1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/dbms/utable/UT_TRANS.CPP Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,740 @@
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 +#else // _ASSERTIONS
1.228 +
1.229 +#define __INVARIANT ( (void)0 )
1.230 +#define __INVARIANT_L ( (void)0 )
1.231 +
1.232 +#endif // _ASSERTIONS
1.233 +
1.234 +inline TDbLockType RDbTransaction::LockState() const
1.235 + { return TDbLockType( iLockState & EState ); }
1.236 +
1.237 +void RDbTransaction::Close()
1.238 + {
1.239 + __ASSERT( !IsLocked() );
1.240 + User::Free( iSharers );
1.241 + Event( RDbNotifier::EClose );
1.242 + }
1.243 +
1.244 +void RDbTransaction::DoCommitL()
1.245 +//
1.246 +// Commit any changes
1.247 +//
1.248 + {
1.249 + __ASSERT_ALWAYS( ( iPrimary.iState & ~ETransactionLock ) == 0, Panic( EDbStreamsPendingOnCommit ) );
1.250 + iLockState |= EFailed;
1.251 + Database().FlushL( LockState() );
1.252 + Database().SynchL( LockState() );
1.253 + Unlock( RDbNotifier::ECommit );
1.254 + }
1.255 +
1.256 +void RDbTransaction::DoRollback()
1.257 +//
1.258 +// Rollback any changes
1.259 +//
1.260 + {
1.261 + __ASSERT_ALWAYS( ( iPrimary.iState & ~ETransactionLock ) == 0, Panic( EDbStreamsPendingOnRollback ) );
1.262 + Database().Revert( LockState() );
1.263 + Database().Abandon( LockState() );
1.264 + if ( LockState() >= EDbWriteLock )
1.265 + ++iRollback;
1.266 + Unlock( RDbNotifier::ERollback );
1.267 + }
1.268 +
1.269 +// explicit transactions
1.270 +
1.271 +void RDbTransaction::BeginL( const CDbObject& aObject )
1.272 +//
1.273 +// begin a user transaction. This first gains a shared read-lock
1.274 +//
1.275 + {
1.276 + __INVARIANT_L;
1.277 + __ASSERT_ALWAYS( GetLock( aObject ) == 0, Panic( EDbBeginNestedTransaction ) );
1.278 + ReadyL();
1.279 + PrepareSLockL( aObject, TUint( ETransactionLock ) );
1.280 + __ASSERT( iAction == EDbReadLock );
1.281 + __ASSERT( iLockState == EDbReadLock );
1.282 + ++iLockCount;
1.283 + }
1.284 +
1.285 +void RDbTransaction::CommitL( const CDbObject& aObject )
1.286 +//
1.287 +// Commit a user transaction and release the lock
1.288 +// All updates must be complete for a write-lock
1.289 +//
1.290 + {
1.291 + __INVARIANT_L;
1.292 + __ASSERT_ALWAYS( InTransaction( aObject ), Panic( EDbNoCurrentTransaction ) );
1.293 + ReadyL();
1.294 + if ( iLockCount > 1 )
1.295 + {
1.296 + TLock* lock = GetLock( aObject );
1.297 + __ASSERT( lock );
1.298 + __ASSERT_ALWAYS( lock->iState == static_cast<TUint>( ETransactionLock ), Panic( EDbStreamsPendingOnCommit ) );
1.299 + Unlock( *lock );
1.300 + }
1.301 + else
1.302 + {
1.303 + __ASSERT_ALWAYS( iAction == EDbReadLock, Panic( EDbUpdatesPendingOnCommit ) );
1.304 + DoCommitL();
1.305 + }
1.306 + }
1.307 +
1.308 +void RDbTransaction::Rollback( const CDbObject& aObject )
1.309 +//
1.310 +// Rollback a user transaction and release the lock
1.311 +// All updates must be complete/aborted for a write-lock
1.312 +//
1.313 + {
1.314 + __INVARIANT;
1.315 + __ASSERT_ALWAYS( InTransaction( aObject ), Panic( EDbNoCurrentTransaction ) );
1.316 + if ( iLockCount > 1 )
1.317 + {
1.318 + TLock* lock = GetLock( aObject );
1.319 + __ASSERT( lock );
1.320 + __ASSERT_ALWAYS( lock->iState == static_cast<TUint>( ETransactionLock ), Panic( EDbStreamsPendingOnRollback ) );
1.321 + Unlock( *lock );
1.322 + }
1.323 + else
1.324 + {
1.325 + __ASSERT_ALWAYS( iAction == EDbReadLock, Panic( EDbUpdatesPendingOnRollback ) );
1.326 + DoRollback();
1.327 + }
1.328 + }
1.329 +
1.330 +void RDbTransaction::PrepareSLockL( const CDbObject& aObject, TUint aInitState )
1.331 +//
1.332 +// prepare to acquire a shared read lock
1.333 +// if any holder has an exclusive lock this fails
1.334 +//
1.335 + {
1.336 + __ASSERT( GetLock( aObject ) == 0 ); // cannot get a 2nd shared lock
1.337 +//
1.338 + THolder h = aObject.Context();
1.339 + if ( iLockCount == 0 )
1.340 + {
1.341 + iPrimary.iHolder = h; // first lock, no other checks required
1.342 + iPrimary.iState = aInitState;
1.343 + }
1.344 + else if ( iLockState != EDbReadLock )
1.345 + __LEAVE( KErrLocked );
1.346 + else
1.347 + { // allocate a Sharers-slot
1.348 + TLock* share = iSharers;
1.349 + if ( iLockCount == iMaxLock )
1.350 + {
1.351 + TInt newsize = iMaxLock + ELockListGranularity;
1.352 + if ( newsize > EMaxLock )
1.353 + {
1.354 + __LEAVE( KErrLocked );
1.355 + return;
1.356 + }
1.357 + iSharers = share = ( TLock* )User::ReAllocL( share, ( newsize - 1 ) * sizeof( TLock ) );
1.358 + iMaxLock = TUint8( newsize );
1.359 + }
1.360 + share += iLockCount - 1;
1.361 + share->iHolder = h;
1.362 + share->iState = aInitState;
1.363 + }
1.364 + }
1.365 +
1.366 +void RDbTransaction::PrepareXLockL( const CDbObject& aObject )
1.367 +//
1.368 +// prepare to acquire an exclusive lock
1.369 +// if any other holder has a lock this fails
1.370 +//
1.371 + {
1.372 + THolder h = aObject.Context();
1.373 + switch ( iLockCount )
1.374 + {
1.375 + case 0: // no other holders, acquire the lock
1.376 + iPrimary.iHolder = h;
1.377 + iPrimary.iState = 0; // this is not a transaction lock
1.378 + break;
1.379 + case 1: // check we are the single Lock holder
1.380 + if (iPrimary.iHolder != h)
1.381 + __LEAVE( KErrLocked );
1.382 + break;
1.383 + default: // cannot get XLock
1.384 + __LEAVE( KErrLocked );
1.385 + break;
1.386 + }
1.387 + }
1.388 +
1.389 +void RDbTransaction::Unlock( RDbNotifier::TEvent aEvent )
1.390 +//
1.391 +// Remove the last lock and signal an event to the Notifier
1.392 +//
1.393 + {
1.394 + __ASSERT( iLockCount == 1 );
1.395 + __ASSERT( ( iPrimary.iState & ~ETransactionLock ) == 0 );
1.396 + TDbLockType ls = LockState();
1.397 + Event( ls == EDbReadLock || ls == EDbXReadLock ? RDbNotifier::EUnlock : aEvent );
1.398 + iLockCount = 0;
1.399 + iAction = iLockState = EDbReadLock;
1.400 + iUpdaters = 0;
1.401 + Database().CheckIdle();
1.402 + }
1.403 +
1.404 +void RDbTransaction::Unlock( RDbTransaction::TLock& aLock )
1.405 +//
1.406 +// Remove a shared lock holder from the list
1.407 +//
1.408 + {
1.409 + __ASSERT( iLockCount > 1 );
1.410 + __ASSERT( LockState() == EDbReadLock );
1.411 + __ASSERT( ( aLock.iState & ~ETransactionLock ) == 0 );
1.412 + aLock = iSharers[--iLockCount - 1];
1.413 + }
1.414 +
1.415 +RDbTransaction::TLock* RDbTransaction::GetLock( const CDbObject& aObject )
1.416 +//
1.417 +// Test if aObject holds any lock, and return it
1.418 +//
1.419 + {
1.420 + const THolder h = aObject.Context();
1.421 + TInt lc = iLockCount;
1.422 + if ( --lc >= 0 )
1.423 + {
1.424 + if ( iPrimary.iHolder == h )
1.425 + return &iPrimary;
1.426 + if ( lc > 0 )
1.427 + {
1.428 + TLock* const base = iSharers;
1.429 + TLock* l = base + lc;
1.430 + do {
1.431 + if ( ( --l )->iHolder == h )
1.432 + return l;
1.433 + } while ( l > base );
1.434 + }
1.435 + }
1.436 + return 0;
1.437 + }
1.438 +
1.439 +TBool RDbTransaction::InTransaction( const CDbObject& aObject )
1.440 +//
1.441 +// Test if aObject holds a non-auto transaction
1.442 +//
1.443 + {
1.444 + __INVARIANT;
1.445 + TLock* lock = GetLock( aObject );
1.446 + return lock ? lock->iState & static_cast<TUint>( ETransactionLock ) : 0;
1.447 + }
1.448 +
1.449 +void RDbTransaction::ReadPrepareL( const CDbObject& aObject )
1.450 +//
1.451 +// Check that aObject can gain a shared read lock and allocate required resources
1.452 +//
1.453 + {
1.454 + __INVARIANT_L;
1.455 + if ( GetLock( aObject ) == 0 )
1.456 + PrepareSLockL( aObject, 0 ); // prepare a S-Lock for the read
1.457 + else if ( iAction == EDbCompactLock ) // Cannot already hold a compaction lock
1.458 + __LEAVE( KErrAccessDenied );
1.459 + }
1.460 +
1.461 +void RDbTransaction::ReadBegin( const CDbObject& aObject )
1.462 +//
1.463 +// Take a read-lock: ReadPrepareL(aObject) _must_ already have been called
1.464 +//
1.465 + {
1.466 + __INVARIANT;
1.467 + TLock* lock = GetLock( aObject );
1.468 + if ( !lock )
1.469 + {
1.470 + ++iLockCount;
1.471 + lock = GetLock( aObject );
1.472 + __ASSERT( lock );
1.473 + }
1.474 + ++lock->iState;
1.475 + }
1.476 +
1.477 +void RDbTransaction::ReadRelease( const CDbObject& aObject )
1.478 + {
1.479 + __INVARIANT;
1.480 + TLock* lock = GetLock( aObject );
1.481 + __ASSERT( lock );
1.482 + __ASSERT( ( lock->iState & ~ETransactionLock ) > 0 );
1.483 + if ( --lock->iState == 0 )
1.484 + { // not transaction-lock
1.485 + if ( iLockCount > 1 )
1.486 + Unlock( *lock );
1.487 + else if ( iAction == EDbReadLock ) // no other locks to this client
1.488 + Unlock( RDbNotifier::EUnlock );
1.489 + }
1.490 + }
1.491 +
1.492 +void RDbTransaction::DMLCheckL()
1.493 +//
1.494 +// Check that we can open a new rowset
1.495 +//
1.496 + {
1.497 + __INVARIANT_L;
1.498 + ReadyL();
1.499 + if ( iAction > EDbCompactLock )
1.500 + __LEAVE( KErrAccessDenied );
1.501 + }
1.502 +
1.503 +void RDbTransaction::DMLPrepareL( const CDbObject& aObject )
1.504 +//
1.505 +// Check that we can do DML, this should be called immediately prior to DMLBegin
1.506 +//
1.507 + {
1.508 + __INVARIANT_L;
1.509 + PrepareXLockL( aObject );
1.510 + if ( iAction>EDbWriteLock )
1.511 + __LEAVE( KErrAccessDenied );
1.512 + }
1.513 +
1.514 +void RDbTransaction::DMLBegin()
1.515 +//
1.516 +// A Rowset begins an update
1.517 +//
1.518 + {
1.519 + __INVARIANT;
1.520 + __ASSERT( iAction == EDbReadLock || iAction == EDbWriteLock );
1.521 + __ASSERT( ( iLockState & EFailed ) == 0 );
1.522 + __ASSERT( iLockCount <= 1 );
1.523 + if ( iAction == EDbReadLock )
1.524 + iAction = EDbWriteLock;
1.525 + if (iLockState == EDbReadLock )
1.526 + iLockState = EDbXReadLock; // escalate lock to exclusive as we are now writing
1.527 + ++iUpdaters;
1.528 + iLockCount = 1;
1.529 + }
1.530 +
1.531 +void RDbTransaction::DMLTouch()
1.532 +//
1.533 +// This must be called prior to putting DML updates
1.534 +//
1.535 + {
1.536 + __ASSERT( iAction == EDbWriteLock );
1.537 + __ASSERT( iUpdaters > 0 );
1.538 + TInt ls = iLockState;
1.539 + if ( ls == EDbXReadLock )
1.540 + ls = EDbWriteLock | EFailed;
1.541 + else
1.542 + ls |= EFailed;
1.543 + iLockState = TUint8( ls );
1.544 + }
1.545 +
1.546 +void RDbTransaction::DMLBeginLC()
1.547 + {
1.548 + DMLBegin();
1.549 + CleanupStack::PushL( TCleanupItem( DMLAbandon, this ) );
1.550 + DMLTouch();
1.551 + }
1.552 +
1.553 +void RDbTransaction::DMLCommitL()
1.554 +//
1.555 +// A rowset has completed an update
1.556 +//
1.557 + {
1.558 + __INVARIANT_L;
1.559 + __ASSERT( iAction == EDbWriteLock && ( iLockState & EFailed ) );
1.560 + TInt updaters = iUpdaters - 1;
1.561 + if ( updaters == 0 )
1.562 + {
1.563 + if ( ( iPrimary.iState & static_cast<TUint>( ETransactionLock ) ) == 0 )
1.564 + {
1.565 + __ASSERT( iLockState == ( EDbWriteLock | EFailed ) );
1.566 + DoCommitL(); // automatic write-commit, release auto-lock
1.567 + return;
1.568 + }
1.569 + iAction = EDbReadLock;
1.570 + }
1.571 + iUpdaters = updaters;
1.572 + iLockState &= ~EFailed;
1.573 + }
1.574 +
1.575 +void RDbTransaction::DMLRollback()
1.576 +//
1.577 +// Rollback a DML operation
1.578 +//
1.579 + {
1.580 + __INVARIANT;
1.581 + __ASSERT( iAction == EDbWriteLock );
1.582 + TInt updates = iUpdaters - 1;
1.583 + if ( updates == 0 )
1.584 + {
1.585 + if ( ( iPrimary.iState & static_cast<TUint>( ETransactionLock ) ) == 0 )
1.586 + {
1.587 + __ASSERT( LockState() == EDbWriteLock || LockState() == EDbXReadLock );
1.588 + DoRollback(); // automatic rollback now (may panic)
1.589 + return;
1.590 + }
1.591 + iAction = EDbReadLock;
1.592 + }
1.593 + iUpdaters = updates;
1.594 + }
1.595 +
1.596 +void RDbTransaction::DMLAbandon( TAny* aPtr )
1.597 + {
1.598 + STATIC_CAST( RDbTransaction*, aPtr )->DMLRollback();
1.599 + }
1.600 +
1.601 +void RDbTransaction::DDLPrepareL( const CDbObject& aObject )
1.602 +//
1.603 +// Check that we can use the database for ddl and flush out any tables
1.604 +// should be called before DDLBegin
1.605 +//
1.606 + {
1.607 + __INVARIANT_L;
1.608 + ReadyL();
1.609 + PrepareXLockL( aObject );
1.610 + if ( iAction != EDbReadLock || ( IsLocked() && iPrimary.iState != static_cast<TUint>( ETransactionLock ) ) )
1.611 + __LEAVE( KErrAccessDenied ); // Cannot take sole ownership of the database
1.612 + TInt ls = iLockState;
1.613 + if ( ls >= EDbWriteLock )
1.614 + { // ensure all table data is flushed as they may be "released"
1.615 + iLockState = TUint8( ls | EFailed );
1.616 + Database().FlushL( EDbWriteLock );
1.617 + iLockState = TUint8( ls );
1.618 + }
1.619 + }
1.620 +
1.621 +void RDbTransaction::DDLBegin()
1.622 +//
1.623 +// A DDL object is about to start ops
1.624 +//
1.625 + {
1.626 + __INVARIANT;
1.627 + __ASSERT( iAction == EDbReadLock );
1.628 + __ASSERT( ( iLockState & EFailed ) == 0 );
1.629 + __ASSERT( iLockCount <= 1 );
1.630 + iLockState = iAction = EDbSchemaLock;
1.631 + iLockCount = 1;
1.632 + }
1.633 +
1.634 +void RDbTransaction::DDLBeginLC()
1.635 + {
1.636 + DDLBegin();
1.637 + CleanupStack::PushL( TCleanupItem( DDLAbandon, this ) );
1.638 + }
1.639 +
1.640 +void RDbTransaction::DDLCommitL()
1.641 +//
1.642 +// A DDL incremental object has completed
1.643 +//
1.644 + {
1.645 + __INVARIANT_L;
1.646 + __ASSERT( iAction == EDbSchemaLock );
1.647 + if ( ( iPrimary.iState & static_cast<TUint>( ETransactionLock ) ) == 0 )
1.648 + {
1.649 + __ASSERT( iLockState == EDbSchemaLock );
1.650 + DoCommitL(); // release auto-lock
1.651 + }
1.652 + else
1.653 + iAction = EDbReadLock;
1.654 + }
1.655 +
1.656 +void RDbTransaction::DDLRollback()
1.657 +//
1.658 +// Rollback a DDL operation
1.659 +//
1.660 + {
1.661 + __INVARIANT;
1.662 + __ASSERT( iAction == EDbSchemaLock );
1.663 + iLockState |= EFailed;
1.664 + if ( ( iPrimary.iState & static_cast<TUint>( ETransactionLock ) ) == 0 )
1.665 + {
1.666 + __ASSERT( iLockState == ( EDbSchemaLock | EFailed ) );
1.667 + DoRollback(); // release auto-lock
1.668 + }
1.669 + else
1.670 + iAction = EDbReadLock;
1.671 + }
1.672 +
1.673 +void RDbTransaction::DDLAbandon( TAny* aPtr )
1.674 + {
1.675 + STATIC_CAST( RDbTransaction*, aPtr )->DDLRollback();
1.676 + }
1.677 +
1.678 +// recovery. Nothing else can be done at the same time as this
1.679 +
1.680 +void RDbTransaction::UtilityPrepareL( const CDbObject& aObject )
1.681 +//
1.682 +// Check that we are in a state to run a utility
1.683 +//
1.684 + {
1.685 + __INVARIANT_L;
1.686 + ReadyL();
1.687 + PrepareXLockL( aObject );
1.688 + if ( IsLocked() ) // utilities not allowed in user transaction
1.689 + __LEAVE( KErrAccessDenied );
1.690 + }
1.691 +
1.692 +void RDbTransaction::UtilityBegin( CDbDatabase::TUtility aType )
1.693 +//
1.694 +// Database Recovery object is about to start
1.695 +//
1.696 + {
1.697 + __INVARIANT;
1.698 + __ASSERT( !IsLocked() );
1.699 + if ( aType == CDbDatabase::ERecover )
1.700 + iLockState = iAction = EDbRecoveryLock;
1.701 + else
1.702 + iLockState = iAction = EDbCompactLock;
1.703 + iLockCount = 1;
1.704 + }
1.705 +
1.706 +void RDbTransaction::UtilityCommitL()
1.707 +//
1.708 +// Database Recovery has completed
1.709 +//
1.710 + {
1.711 + __INVARIANT_L;
1.712 + Database().SynchL( LockState() );
1.713 + Unlock( iAction == EDbRecoveryLock ? RDbNotifier::ERecover : RDbNotifier::EUnlock ); // release auto-lock
1.714 + }
1.715 +
1.716 +void RDbTransaction::UtilityRollback()
1.717 + {
1.718 + __INVARIANT;
1.719 + Database().Revert( LockState() );
1.720 + Unlock( RDbNotifier::EUnlock ); // release auto-lock
1.721 + }
1.722 +
1.723 +CDbNotifier* RDbTransaction::NotifierL()
1.724 +//
1.725 +// Only support a single notifier for the database (server multiplexes)
1.726 +//
1.727 + {
1.728 + if ( iNotifier )
1.729 + __LEAVE( KErrNotSupported );
1.730 + return iNotifier = new( ELeave ) CNotifier( *this );
1.731 + }
1.732 +
1.733 +void RDbTransaction::Event( RDbNotifier::TEvent aEvent )
1.734 +//
1.735 +// Report an event to the Notifier
1.736 +// If the lock was less than a write lock, report unlock only: no commit or rollback
1.737 +//
1.738 + {
1.739 + if ( iNotifier )
1.740 + iNotifier->Event( aEvent );
1.741 + }
1.742 +
1.743 +