// Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// Order-by stage for the cursor data "pipeline"

// 

//

#include "UT_STD.H"

#include "D32COMP.H"

#include <d32dbmsconstants.h>

#ifdef _DEBUG

#define _CHECK_ORDERING		// forces a full test of the ordering after sorting

#endif

#define MAX( a, b ) ( (a) > (b) ? (a) : (b) )

/* The key structure.

Each key value is always aligned on a 32-bit boundary to allow word reads and writes

integral values are always atored as 32-bit values just as for the row buffer

Text columns are encoded as follows (trailing padding is omitted from the description)

  Text8 columns			<byte n><n ASCII characters>

  n is the [character] length of the column

  Text16 columns		<short n><n UNICODE characters>

  n is the [character] length of the column

  LongText8 columns		<word n><n ASCII characters>

                 or		<word n|ETrunc><32 ASCII characters><blobId>

  n is [byte] size of the column

  LongText16 columns	<word n><n/2 UNICODE characters>

                  or	<word n|ETrunc><16 UNICODE characters><blobId>

  n is [byte] size of the column

*/

class CDbOrderByStage::HOrdering

	{

private:

	struct TKeyCol

		{

		TDbColNo iOrdinal;

		TUint8 iType;

		TUint8 iOrder;

		TUint8 iLength;

		};

	struct TBlobKey

		{

		enum {ETrunc=(TInt)0x80000000};

		enum {ETruncSize=32};		// store 32 bytes of truncated BLOBs

	public:

		inline TInt Size() const;

	public:

		TInt iSize;

		union {TUint8 iData8[ETruncSize]; TUint16 iData16[ETruncSize>>1];};

		TDbBlobId iId;

		};

public:

	static HOrdering* NewL(CDbTable& aTable,const CDbKey& aKey);

	TAny* EntryL(TAny* aPtr,const RDbTableRow& aRow) const;

	TInt CompareL(const TAny* aLeft,const TAny* aRight) const;

	TInt MaxSize() const;

private:

	inline HOrdering(TInt aCount,TDbTextComparison aComparison,CDbTable& aTable);

	MStreamBuf* BlobLC(TDbBlobId aId,TDbColType aType) const;

	TInt CompareLongText8L(const TBlobKey& aLeft,const TBlobKey& aRight) const;

	TInt CompareLongText16L(const TBlobKey& aLeft,const TBlobKey& aRight) const;

private:

	CDbTable& iTable;

	const TTextOps& iTextOps;

	const TKeyCol* iEndOfKeys;

	TKeyCol iKeys[1];	// one or more keys

	};

// Class HDbOrdering

inline TInt CDbOrderByStage::HOrdering::TBlobKey::Size() const

	{

	TInt size=_FOFF(TBlobKey,iData8[iSize+3]);

	return (size&ETrunc) ? sizeof(TBlobKey) : size&~3;

	}

inline CDbOrderByStage::HOrdering::HOrdering(TInt aCount,TDbTextComparison aComparison,CDbTable& aTable) :

	iTable(aTable),

	iTextOps(TTextOps::Ops(aComparison)),

	iEndOfKeys(&iKeys[aCount])

	{

	}

//

// Construct the ordering based on the key definition (must be valid for the table)

// and the column set provided

//

CDbOrderByStage::HOrdering* CDbOrderByStage::HOrdering::NewL(CDbTable& aTable,const CDbKey& aKey)

	{

	TInt count=aKey.Count();

	__ASSERT(count>0);

	HOrdering* self=new(User::AllocLC(_FOFF(HOrdering,iKeys[count])))

								HOrdering(count,aKey.Comparison(),aTable);

	TKeyCol* pKey=&self->iKeys[0];

	const HDbColumnSet& columns=aTable.Def().Columns();

	for (TInt ii=0;ii<count;++pKey,++ii)

		{

		const TDbKeyCol& key=aKey[ii];

		pKey->iOrder=TUint8(key.iOrder);

		pKey->iOrdinal=columns.ColNoL(key.iName);

		if (pKey->iOrdinal==KDbNullColNo)

			__LEAVE(KErrNotFound);

		const TDbColumnDef& col=columns[pKey->iOrdinal];

		switch (pKey->iType=col.iType)

			{

		default:

			break;

		case EDbColText8:

		case EDbColText16:

			{

			TInt l=col.iMaxLength;

			if (l<256)

				{

				pKey->iLength=TUint8(l);

				break;

				}

			}

			// fall through to argument error

		case EDbColBinary:

		case EDbColLongBinary:

			__LEAVE(KErrArgument);

			}

		}

	CleanupStack::Pop();

	return self;

	}

TInt CDbOrderByStage::HOrdering::MaxSize() const

	{

	TInt maxsize=0;

	const TKeyCol* const end=iEndOfKeys;

	const TKeyCol* key=&iKeys[0];

	__ASSERT(key<end);

	do	{

		TInt s;

		switch (key->iType)

			{

		default:

			s=sizeof(TUint32);

			break;

		case EDbColInt64:

			s=sizeof(TInt64);

			break;

		case EDbColDateTime:

			s=sizeof(TTime);

			break;

		case EDbColReal64:

			s=sizeof(TReal64);

			break;

		case EDbColText8:

			s=Align4(key->iLength+1);

			break;

		case EDbColText16:

			s=Align4((key->iLength<<1)+1);

			break;

		case EDbColLongText8:

		case EDbColLongText16:

			s=MAX(__Align8(sizeof(TUint32)+KDbMaxInlineBlobSize),sizeof(TBlobKey));

			break;

			}

		maxsize+=s;

		} while (++key<end);

	return maxsize;

	}

MStreamBuf* CDbOrderByStage::HOrdering::BlobLC(TDbBlobId aId,TDbColType aType) const

	{

	return iTable.BlobsL()->ReadLC(aId,aType);

	}

//

// Construct an entry at aPtr from the record given

// iMaxSize bytes are assumed to be available at aPtr

// return the actual size of the entry

//

TAny* CDbOrderByStage::HOrdering::EntryL(TAny* aPtr,const RDbTableRow& aRow) const

	{

	__ASSERT(Align4(aPtr)==aPtr);

	TUint32* ptr=(TUint32*)aPtr;		// 32-bit words are nice

	const TKeyCol* const end=iEndOfKeys;

	const TKeyCol* key=iKeys;

	__ASSERT(key<end);

	do	{

		const TDbCell* cell=aRow.ColCell(key->iOrdinal);

		TDbColType type=TDbColType(key->iType);

		if (cell->Length()==0)

			{	// null column

			const TUint K64BitColumnMask=(1u<<EDbColInt64)|(1u<<EDbColReal64)|(1u<<EDbColDateTime);

			*ptr++=0;

			if (K64BitColumnMask&(1u<<type))

				*ptr++=0;		// 8-byte column

			continue;

			}

		switch (type)

			{

		default:

			__ASSERT(0);

		case EDbColBit:

		case EDbColUint8:

		case EDbColUint16:

		case EDbColUint32:

		case EDbColInt8:

		case EDbColInt16:

		case EDbColInt32:

		case EDbColReal32:

			*ptr++=*(const TUint32*)cell->Data();

			break;

		case EDbColInt64:

		case EDbColDateTime:

		case EDbColReal64:

			{

			const TUint32* data=(const TUint32*)cell->Data();

			*ptr++=*data++;

			*ptr++=*data;

			}

			break;

		case EDbColText8:

			{

			TInt size=cell->Length();

			*(TUint8*)ptr=TUint8(size);

			ptr=(TUint32*)Align4(Mem::Copy(PtrAdd(ptr,1),cell->Data(),size));

			}

			break;

		case EDbColText16:

			{

			TInt size=cell->Length();

			*(TUint16*)ptr=TUint16(size>>1);

			ptr=(TUint32*)Align4(Mem::Copy(PtrAdd(ptr,2),cell->Data(),size));

			}

			break;

		case EDbColLongText8:

		case EDbColLongText16:

			{

			const TDbBlob& blob=*(const TDbBlob*)cell->Data();

			TInt size=blob.Size();

			if (blob.IsInline())

				{

				*ptr++=size;

				ptr=(TUint32*)Align4(Mem::Copy(ptr,blob.Data(),size));

				}

			else

				{

				TInt rsize=size;

				if (size>TBlobKey::ETruncSize)

					{

					size|=TBlobKey::ETrunc;

					rsize=TBlobKey::ETruncSize;

					}

				*ptr++=size;

				BlobLC(blob.Id(),TDbColType(key->iType))->ReadL(ptr,rsize);

				CleanupStack::PopAndDestroy();

				ptr=Align4(PtrAdd(ptr,rsize));

				if (size&TBlobKey::ETrunc)

					*ptr++=blob.Id();

				}

			}

			break;

			}

		} while (++key<end);

	return ptr;

	}

TInt CDbOrderByStage::HOrdering::CompareLongText8L( const CDbOrderByStage::HOrdering::TBlobKey& aLeft, const CDbOrderByStage::HOrdering::TBlobKey& aRight ) const

	{

	TUint sizel = aLeft.iSize;

	TUint sizer = aRight.iSize;

	TUint s = sizel;

	if ( sizer < s )

		s = sizer;

	if ( s > static_cast<TUint>( TBlobKey::ETruncSize ) && ( ( sizel | sizer ) & static_cast<TUint>( TBlobKey::ETrunc ) ) )

		s = TBlobKey::ETruncSize;

	TInt rr = iTextOps.Compare( aLeft.iData8, s, aRight.iData8, s );

	if ( rr )

		return rr;

//

// matches up to the same-length inlined data...

// now it gets interesting

//

	if ( ( ( sizel | sizer ) & static_cast<TUint>( TBlobKey::ETrunc ) ) == 0 )

		return sizel - sizer;		// neither are truncated

	if ( s == sizel )

		return -1;		// left completely match against truncated right

	if ( s == sizer )

		return 1;		// right completely matched against truncated left

	s = Min( TInt( sizel & ~TBlobKey::ETrunc ), TInt( sizer & ~TBlobKey::ETrunc ) );		// minimum real length

	if ( sizel & static_cast<TUint>( TBlobKey::ETrunc ) )

		{

		MStreamBuf& bufL = *BlobLC( aLeft.iId, EDbColLongText8 );

		if ( sizer & static_cast<TUint>( TBlobKey::ETrunc ) )

			{	// both out-of-line

			rr = Comp::Compare8L( bufL, *BlobLC( aRight.iId, EDbColLongText8 ), s, iTextOps );

			CleanupStack::PopAndDestroy();

			}

		else	// left side only out-of-line

			rr = Comp::Compare8L( bufL, aRight.iData8, s, iTextOps );

		}

	else

		{	// right side only out-of-line

		__ASSERT( sizer & static_cast<TUint>( TBlobKey::ETrunc ) );

		rr = -Comp::Compare8L( *BlobLC( aRight.iId, EDbColLongText8 ), aLeft.iData8, s, iTextOps );

		}

	CleanupStack::PopAndDestroy();

	return rr ? rr : ( sizel & ~TBlobKey::ETrunc ) - ( sizer & ~TBlobKey::ETrunc );

	}

TInt CDbOrderByStage::HOrdering::CompareLongText16L( const CDbOrderByStage::HOrdering::TBlobKey& aLeft, const CDbOrderByStage::HOrdering::TBlobKey& aRight ) const

	{

	TUint sizeL = aLeft.iSize  & ~TBlobKey::ETrunc; // set truncation bit to 0 to get true size

	TUint sizeR = aRight.iSize & ~TBlobKey::ETrunc;

	TBool truncL = aLeft.iSize  & TBlobKey::ETrunc; // data is truncated if TBlobKey::ETrunc bit is 1

	TBool truncR = aRight.iSize & TBlobKey::ETrunc;

	if (!(truncL | truncR)) // neither side is truncated, compare full strings

		{		

		return iTextOps.Order( aLeft.iData16, sizeL>>1, aRight.iData16, sizeR>>1 );

		}

	TInt result;

	TUint sizeMin = Min( TInt(sizeL), TInt(sizeR) ); // minimum real length

	if ( truncL )

		{

		MStreamBuf& bufL = *BlobLC( aLeft.iId, EDbColLongText16 );

		if ( truncR )

			{	// both out-of-line

			result = Comp::Compare16L( bufL, *BlobLC( aRight.iId, EDbColLongText16 ), sizeMin, iTextOps );

			CleanupStack::PopAndDestroy();

			}

		else	// left side only out-of-line

			result = Comp::Compare16L( bufL, aRight.iData16, sizeMin, iTextOps );

		}

	else

		{	// right side only out-of-line

		__ASSERT( truncR );

		result = -Comp::Compare16L( *BlobLC( aRight.iId, EDbColLongText16 ), aLeft.iData16, sizeMin, iTextOps );

		}

	CleanupStack::PopAndDestroy();

	return result ? result : ( sizeL ) - ( sizeR );

	}

TInt CDbOrderByStage::HOrdering::CompareL(const TAny* aLeft,const TAny* aRight) const

//

// compare the keys

//

	{

    __ASSERT(aLeft != NULL);

    __ASSERT(aRight != NULL);

	const TUint8* left=(const TUint8*)aLeft;

	const TUint8* right=(const TUint8*)aRight;

	const TKeyCol* end=iEndOfKeys;

	const TKeyCol* key=&iKeys[0];

	TInt rr;

	for (;;)

		{

		switch (key->iType)

			{

		default:

			__ASSERT(0);

		case EDbColBit:

		case EDbColUint8:

		case EDbColUint16:

		case EDbColUint32:

			rr=Comp::Compare(*(const TUint32*)left,*(const TUint32*)right);

			left+=sizeof(TUint32);

			right+=sizeof(TUint32);

			break;

		case EDbColInt8:

		case EDbColInt16:

		case EDbColInt32:

			rr=Comp::Compare(*(const TInt32*)left,*(const TInt32*)right);

			left+=sizeof(TInt32);

			right+=sizeof(TInt32);

			break;

		case EDbColInt64:

			rr=Comp::Compare(*(const TInt64*)left,*(const TInt64*)right);

			left+=sizeof(TInt64);

			right+=sizeof(TInt64);

			break;

		case EDbColDateTime:

			rr=Comp::Compare(*(const TTime*)left,*(const TTime*)right);

			left+=sizeof(TTime);

			right+=sizeof(TTime);

			break;

		case EDbColReal32:

			rr=Comp::Compare(*(const TReal32*)left,*(const TReal32*)right);

			left+=sizeof(TReal32);

			right+=sizeof(TReal32);

			break;

		case EDbColReal64:

			rr=Comp::Compare(*(const TReal64*)left,*(const TReal64*)right);

			left+=sizeof(TReal64);

			right+=sizeof(TReal64);

			break;

		case EDbColText8:

			{

			TInt sizel=*left++;

			TInt sizer=*right++;

			rr=iTextOps.Compare(left,sizel,right,sizer);

			left=Align4(left+sizel);

			right=Align4(right+sizer);

			}

			break;

		case EDbColText16:

			{

			const TUint16* l16=reinterpret_cast<const TUint16*>(left);

			const TUint16* r16=reinterpret_cast<const TUint16*>(right);

			TInt sizel=*l16++;

			TInt sizer=*r16++;

			rr=iTextOps.Order(l16,sizel,r16,sizer);

			left=Align4(reinterpret_cast<const TUint8*>(l16+sizel));

			right=Align4(reinterpret_cast<const TUint8*>(r16+sizer));

			}

			break;

		case EDbColLongText8:

			{

			const TBlobKey* ltext=(const TBlobKey*)left;

			const TBlobKey* rtext=(const TBlobKey*)right;

			rr=CompareLongText8L(*ltext,*rtext);

			left+=ltext->Size();

			right+=rtext->Size();

			}

			break;

		case EDbColLongText16:

			{

			const TBlobKey* ltext=(const TBlobKey*)left;

			const TBlobKey* rtext=(const TBlobKey*)right;

			rr=CompareLongText16L(*ltext,*rtext);

			left+=ltext->Size();

			right+=rtext->Size();

			}

			break;

			}

		if (rr!=0)

			break;

		if (++key==end)

			break;

		}

	return key->iOrder==TDbKeyCol::EAsc ? rr : -rr;

	}

//

NONSHARABLE_CLASS(CDbOrderByStage::CKeys) : public CBase

	{

public:		// should be private but VC++ 4.0 whinges

	struct TKey

		{

		TUint32 iId;

		TUint8 iKey[4];		// and then some

		};

private:

	enum {EKeysGranularity=32};

	struct TPage

		{

		TPage* iNext;

		TKey iEntries[1];

		};

	enum {EMinPageSize=0x200,EMinKeyElements=2};

public:

	CKeys(TInt aMaxKeySize);

	~CKeys();

//

	void AddL(TDbRecordId aRecordId,const RDbTableRow& aRow,const HOrdering& aOrder);

	void SortL(const HOrdering& aOrder);

	void GetRecordsL(CArrayFix<TDbRecordId>& aRecords);

#ifdef _CHECK_ORDERING

	void VerifyOrderingL(const HOrdering& aOrder);

#endif

private:

	void SortL(TKey* aData[],TInt aElem,const HOrdering& aOrder);

	TKey& NewKeyL();

	void KeyComplete(TAny* aEnd);

	void Release();

private:

	RPointerArray<TKey> iKeys;

	TInt iMaxKeySize;

	TInt iPageSize;

	TPage* iPages;

	TKey* iNext;

	TKey* iEnd;

	};

// Class CDbOrderByStage::CKeys

CDbOrderByStage::CKeys::CKeys(TInt aMaxKeySize)

	:iKeys(EKeysGranularity),iMaxKeySize(_FOFF(TKey,iKey[aMaxKeySize])),

	 iPageSize(Max(EMinPageSize+iMaxKeySize,iMaxKeySize*EMinKeyElements))

	{}

CDbOrderByStage::CKeys::~CKeys()

	{

	iKeys.Close();

	Release();

	}

void CDbOrderByStage::CKeys::SortL(CDbOrderByStage::CKeys::TKey* aData[],TInt aElem,const HOrdering& aOrder)

//

// Sort the array of row keys

// Uses Heap-sort

//

	{

	__ASSERT(aElem>1);

	TInt heap=aElem>>1;

	--aElem;

	for (;;)

		{

		TKey* key;

		if (heap!=0)

			key=aData[--heap];

		else

			{

			key=aData[aElem];

			aData[aElem]=aData[0];

			if (--aElem==0)

				{

				aData[0]=key;

				break;

				}

			}

		TInt ix=heap;

		TInt parent;

		for (parent=ix;;parent=ix)

			{

			ix=(ix<<1)+1;

			if (ix<=aElem)

				{

				if (ix<aElem && aOrder.CompareL(aData[ix]->iKey,aData[ix+1]->iKey)<0)

					++ix;

				}

			else

				break;

			if (aOrder.CompareL(aData[ix]->iKey,key->iKey)<=0)

				break;

			aData[parent]=aData[ix];

			}

		aData[parent]=key;

		}

	}

void CDbOrderByStage::CKeys::AddL(TDbRecordId aRecordId,const RDbTableRow& aRow,const HOrdering& aOrder)

//

// Create a key for the row and store it

//

	{

	TKey& key=NewKeyL();

	key.iId=aRecordId.Value();

	TAny* end=aOrder.EntryL(&key.iKey[0],aRow);

	__LEAVE_IF_ERROR(iKeys.Append(&key));

	KeyComplete(end);

	}

void CDbOrderByStage::CKeys::SortL(const HOrdering& aOrder)

	{

	TInt elem=iKeys.Count();

	if (elem>1)

		SortL(&iKeys[0],elem,aOrder);

	}

void CDbOrderByStage::CKeys::GetRecordsL(CArrayFix<TDbRecordId>& aRecords)

	{

	TInt elem=iKeys.Count();

	if (elem==0)

		return;

	TKey** const base=&iKeys[0];

	TKey** ptr=base+elem;

	do	{

		--ptr;

		*REINTERPRET_CAST(TDbRecordId*,ptr)=(*ptr)->iId;

		} while (ptr>base);

	Release();		// discard key memory before adding records

	aRecords.InsertL(0,REINTERPRET_CAST(const TDbRecordId*,base),elem);

	iKeys.Reset();

	}

void CDbOrderByStage::CKeys::Release()

//

// Discard all of the allocated pages

//

	{

	TPage* p=iPages;

	while (p)

		{

		TPage* n=p->iNext;

		User::Free(p);

		p=n;

		}

	iPages=0;

	iNext=iEnd=0;

	}

CDbOrderByStage::CKeys::TKey& CDbOrderByStage::CKeys::NewKeyL()

//

// Allocate a key entry for the raw key data

//

	{

	TKey* p=iNext;

	if (PtrAdd(p,iMaxKeySize)>iEnd)

		{	// not enough space for a maximum key

		TPage* page=iPages;

		if (page)

			{	// compress the current page

			__DEBUG(page=(TPage*))User::ReAlloc(page,(TUint8*)iNext-(TUint8*)page);

			__ASSERT(page==iPages);		// if it moves we are dead

			}

		page=(TPage*)User::AllocL(_FOFF(TPage,iEntries)+iPageSize);

		page->iNext=iPages;

		iPages=page;

		p=iNext=&page->iEntries[0];

		iEnd=PtrAdd(p,iPageSize);

		}

	return *p;

	}

void CDbOrderByStage::CKeys::KeyComplete(TAny* aEnd)

//

// Key is complete, prepare for the next one

//

	{

	__ASSERT(aEnd==Align4(aEnd));

	__ASSERT(iNext<=aEnd&&aEnd<=iEnd);

	iNext=STATIC_CAST(TKey*,aEnd);

	}

#ifdef _CHECK_ORDERING

void CDbOrderByStage::CKeys::VerifyOrderingL(const HOrdering& aOrder)

	{

// this performs a full O(N*N) comparison of the record set

	if (iKeys.Count()==0)

		return;

	TKey* const* data=&iKeys[0];

	for (TInt ii=iKeys.Count();--ii>=0;)

		{

		for (TInt jj=iKeys.Count();--jj>=0;)

			{

			TInt rr=aOrder.CompareL(data[ii]->iKey,data[jj]->iKey);

			if (ii==jj)

				__ASSERT_ALWAYS(rr==0,User::Invariant());

			else if (ii<jj)

				__ASSERT_ALWAYS(rr<=0,User::Invariant());

			else

				__ASSERT_ALWAYS(rr>=0,User::Invariant());

			}

		}

	}

#endif

// Class CDbOrderByStage

inline const RDbTableRow& CDbOrderByStage::Row()

	{return iRow;}

inline CDbOrderByStage::CKeys& CDbOrderByStage::Keys()

	{__ASSERT(iKeys);return *iKeys;}

inline const CDbOrderByStage::HOrdering& CDbOrderByStage::Order()

	{__ASSERT(iOrder);return *iOrder;}

CDbOrderByStage::CDbOrderByStage(const RDbTableRow& aRow)

	: CDbBasicWindowStage(KDbUnlimitedWindow),iRow(aRow)

	{

	__ASSERT(iState==EReset);

	}

CDbOrderByStage::~CDbOrderByStage()

	{

	delete iOrder;

	delete iKeys;

	}

void CDbOrderByStage::ConstructL(const CDbKey& aOrderBy)

//

// Build the key structures to support the partial and complete ordering

//

	{

	iOrder=HOrdering::NewL(Row().Table(),aOrderBy);

	}

void CDbOrderByStage::Reset()

//

// Reset the window to initial state

//

	{

	delete iKeys;

	iKeys=0;

	iState=EReset;

	CDbBasicWindowStage::Reset();

	}

TBool CDbOrderByStage::ReadL(TInt& aWork,TDbPosition aNext)

//

// Read some more record keys

//

	{

	TDbRecordId id(KDbNullRecordIdValue);

	TGoto r;

	while ((r=CDbDataStage::GotoL(aWork,aNext,id))==ESuccess)

		{

		CDbDataStage::ReadRowL(id);

		Keys().AddL(id,Row(),Order());

		aNext=EDbNext;

		}

	switch (r)

		{

	default:

		__ASSERT(0);

	case ESynchFailure:

		__LEAVE(KErrNotReady);

	case EExhausted:

		return ETrue;

	case ENoRow:

		return EFalse;

		}

	}

TBool CDbOrderByStage::DoEvaluateL(TInt& aWork)

//

// Build the key collection, and finally sort it

//

	{

	TState s=iState;

	iState=EFailed;

	switch (s)

		{

	default:

		__ASSERT(0);

	case EFailed:

		__LEAVE(KErrNotReady);

	case EReset:

		__ASSERT(!iKeys);

		iKeys=new(ELeave) CKeys(Order().MaxSize());

		// drop through to EEvaluate

	case EEvaluate:

		if (ReadL(aWork,s==EReset ? EDbFirst : EDbNext))

			{

			iState=EEvaluate;

			return ETrue;

			}

		// drop through to ESort

	case ESort:

		Keys().SortL(Order());

#ifdef _CHECK_ORDERING

		Keys().VerifyOrderingL(Order());

#endif

		// drop through to EAdd

	case EAdd:

		Keys().GetRecordsL(iRecords);

		delete iKeys;

		iKeys=0;

		// drop through to EComplete

	case EComplete:

		iState=EComplete;

		return EFalse;

		}

	}

TBool CDbOrderByStage::Unevaluated()

//

// Return whether it is worth Evaluating

//

	{

	if (iState==EComplete)

		return CDbDataStage::Unevaluated();

	return iState!=EFailed;

	}

// Class CDbReorderWindowStage

CDbReorderWindowStage::CDbReorderWindowStage()

	: CDbBasicWindowStage(KDbUnlimitedWindow),iRows(EGranularity)

	{

	__ASSERT(iState==EReset);

	}

CDbReorderWindowStage::~CDbReorderWindowStage()

	{

	iRows.Close();

	}

void CDbReorderWindowStage::Reset()

//

// Reset the window to initial state

//

	{

	iRows.Reset();

	iState=EReset;

	CDbBasicWindowStage::Reset();

	}

TBool CDbReorderWindowStage::ReadL(TInt& aWork,TDbPosition aNext)

//

// Read some more row ids

//

	{

	TDbRecordId id(KDbNullRecordIdValue);

	TGoto r;

	while ((r=CDbDataStage::GotoL(aWork,aNext,id))==ESuccess)

		{

		__LEAVE_IF_ERROR(iRows.Append(id.Value()));

		aNext=EDbNext;

		}

	switch (r)

		{

	default:

		__ASSERT(0);

	case ESynchFailure:

		__LEAVE(KErrNotReady);

	case EExhausted:

		return ETrue;

	case ENoRow:

		return EFalse;

		}

	}

TBool CDbReorderWindowStage::DoEvaluateL(TInt& aWork)

//

// Build the key collection, and finally sort it

//

	{

	TState s=iState;

	iState=EFailed;

	switch (s)

		{

	default:

		__ASSERT(0);

	case EFailed:

		__LEAVE(KErrNotReady);

	case EReset:

	case EEvaluate:

		if (ReadL(aWork,s==EReset ? EDbFirst : EDbNext))

			{

			iState=EEvaluate;

			return ETrue;

			}

		if (iRows.Count())

			{

			iRows.Sort();

			iRecords.AppendL((const TDbRecordId*)&iRows[0],iRows.Count());

			iRows.Reset();

			}

		// coverity[fallthrough]

	case EComplete:

		iState=EComplete;

		return EFalse;

		}

	}

TBool CDbReorderWindowStage::Unevaluated()

//

// Return whether it is worth Evaluating

//

	{

	if (iState==EComplete)

		return CDbDataStage::Unevaluated();

	return iState!=EFailed;

	}