sl@0: // Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).
sl@0: // All rights reserved.
sl@0: // This component and the accompanying materials are made available
sl@0: // under the terms of "Eclipse Public License v1.0"
sl@0: // which accompanies this distribution, and is available
sl@0: // at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0: //
sl@0: // Initial Contributors:
sl@0: // Nokia Corporation - initial contribution.
sl@0: //
sl@0: // Contributors:
sl@0: //
sl@0: // Description:
sl@0: //
sl@0: 
sl@0: #include "UT_STD.H"
sl@0: 
sl@0: // Class RDbTransaction::CNotifier
sl@0: 
sl@0: NONSHARABLE_CLASS(RDbTransaction::CNotifier) : public CDbNotifier
sl@0: 	{
sl@0: public:
sl@0: 	inline CNotifier( RDbTransaction& aTransaction );
sl@0: 	~CNotifier();
sl@0: //
sl@0: //	void Event( RDbNotifier::TEvent aEvent );
sl@0: private:
sl@0: //	void Complete( TInt aStatus );
sl@0: // from CDbNotifier
sl@0: //	void Notify( TType aEvent, TRequestStatus& aStatus );
sl@0: 	void Cancel();
sl@0: private:
sl@0: 	RDbTransaction* iTransaction;
sl@0: //	TRequestStatus* iStatus;
sl@0: 	TInt iPending;
sl@0: 	};
sl@0: 
sl@0: inline RDbTransaction::CNotifier::CNotifier( RDbTransaction& aTransaction )
sl@0:  :	iTransaction( &aTransaction )
sl@0: 	{}
sl@0: 
sl@0: RDbTransaction::CNotifier::~CNotifier()
sl@0: //
sl@0: // Cancel any outstanding request and extract from the transaction
sl@0: //
sl@0: 	{
sl@0: 	Cancel();
sl@0: 	if ( iTransaction )
sl@0: 		{
sl@0: 		__ASSERT( iTransaction->iNotifier == this );
sl@0: 		iTransaction->iNotifier = 0;
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: //void RDbTransaction::CNotifier::Complete( TInt aStatus )
sl@0: //	{
sl@0: //	if ( iStatus )
sl@0: //		{
sl@0: //		iPending = 0;
sl@0: //		User::RequestComplete( iStatus, aStatus );
sl@0: //		}
sl@0: //	}
sl@0: 
sl@0: //void RDbTransaction::CNotifier::Notify( CDbNotifier::TType aType, TRequestStatus& aStatus )
sl@0: ////
sl@0: //// Request for future notification. If the database is closed complete immediately
sl@0: ////
sl@0: //	{
sl@0: //	__ASSERT( !iStatus );
sl@0: //	__ASSERT( iPending >= 0 );
sl@0: //	iStatus = &aStatus;
sl@0: //	if ( iPending > RDbNotifier::EUnlock )
sl@0: //		Complete( iPending );
sl@0: //	else if ( !iTransaction )
sl@0: //		Complete( RDbNotifier::EClose );
sl@0: //	else
sl@0: //		{
sl@0: //		iPending = aType;
sl@0: //		aStatus = KRequestPending;
sl@0: //		}
sl@0: //	}
sl@0: 
sl@0: void RDbTransaction::CNotifier::Cancel()
sl@0: 	{
sl@0: //	Complete( KErrCancel );
sl@0: 	}
sl@0: 
sl@0: //void RDbTransaction::CNotifier::Event( RDbNotifier::TEvent aEvent )
sl@0: //	{
sl@0: //	if ( aEvent == RDbNotifier::EClose )
sl@0: //		iTransaction = 0;
sl@0: //	if ( iStatus )
sl@0: //		{
sl@0: //		__ASSERT( iPending < 0 );
sl@0: //		if (aEvent == RDbNotifier::EUnlock && iPending == CDbNotifier::EChange )
sl@0: //			;	// not interested in unlock events
sl@0: //		else
sl@0: //			Complete( aEvent );
sl@0: //		}
sl@0: //	else
sl@0: //		{
sl@0: //		__ASSERT( iPending >= 0 );
sl@0: //		if ( aEvent > iPending )
sl@0: //			iPending = aEvent;		// save the event
sl@0: //		}
sl@0: //	}
sl@0: 
sl@0: 
sl@0: // Class RDbTransaction
sl@0: 
sl@0: #ifdef _ASSERTIONS
sl@0: 
sl@0: //void RDbTransaction::_Invariant() const
sl@0: ////
sl@0: //// Invariance test
sl@0: ////
sl@0: //	{
sl@0: //	if ( iLockCount == 0 )
sl@0: //		{	// nothing must be happening in this state
sl@0: //		__ASSERT( iLockState == EDbReadLock );
sl@0: //		__ASSERT( iAction == EDbReadLock );
sl@0: //		__ASSERT( iUpdaters == 0 );
sl@0: //		return;
sl@0: //		}
sl@0: //	switch ( iLockState & EState )
sl@0: //		{
sl@0: //	default:
sl@0: //		__ASSERT( 0 );
sl@0: //	case EDbReadLock:
sl@0: //		{
sl@0: //		__ASSERT( iAction == EDbReadLock );
sl@0: //		__ASSERT( iLockCount > 0 );		// someone must have a lock
sl@0: //		__ASSERT( iLockCount <= iMaxLock );
sl@0: //		__ASSERT( iUpdaters == 0 );
sl@0: //		__ASSERT( iPrimary.iState != 0 );
sl@0: //		for (TInt ii = iLockCount - 1; --ii >= 0; )
sl@0: //			__ASSERT( iSharers[ii].iState != 0 );
sl@0: //		}
sl@0: //		break;
sl@0: //	case EDbCompactLock:		// not allowed in user-transactions
sl@0: //	case EDbRecoveryLock:
sl@0: //		__ASSERT( iAction == iLockState );
sl@0: //		__ASSERT( iLockCount == 1 );	// exactly one lock allowed
sl@0: //		__ASSERT( iUpdaters == 0 );
sl@0: //		__ASSERT( iPrimary.iState == 0 );
sl@0: //		break;
sl@0: //	case EDbXReadLock:	// intention to write. No updates but exclusive
sl@0: //		__ASSERT( iLockCount == 1 );	// exactly one lock allowed
sl@0: //		switch ( iAction )
sl@0: //			{
sl@0: //		default:
sl@0: //			__ASSERT( 0 );
sl@0: //		case EDbReadLock:	// must be in a transaction: cannot commit a write/schema mod when releasing a read lock
sl@0: //			__ASSERT( iUpdaters == 0 );
sl@0: //			__ASSERT( iPrimary.iState & static_cast<TUint>( ETransactionLock ) );
sl@0: //			break;
sl@0: //		case EDbWriteLock:
sl@0: //			__ASSERT( iUpdaters > 0 );
sl@0: //			break;
sl@0: //			}
sl@0: //		break;
sl@0: //	case EDbWriteLock:
sl@0: //	case EDbSchemaLock:
sl@0: //		__ASSERT( iLockCount == 1 );	// exactly one lock allowed
sl@0: //		switch ( iAction )
sl@0: //			{
sl@0: //		default:
sl@0: //			__ASSERT( 0 );
sl@0: //		case EDbReadLock:	// must be in a transaction: cannot commit a write/schema mod when releasing a read lock
sl@0: //			__ASSERT( iUpdaters == 0 );
sl@0: //			__ASSERT( iPrimary.iState & static_cast<TUint>( ETransactionLock ) );
sl@0: //			break;
sl@0: //		case EDbWriteLock:
sl@0: //			__ASSERT( iUpdaters > 0 );
sl@0: //			__ASSERT( ( iLockState & EState ) == EDbWriteLock || ( iPrimary.iState & static_cast<TUint>( ETransactionLock ) ) );
sl@0: //			break;
sl@0: //		case EDbSchemaLock:
sl@0: //			__ASSERT( ( iLockState & EState ) == EDbSchemaLock );
sl@0: //			__ASSERT( iUpdaters == 0 );
sl@0: //			break;
sl@0: //			}
sl@0: //		break;
sl@0: //		}
sl@0: //	}
sl@0: 
sl@0: //template <class T> struct _InvariantFunc
sl@0: //	{
sl@0: //	static void Invariant( TAny* aPtr ) { ( (const T*)aPtr )->_Invariant(); }
sl@0: //	};
sl@0: //
sl@0: //template <class T> inline TCleanupOperation _InvariantFunction( T* )
sl@0: //	{ return _InvariantFunc<T>::Invariant; }
sl@0: //
sl@0: //struct _Invariant
sl@0: //	{
sl@0: //	inline _Invariant( TCleanupOperation aOp, TAny* aPtr )
sl@0: //	 :	iOp( aOp ), iPtr( aPtr )
sl@0: //		{ aOp( aPtr ); }
sl@0: //	inline ~_Invariant()
sl@0: //		{ iOp( iPtr ); }
sl@0: //private:
sl@0: //	TCleanupOperation iOp;
sl@0: //	TAny* iPtr;
sl@0: //	};
sl@0: 
sl@0: #ifndef __LEAVE_EQUALS_THROW
sl@0: //struct _InvariantL
sl@0: //	{
sl@0: //	inline _InvariantL( TCleanupOperation aOp, TAny* aPtr )
sl@0: //		{ aOp( aPtr ); CleanupStack::PushL( TCleanupItem( aOp, aPtr ) ); }
sl@0: //	inline ~_InvariantL()
sl@0: //        { CleanupStack::PopAndDestroy(); }
sl@0: //	};
sl@0: #endif //__LEAVE_EQUALS_THROW__
sl@0: 
sl@0: //#define __INVARIANT   struct _Invariant _invariant( _InvariantFunction( this ), this );
sl@0: 
sl@0: //#ifdef __LEAVE_EQUALS_THROW__
sl@0: //	#define __INVARIANT_L __INVARIANT
sl@0: //#else
sl@0: //	#define __INVARIANT_L struct _InvariantL _invariant( _InvariantFunction( this ), this );
sl@0: //#endif //__LEAVE_EQUALS_THROW__
sl@0: 
sl@0: #define __INVARIANT   ( (void)0 )
sl@0: #define __INVARIANT_L ( (void)0 )
sl@0: #else // _ASSERTIONS
sl@0: 
sl@0: #define __INVARIANT   ( (void)0 )
sl@0: #define __INVARIANT_L ( (void)0 )
sl@0: 
sl@0: #endif // _ASSERTIONS
sl@0: 
sl@0: inline TDbLockType RDbTransaction::LockState() const
sl@0: 	{ return TDbLockType( iLockState & EState ); }
sl@0: 
sl@0: void RDbTransaction::Close()
sl@0: 	{
sl@0: 	__ASSERT( !IsLocked() );
sl@0: 	User::Free( iSharers );
sl@0: //	Event( RDbNotifier::EClose );
sl@0: 	}
sl@0: 
sl@0: void RDbTransaction::DoCommitL()
sl@0: //
sl@0: // Commit any changes
sl@0: //
sl@0: 	{
sl@0: 	__ASSERT_ALWAYS( ( iPrimary.iState & ~ETransactionLock ) == 0, Panic( EDbStreamsPendingOnCommit ) );
sl@0: 	iLockState |= EFailed;
sl@0: 	Database().FlushL( LockState() );
sl@0: 	Database().SynchL( LockState() );
sl@0: 	Unlock( RDbNotifier::ECommit );
sl@0: 	}
sl@0: 
sl@0: void RDbTransaction::DoRollback()
sl@0: //
sl@0: // Rollback any changes
sl@0: //
sl@0: 	{
sl@0: 	__ASSERT_ALWAYS( ( iPrimary.iState & ~ETransactionLock ) == 0, Panic( EDbStreamsPendingOnRollback ) );
sl@0: 	Database().Revert( LockState() );
sl@0: 	Database().Abandon( LockState() );
sl@0: 	if ( LockState() >= EDbWriteLock )
sl@0: 		++iRollback;
sl@0: 	Unlock( RDbNotifier::ERollback );
sl@0: 	}
sl@0: 
sl@0: // explicit transactions
sl@0: 
sl@0: void RDbTransaction::BeginL( const CDbObject& aObject )
sl@0: //
sl@0: // begin a user transaction. This first gains a shared read-lock
sl@0: //
sl@0: 	{
sl@0: 	__INVARIANT_L;
sl@0: 	__ASSERT_ALWAYS( GetLock( aObject ) == 0, Panic( EDbBeginNestedTransaction ) );
sl@0: 	ReadyL();
sl@0: 	PrepareSLockL( aObject, TUint( ETransactionLock ) );
sl@0: 	__ASSERT( iAction == EDbReadLock );
sl@0: 	__ASSERT( iLockState == EDbReadLock );
sl@0: 	++iLockCount;
sl@0: 	}
sl@0: 
sl@0: void RDbTransaction::CommitL( const CDbObject& aObject )
sl@0: //
sl@0: // Commit a user transaction and release the lock
sl@0: // All updates must be complete for a write-lock
sl@0: //
sl@0: 	{
sl@0: 	__INVARIANT_L;
sl@0: 	__ASSERT_ALWAYS( InTransaction( aObject ), Panic( EDbNoCurrentTransaction ) );
sl@0: 	ReadyL();
sl@0: 	if ( iLockCount > 1 )
sl@0: 		{
sl@0: 		TLock* lock = GetLock( aObject );
sl@0: 		__ASSERT( lock );
sl@0: 		__ASSERT_ALWAYS( lock->iState == static_cast<TUint>( ETransactionLock ), Panic( EDbStreamsPendingOnCommit ) );
sl@0: 		Unlock( *lock );
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		__ASSERT_ALWAYS( iAction == EDbReadLock, Panic( EDbUpdatesPendingOnCommit ) );
sl@0: 		DoCommitL();
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: void RDbTransaction::Rollback( const CDbObject& aObject )
sl@0: //
sl@0: // Rollback a user transaction and release the lock
sl@0: // All updates must be complete/aborted for a write-lock
sl@0: //
sl@0: 	{
sl@0: 	__INVARIANT;
sl@0: 	__ASSERT_ALWAYS( InTransaction( aObject ), Panic( EDbNoCurrentTransaction ) );
sl@0: 	if ( iLockCount > 1 )
sl@0: 		{
sl@0: 		TLock* lock = GetLock( aObject );
sl@0: 		__ASSERT( lock );
sl@0: 		__ASSERT_ALWAYS( lock->iState == static_cast<TUint>( ETransactionLock ), Panic( EDbStreamsPendingOnRollback ) );
sl@0: 		Unlock( *lock );
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		__ASSERT_ALWAYS( iAction == EDbReadLock, Panic( EDbUpdatesPendingOnRollback ) );
sl@0: 		DoRollback();
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: void RDbTransaction::PrepareSLockL( const CDbObject& aObject, TUint aInitState )
sl@0: //
sl@0: // prepare to acquire a shared read lock
sl@0: // if any holder has an exclusive lock this fails
sl@0: //
sl@0: 	{
sl@0: 	__ASSERT( GetLock( aObject ) == 0 );	// cannot get a 2nd shared lock
sl@0: //
sl@0: 	THolder h = aObject.Context();
sl@0: 	if ( iLockCount == 0 )
sl@0: 		{
sl@0: 		iPrimary.iHolder = h;				// first lock, no other checks required
sl@0: 		iPrimary.iState = aInitState;
sl@0: 		}
sl@0: 	else if ( iLockState != EDbReadLock )
sl@0: 		__LEAVE( KErrLocked );
sl@0: 	else
sl@0: 		{						// allocate a Sharers-slot
sl@0: 		TLock* share = iSharers;
sl@0: 		if ( iLockCount == iMaxLock )
sl@0: 			{
sl@0: 			TInt newsize = iMaxLock + ELockListGranularity;
sl@0: 			if ( newsize > EMaxLock )
sl@0: 				{
sl@0: 				__LEAVE( KErrLocked );
sl@0: 				return;
sl@0: 				}
sl@0: 			iSharers = share = ( TLock* )User::ReAllocL( share, ( newsize - 1 ) * sizeof( TLock ) );
sl@0: 			iMaxLock = TUint8( newsize );
sl@0: 			}
sl@0: 		share += iLockCount - 1;
sl@0: 		share->iHolder = h;
sl@0: 		share->iState = aInitState;
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: void RDbTransaction::PrepareXLockL( const CDbObject& aObject )
sl@0: //
sl@0: // prepare to acquire an exclusive lock
sl@0: // if any other holder has a lock this fails
sl@0: //
sl@0: 	{
sl@0: 	THolder h = aObject.Context();
sl@0: 	switch ( iLockCount )
sl@0: 		{
sl@0: 	case 0:					// no other holders, acquire the lock
sl@0: 		iPrimary.iHolder = h;
sl@0: 		iPrimary.iState = 0;		// this is not a transaction lock
sl@0: 		break;
sl@0: 	case 1:					// check we are the single Lock holder
sl@0: 		if (iPrimary.iHolder != h)
sl@0: 			__LEAVE( KErrLocked );
sl@0: 		break;
sl@0: 	default:				// cannot get XLock
sl@0: 		__LEAVE( KErrLocked );
sl@0: 		break;
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: void RDbTransaction::Unlock( RDbNotifier::TEvent aEvent )
sl@0: //
sl@0: // Remove the last lock and signal an event to the Notifier
sl@0: //
sl@0: 	{
sl@0: 	__ASSERT( iLockCount == 1 );
sl@0: 	__ASSERT( ( iPrimary.iState & ~ETransactionLock ) == 0 );
sl@0: 	TDbLockType ls = LockState();
sl@0: 	Event( ls == EDbReadLock || ls == EDbXReadLock ? RDbNotifier::EUnlock : aEvent );
sl@0: 	iLockCount = 0;
sl@0: 	iAction = iLockState = EDbReadLock;
sl@0: 	iUpdaters = 0;
sl@0: 	Database().CheckIdle();
sl@0: 	}
sl@0: 
sl@0: void RDbTransaction::Unlock( RDbTransaction::TLock& aLock )
sl@0: //
sl@0: // Remove a shared lock holder from the list
sl@0: //
sl@0: 	{
sl@0: 	__ASSERT( iLockCount > 1 );
sl@0: 	__ASSERT( LockState() == EDbReadLock );
sl@0: 	__ASSERT( ( aLock.iState & ~ETransactionLock ) == 0 );
sl@0: 	aLock = iSharers[--iLockCount - 1];
sl@0: 	}
sl@0: 
sl@0: RDbTransaction::TLock* RDbTransaction::GetLock( const CDbObject& aObject )
sl@0: //
sl@0: // Test if aObject holds any lock, and return it
sl@0: //
sl@0: 	{
sl@0: 	const THolder h = aObject.Context();
sl@0: 	TInt lc = iLockCount;
sl@0: 	if ( --lc >= 0 )
sl@0: 		{
sl@0: 		if ( iPrimary.iHolder == h )
sl@0: 			return &iPrimary;
sl@0: 		if ( lc > 0 )
sl@0: 			{
sl@0: 			TLock* const base = iSharers;
sl@0: 			TLock* l = base + lc;
sl@0: 			do	{
sl@0: 				if ( ( --l )->iHolder == h )
sl@0: 					return l;
sl@0: 				} while ( l > base );
sl@0: 			}
sl@0: 		}
sl@0: 	return 0;
sl@0: 	}
sl@0: 
sl@0: TBool RDbTransaction::InTransaction( const CDbObject& aObject )
sl@0: //
sl@0: // Test if aObject holds a non-auto transaction
sl@0: //
sl@0: 	{
sl@0: 	__INVARIANT;
sl@0: 	TLock* lock = GetLock( aObject );
sl@0: 	return lock ? lock->iState & static_cast<TUint>( ETransactionLock ) : 0;
sl@0: 	}
sl@0: 
sl@0: void RDbTransaction::ReadPrepareL( const CDbObject& aObject )
sl@0: //
sl@0: // Check that aObject can gain a shared read lock and allocate required resources
sl@0: //
sl@0: 	{
sl@0: 	__INVARIANT_L;
sl@0: 	if ( GetLock( aObject ) == 0 )
sl@0: 		PrepareSLockL( aObject, 0 );		// prepare a S-Lock for the read
sl@0: 	else if ( iAction == EDbCompactLock )	// Cannot already hold a compaction lock
sl@0: 		__LEAVE( KErrAccessDenied );
sl@0: 	}
sl@0: 
sl@0: void RDbTransaction::ReadBegin( const CDbObject& aObject )
sl@0: //
sl@0: // Take a read-lock: ReadPrepareL(aObject) _must_ already have been called
sl@0: //
sl@0: 	{
sl@0: 	__INVARIANT;
sl@0: 	TLock* lock = GetLock( aObject );
sl@0: 	if ( !lock )
sl@0: 		{
sl@0: 		++iLockCount;
sl@0: 		lock = GetLock( aObject );
sl@0: 		__ASSERT( lock );
sl@0: 		}
sl@0: 	++lock->iState;
sl@0: 	}
sl@0: 
sl@0: void RDbTransaction::ReadRelease( const CDbObject& aObject )
sl@0: 	{
sl@0: 	__INVARIANT;
sl@0: 	TLock* lock = GetLock( aObject );
sl@0: 	__ASSERT( lock );
sl@0: 	__ASSERT( ( lock->iState & ~ETransactionLock ) > 0 );
sl@0: 	if ( --lock->iState == 0 )
sl@0: 		{	// not transaction-lock
sl@0: 		if ( iLockCount > 1 )
sl@0: 			Unlock( *lock );
sl@0: 		else if ( iAction == EDbReadLock )	// no other locks to this client
sl@0: 			Unlock( RDbNotifier::EUnlock );
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: void RDbTransaction::DMLCheckL()
sl@0: //
sl@0: // Check that we can open a new rowset
sl@0: //
sl@0: 	{
sl@0: 	__INVARIANT_L;
sl@0: 	ReadyL();
sl@0: 	if ( iAction > EDbCompactLock )	
sl@0: 		__LEAVE( KErrAccessDenied );
sl@0: 	}
sl@0: 
sl@0: void RDbTransaction::DMLPrepareL( const CDbObject& aObject )
sl@0: //
sl@0: // Check that we can do DML, this should be called immediately prior to DMLBegin
sl@0: //
sl@0: 	{
sl@0: 	__INVARIANT_L;
sl@0: 	PrepareXLockL( aObject );
sl@0: 	if ( iAction>EDbWriteLock )
sl@0: 		__LEAVE( KErrAccessDenied );
sl@0: 	}
sl@0: 
sl@0: void RDbTransaction::DMLBegin()
sl@0: //
sl@0: // A Rowset begins an update
sl@0: //
sl@0: 	{
sl@0: 	__INVARIANT;
sl@0: 	__ASSERT( iAction == EDbReadLock || iAction == EDbWriteLock );
sl@0: 	__ASSERT( ( iLockState & EFailed ) == 0 );
sl@0: 	__ASSERT( iLockCount <= 1 );
sl@0: 	if ( iAction == EDbReadLock )
sl@0: 		iAction = EDbWriteLock;
sl@0: 	if (iLockState == EDbReadLock )
sl@0: 		iLockState = EDbXReadLock;		// escalate lock to exclusive as we are now writing
sl@0: 	++iUpdaters;
sl@0: 	iLockCount = 1;
sl@0: 	}
sl@0: 
sl@0: void RDbTransaction::DMLTouch()
sl@0: //
sl@0: // This must be called prior to putting DML updates
sl@0: //
sl@0: 	{
sl@0: 	__ASSERT( iAction == EDbWriteLock );
sl@0: 	__ASSERT( iUpdaters > 0 );
sl@0: 	TInt ls = iLockState;
sl@0: 	if ( ls == EDbXReadLock )
sl@0: 		ls = EDbWriteLock | EFailed;
sl@0: 	else
sl@0: 		ls |= EFailed;
sl@0: 	iLockState = TUint8( ls );
sl@0: 	}
sl@0: 
sl@0: void RDbTransaction::DMLBeginLC()
sl@0: 	{
sl@0: 	DMLBegin();
sl@0: 	CleanupStack::PushL( TCleanupItem( DMLAbandon, this ) );
sl@0: 	DMLTouch();
sl@0: 	}
sl@0: 
sl@0: void RDbTransaction::DMLCommitL()
sl@0: //
sl@0: // A rowset has completed an update
sl@0: //
sl@0: 	{
sl@0: 	__INVARIANT_L;
sl@0: 	__ASSERT( iAction == EDbWriteLock && ( iLockState & EFailed ) );
sl@0: 	TInt updaters = iUpdaters - 1;
sl@0: 	if ( updaters == 0 )
sl@0: 		{
sl@0: 		if ( ( iPrimary.iState & static_cast<TUint>( ETransactionLock ) ) == 0 )
sl@0: 			{
sl@0: 			__ASSERT( iLockState == ( EDbWriteLock | EFailed ) );
sl@0: 			DoCommitL();		// automatic write-commit, release auto-lock
sl@0: 			return;
sl@0: 			}
sl@0: 		iAction = EDbReadLock;
sl@0: 		}
sl@0: 	iUpdaters = updaters;
sl@0: 	iLockState &= ~EFailed;
sl@0: 	}
sl@0: 
sl@0: void RDbTransaction::DMLRollback()
sl@0: //
sl@0: // Rollback a DML operation
sl@0: //
sl@0: 	{
sl@0: 	__INVARIANT;
sl@0: 	__ASSERT( iAction == EDbWriteLock );
sl@0: 	TInt updates = iUpdaters - 1;
sl@0: 	if ( updates == 0 )
sl@0: 		{
sl@0: 		if ( ( iPrimary.iState & static_cast<TUint>( ETransactionLock ) ) == 0 )
sl@0: 			{
sl@0: 			__ASSERT( LockState() == EDbWriteLock || LockState() == EDbXReadLock );
sl@0: 			DoRollback();		// automatic rollback now (may panic)
sl@0: 			return;
sl@0: 			}
sl@0: 		iAction = EDbReadLock;
sl@0: 		}
sl@0: 	iUpdaters = updates;
sl@0: 	}
sl@0: 
sl@0: void RDbTransaction::DMLAbandon( TAny* aPtr )
sl@0: 	{
sl@0: 	STATIC_CAST( RDbTransaction*, aPtr )->DMLRollback();
sl@0: 	}
sl@0: 
sl@0: void RDbTransaction::DDLPrepareL( const CDbObject& aObject )
sl@0: //
sl@0: // Check that we can use the database for ddl and flush out any tables
sl@0: // should be called before DDLBegin
sl@0: //
sl@0: 	{
sl@0: 	__INVARIANT_L;
sl@0: 	ReadyL();
sl@0: 	PrepareXLockL( aObject );
sl@0: 	if ( iAction != EDbReadLock || ( IsLocked() && iPrimary.iState != static_cast<TUint>( ETransactionLock ) ) )
sl@0: 		__LEAVE( KErrAccessDenied );	// Cannot take sole ownership of the database
sl@0: 	TInt ls = iLockState;
sl@0: 	if ( ls >= EDbWriteLock )
sl@0: 		{	// ensure all table data is flushed as they may be "released"
sl@0: 		iLockState = TUint8( ls | EFailed );
sl@0: 		Database().FlushL( EDbWriteLock );
sl@0: 		iLockState = TUint8( ls );
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: void RDbTransaction::DDLBegin()
sl@0: //
sl@0: // A DDL object is about to start ops
sl@0: //
sl@0: 	{
sl@0: 	__INVARIANT;
sl@0: 	__ASSERT( iAction == EDbReadLock );
sl@0: 	__ASSERT( ( iLockState & EFailed ) == 0 );
sl@0: 	__ASSERT( iLockCount <= 1 );
sl@0: 	iLockState = iAction = EDbSchemaLock;
sl@0: 	iLockCount = 1;
sl@0: 	}
sl@0: 
sl@0: void RDbTransaction::DDLBeginLC()
sl@0: 	{
sl@0: 	DDLBegin();
sl@0: 	CleanupStack::PushL( TCleanupItem( DDLAbandon, this ) );
sl@0: 	}
sl@0: 
sl@0: void RDbTransaction::DDLCommitL()
sl@0: //
sl@0: // A DDL incremental object has completed
sl@0: //
sl@0: 	{
sl@0: 	__INVARIANT_L;
sl@0: 	__ASSERT( iAction == EDbSchemaLock );
sl@0: 	if ( ( iPrimary.iState & static_cast<TUint>( ETransactionLock ) ) == 0 )
sl@0: 		{
sl@0: 		__ASSERT( iLockState == EDbSchemaLock );
sl@0: 		DoCommitL();	// release auto-lock
sl@0: 		}
sl@0: 	else
sl@0: 		iAction = EDbReadLock;
sl@0: 	}
sl@0: 
sl@0: void RDbTransaction::DDLRollback()
sl@0: //
sl@0: // Rollback a DDL operation
sl@0: //
sl@0: 	{
sl@0: 	__INVARIANT;
sl@0: 	__ASSERT( iAction == EDbSchemaLock );
sl@0: 	iLockState |= EFailed;
sl@0: 	if ( ( iPrimary.iState & static_cast<TUint>( ETransactionLock ) ) == 0 )
sl@0: 		{
sl@0: 		__ASSERT( iLockState == ( EDbSchemaLock | EFailed ) );
sl@0: 		DoRollback();		// release auto-lock
sl@0: 		}
sl@0: 	else
sl@0: 		iAction = EDbReadLock;
sl@0: 	}
sl@0: 
sl@0: void RDbTransaction::DDLAbandon( TAny* aPtr )
sl@0: 	{
sl@0: 	STATIC_CAST( RDbTransaction*, aPtr )->DDLRollback();
sl@0: 	}
sl@0: 
sl@0: // recovery. Nothing else can be done at the same time as this
sl@0: 
sl@0: void RDbTransaction::UtilityPrepareL( const CDbObject& aObject )
sl@0: //
sl@0: // Check that we are in a state to run a utility
sl@0: //
sl@0: 	{
sl@0: 	__INVARIANT_L;
sl@0: 	ReadyL();
sl@0: 	PrepareXLockL( aObject );
sl@0: 	if ( IsLocked() )			// utilities not allowed in user transaction
sl@0: 		__LEAVE( KErrAccessDenied );
sl@0: 	}
sl@0: 
sl@0: void RDbTransaction::UtilityBegin( CDbDatabase::TUtility aType )
sl@0: //
sl@0: // Database Recovery object is about to start
sl@0: //
sl@0: 	{
sl@0: 	__INVARIANT;
sl@0: 	__ASSERT( !IsLocked() );
sl@0: 	if ( aType == CDbDatabase::ERecover )
sl@0: 		iLockState = iAction = EDbRecoveryLock;
sl@0: 	else
sl@0: 		iLockState = iAction = EDbCompactLock;
sl@0: 	iLockCount = 1;
sl@0: 	}
sl@0: 
sl@0: void RDbTransaction::UtilityCommitL()
sl@0: //
sl@0: // Database Recovery has completed
sl@0: //
sl@0: 	{
sl@0: 	__INVARIANT_L;
sl@0: 	Database().SynchL( LockState() );
sl@0: 	Unlock( iAction == EDbRecoveryLock ? RDbNotifier::ERecover : RDbNotifier::EUnlock );	// release auto-lock
sl@0: 	}
sl@0: 
sl@0: void RDbTransaction::UtilityRollback()
sl@0: 	{
sl@0: 	__INVARIANT;
sl@0: 	Database().Revert( LockState() );
sl@0: 	Unlock( RDbNotifier::EUnlock );	// release auto-lock
sl@0: 	}
sl@0: 
sl@0: CDbNotifier* RDbTransaction::NotifierL()
sl@0: //
sl@0: // Only support a single notifier for the database (server multiplexes)
sl@0: //
sl@0: 	{
sl@0: 	if ( iNotifier )
sl@0: 		__LEAVE( KErrNotSupported );
sl@0: 	return iNotifier = new( ELeave ) CNotifier( *this );
sl@0: 	}
sl@0: 
sl@0: void RDbTransaction::Event( RDbNotifier::TEvent aEvent )
sl@0: //
sl@0: // Report an event to the Notifier
sl@0: // If the lock was less than a write lock, report unlock only: no commit or rollback
sl@0: //
sl@0: 	{
sl@0: //	if ( iNotifier )
sl@0: //		iNotifier->Event( aEvent );
sl@0: 	}
sl@0: 
sl@0: