// 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:

//

#include "US_STD.H"

#include "D32COMP.H"

// Class TDbStoreIndexStats::TBound

inline void TDbStoreIndexStats::TBound::Set(TReal64 aBound)

	{iValue=aBound;}

void TDbStoreIndexStats::TBound::Set(const TInt64& aBound)

	{iValue=I64REAL(aBound);}

void TDbStoreIndexStats::TBound::Set(const TText8* aPtr,TInt aLen,const TTextOps& aConv)

	{

	TInt64 v(0u);

	const TText8* const end=aPtr+aLen;

	TInt shift=48;

	do

		{

		if (aPtr==end)

			break;

		TInt64 t(aConv.Fold(*aPtr++));

		t<<=shift;

		v+=t;

		} while ((shift-=8)>=0);

	Set(v);

	}

void TDbStoreIndexStats::TBound::Set(const TText16* aPtr,TInt aLen,const TTextOps& aConv)

	{

	TInt64 v(0u);

	const TText16* const end=aPtr+aLen;

	TInt shift=32;

	do

		{

		if (aPtr==end)

			break;

		TInt64 t(aConv.Fold(*aPtr++));

		t<<=shift;

		v+=t;

		} while ((shift-=16)>=0);

	Set(v);

	}

void TDbStoreIndexStats::TBound::Set(const TDbLookupKey::SColumn& aBound,const TTextOps& aConv)

	{

	switch (aBound.iType)

		{

	default:

		__ASSERT(0);

	case EDbColInt64:

		Set(aBound.iInt64);

		break;

	case EDbColDateTime:

		Set(aBound.iTime().Int64());

		break;

	case EDbColReal64:

		Set(aBound.iReal64);

		break;

	case EDbColText8:

		Set(aBound.iDes8.iPtr,aBound.iDes8.iLength,aConv);

		break;

	case EDbColText16:

		Set(aBound.iDes16.iPtr,aBound.iDes16.iLength,aConv);

		break;

		}

	}

// Class TDbStoreIndexStats

inline TBool TDbStoreIndexStats::NeedsRefresh() const

	{

	return iRefresh<=ERefresh;

	}

inline TInt TDbStoreIndexStats::Cardinality() const

	{

	return iCardinality;

	}

// update the refresh count

inline void TDbStoreIndexStats::Touch()

	{

	TInt r=iRefresh-1;

	if (r>=ERefresh) 

		iRefresh=r;

	}

// an entry is inserted

inline void TDbStoreIndexStats::Inc()

	{

	++iCardinality;

	Touch();

	}

// an entry is removed

inline void TDbStoreIndexStats::Dec()

	{

	--iCardinality;

	Touch();

	}

// contents have changed radically. provoke an immediate refresh

inline void TDbStoreIndexStats::Reset(TInt aCardinality)

	{

	iCardinality=aCardinality;

	iRefresh=ERefresh;

	}

// stats have been refreshed. set for next update

inline void TDbStoreIndexStats::Refresh(TDbStoreIndexStats::TType aType)

	{

	iFlags=(iFlags&~EFlgDiscrete)|aType;

	iRefresh=(iCardinality>>ERefreshFactor)+1;

	}

//

// Internalize the index statistics

// This must handle a stream externalized by builds before 052

//

void TDbStoreIndexStats::InternalizeL(RReadStream& aStream)

	{

	TCardinality c;

	aStream>>c;

	iCardinality=c;

	TUint refresh=aStream.ReadUint32L();

	iFlags=refresh&EFlagsMask;

	iRefresh=TInt(refresh>>ERefreshShift)+EInvalid;

//

// pre-build-052 data would run out here

// if there is no more data, mark the (non-cardinality) stats as invalid

//

	TRAPD(r,aStream>>iLower.iValue>>iUpper.iValue;)

	if (r==KErrEof)

		iRefresh=EInvalid;		// mark as invalid data

	else

		__LEAVE_IF_ERROR(r);	// just an "ordinary" error

	}

//

// Notes: iCardinality cannot exceed 2^29 (due to storage mechanism)

//		thus iRefresh cannot exceed 2^(29-ERefreshFactor)+1

//		this leaves the 5 m.s.b. clear in iRefresh-EInvalid

//		the flags bits are stored there

//

void TDbStoreIndexStats::ExternalizeL(RWriteStream& aStream) const

	{

	__ASSERT((iFlags&~EFlagsMask)==0);

	aStream<<TCardinality(iCardinality);

	aStream<<TUint32((TUint(iRefresh-EInvalid)<<ERefreshShift)|iFlags);

	aStream<<iLower.iValue<<iUpper.iValue;

	}

//

// Reverse the span and bounds

//

TInt TDbStoreIndexStats::ReverseSpan(TUint aInclusion,const TDbLookupKey* aLower,const TDbLookupKey* aUpper,const TTextOps& aConv) const

	{

	__ASSERT(iLower.iValue>iUpper.iValue);

	TDbStoreIndexStats stats(*this);

	stats.iLower=iUpper;

	stats.iUpper=iLower;

	return stats.Span((aInclusion<<1)|(aInclusion>>1),aUpper,aLower,aConv);

	}

//

// Evaluate the probable proportion of the index set contained within the bounds

//

TInt TDbStoreIndexStats::Span(TUint aInclusion,const TDbLookupKey* aLower,const TDbLookupKey* aUpper,const TTextOps& aConv) const

	{

	if (!IsValid())

		return CDbTable::EUnavailableSpan;	// No valid index data

	if (iCardinality==0)

		return 0;					// no rows at all

//

	if (iLower.iValue>iUpper.iValue)

		return ReverseSpan(aInclusion,aLower,aUpper,aConv);	// descending index

//

	aInclusion&=CDbRecordIndex::EIncludeBoth;

	TBound l(iLower);

	if (aLower)

		{

		TBound bound;

		bound.Set(*aLower->First(),aConv);

		if (bound.iValue>=l.iValue)

			l=bound;

		else

			aInclusion|=CDbRecordIndex::EIncludeLower;

		}

	else

		aInclusion|=CDbRecordIndex::EIncludeLower;

//

	TBound h(iUpper);

	if (aUpper)

		{

		TBound bound;

		bound.Set(*aUpper->First(),aConv);

		if (bound.iValue<=h.iValue)

			h=bound;

		else

			aInclusion|=CDbRecordIndex::EIncludeUpper;

		}

	else

		aInclusion|=CDbRecordIndex::EIncludeUpper;

//

	TRealX restrict(h.iValue);

	restrict.SubEq(l.iValue);		// extended precision--no errors

	TRealX span(iUpper.iValue);

	span.SubEq(iLower.iValue);

	if (iFlags&EFlgDiscrete)

		{

		if (aInclusion==0)

			--restrict;

		else if (aInclusion==CDbRecordIndex::EIncludeBoth)

			++restrict;

		++span;

		}

	else if (restrict.IsZero())		// single value continuous range

		{

		return (span.IsZero() && aInclusion==CDbRecordIndex::EIncludeBoth)

			? CDbTable::EFullIndexSpan : 0;

		}

	if (restrict<=TRealX(0))

		return 0;	// no overlap

	restrict.DivEq(span);

	restrict.MultEq(TInt(CDbTable::EFullIndexSpan));

	return TInt(restrict);

	}

// Class CDbStoreIndex

inline CDbStoreIndex::HKey& CDbStoreIndex::Key() const

	{

	return *iKey;

	}

inline const TBtree& CDbStoreIndex::Tree() const

	{

	return iTree;

	}

inline TInt CDbStoreIndex::Count() const

	{

	return iStats.Cardinality();

	}

// Class CDbStoreIndex::HKey

NONSHARABLE_CLASS(CDbStoreIndex::HKey) : public MBtreeKey

	{

public:

	static HKey* NewL(const CDbKey& aKey,const HDbColumnSet& aColSet);

//

	inline TInt EntrySize() const;

	virtual TInt KeySize() const;

	virtual TBool IncompleteKey() const;

//

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

	TInt EntryL(TAny* aPtr,const TDbLookupKey& aKey);

	inline const TAny* Restriction() const;

	inline void Restrict(const TAny* aRestriction);

//

	void Bound(TDbStoreIndexStats::TBound& aBound,const TAny* aEntry);

	TDbStoreIndexStats::TType KeyType() const;

// from MBtreeKey

	const TAny* Key(const TAny* aRecord) const;

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

protected:

	HKey() {}

	inline TBool FullComparison() const;

// from MBtreeKey

	void Between(const TAny* aLeft,const TAny* aRight,TBtreePivot& aPivot) const;

private:

	struct SKeyCol

		{

		TDbColNo iOrdinal;

		TInt iSize;

		TUint8 iType;

		TUint8 iOrder;

		};

	const TTextOps* iTextOps;

	TInt iSize;

	const SKeyCol* iEndOfKeys;

	const SKeyCol* iRestrictedEndOfKeys;

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

	};

NONSHARABLE_CLASS(CDbStoreIndex::HDupKey) : public CDbStoreIndex::HKey

	{

	friend class CDbStoreIndex::HKey;

private:

	HDupKey() {}

	TInt KeySize() const;

	const TAny* Key(const TAny* aRecord) const;

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

	TBool IncompleteKey() const;

	};

inline TInt CDbStoreIndex::HKey::EntrySize() const

	{

	return iSize;

	}

inline const TAny* CDbStoreIndex::HKey::Restriction() const

	{

	return iRestrictedEndOfKeys;

	}

inline void CDbStoreIndex::HKey::Restrict(const TAny* aRestriction)

	{

	__ASSERT(aRestriction==0||(aRestriction>=iKeys&&aRestriction<=iEndOfKeys));

	iRestrictedEndOfKeys=(const SKeyCol*)aRestriction;

	}

inline TBool CDbStoreIndex::HKey::FullComparison() const

	{

	return iRestrictedEndOfKeys==NULL;

	}

//

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

// and the column set provided

//

CDbStoreIndex::HKey* CDbStoreIndex::HKey::NewL(const CDbKey& aKey,const HDbColumnSet& aColumns)

	{

	TInt count=aKey.Count();

	HKey* self=(HKey*)User::AllocLC(_FOFF(HKey,iKeys[count]));

	if (aKey.IsUnique())

		new(self) HKey;

	else

		new(self) HDupKey;

	self->iTextOps=&TTextOps::Ops(aKey.Comparison());

	self->iEndOfKeys=&self->iKeys[count];

	self->iRestrictedEndOfKeys=NULL;

	TInt len=sizeof(TDbRecordId);

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

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

		{

		const TDbKeyCol& key=aKey[ii];

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

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

		if (pKey->iOrdinal==KDbNullColNo)

			__LEAVE(KErrCorrupt);

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

		pKey->iType=col.iType;

		pKey->iSize=CDbStoreIndexDef::KeySize(key,col);

		len+=Align4(pKey->iSize);

		}

	self->iSize=len;

	if (self->KeySize()>KMaxIndexKeySize)

		__LEAVE(KErrCorrupt);

	CleanupStack::Pop();

	return self;

	}

//

// Construct an entry at aPtr from the record given

//

TInt CDbStoreIndex::HKey::EntryL(TAny* aPtr,const RDbTableRow& aRow,TDbRecordId aRecord)

	{

	TUint8* ptr=(TUint8*)aPtr;

	Mem::FillZ(ptr,iSize);

	*REINTERPRET_CAST(TDbRecordId*,ptr)=aRecord;

	ptr+=sizeof(TDbRecordId);

	const SKeyCol* const end=iEndOfKeys;

	for (const SKeyCol* key=&iKeys[0];key<end;++key)

		{

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

		TInt size=key->iSize;

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

			{

#ifdef __DOUBLE_WORDS_SWAPPED__

			if (key->iType==EDbColReal64)

				{

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

				((TUint32*)ptr)[0]=data[1];

				((TUint32*)ptr)[1]=data[0];

				}

			else

#endif

			if (TDbCol::IsLong(TDbColType(key->iType)))

				{

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

				if (blob.IsInline())

					Mem::Copy(ptr,blob.Data(),Min(size,blob.Size()));

				else

					{

					aRow.Table().BlobsL()->ReadLC(blob.Id(),TDbColType(key->iType))->ReadL(ptr,size);

					CleanupStack::PopAndDestroy();	// stream buffer

					}

				}

			else

				Mem::Copy(ptr,cell->Data(),Min(size,cell->Length()));

			}

		ptr+=Align4(size);

		}

	iRestrictedEndOfKeys=NULL;		// use the full key for comparison

	return EntrySize();

	}

//

// Construct an entry from a lookup key

//

TInt CDbStoreIndex::HKey::EntryL(TAny* aPtr,const TDbLookupKey& aKey)

	{

	TUint8* ptr=(TUint8*)aPtr;

	Mem::FillZ(ptr,iSize);

	ptr+=sizeof(TDbRecordId);

	const TDbLookupKey::SColumn* lkey=aKey.First();

	const TDbLookupKey::SColumn* const lend=lkey+aKey.Count();

	__ASSERT(lkey<lend);

	const SKeyCol* const end=iEndOfKeys;

	const SKeyCol* key=&iKeys[0];

	for (;;)

		{

		TDbColType ltype=lkey->iType;

		TInt size=key->iSize;

		switch (key->iType)

			{

		default:

			__ASSERT(0);

		case EDbColBit:

		case EDbColUint8:

		case EDbColUint16:

		case EDbColUint32:

			if (ltype==EDbColUint32)

				{

				*(TUint32*)ptr=lkey->iUint32;

				break;

				}

			else if (ltype==EDbColInt32)

				{

				if (lkey->iInt32>=0)	// domain check, unsigned value

					{

					*(TUint32*)ptr=lkey->iInt32;

					break;

					}

				}

			else if (ltype==EDbColInt64)

				{

				const TInt64& v=lkey->iInt64;

				if (I64HIGH(v)==0)		// domain check, in unsigned 32-bit range

					{

					*(TUint32*)ptr=I64LOW(v);

					break;

					}

				}

			Panic(EDbWrongType);

			break;

		case EDbColInt8:

		case EDbColInt16:

		case EDbColInt32:

			if (ltype==EDbColInt32)

				{

				*(TInt32*)ptr=lkey->iInt32;

				break;

				}

			else if (ltype==EDbColUint32)

				{

				if (lkey->iUint32<=TUint(KMaxTInt))	// domain check, in signed range

					{

					*(TInt32*)ptr=lkey->iUint32;

					break;

					}

				}

			else if (ltype==EDbColInt64)

				{

				const TInt64& v=lkey->iInt64;

				TInt32 l=I64LOW(v);

				TInt32 h=I64HIGH(v);

				if (h==(l>>31))	// domain check, in signed 32-bit range

					{

					*(TInt32*)ptr=l;

					break;

					}

				}

			Panic(EDbWrongType);

			break;

		case EDbColReal32:

			if (ltype==EDbColReal32)

				{

				*(TReal32*)ptr=lkey->iReal32;

				break;

				}

			else if (ltype==EDbColReal64)

				{	// convert to TReal32, storing +-#inf if reqd.

				TRealX(lkey->iReal64).GetTReal(*(TReal32*)ptr);

				break;

				}

			Panic(EDbWrongType);

			break;

		case EDbColReal64:

#ifdef __DOUBLE_WORDS_SWAPPED__

			if (ltype==EDbColReal64)

				{

				const TUint32* data=(TUint32*)&lkey->iReal64;

				((TUint32*)ptr)[0]=data[1];

				((TUint32*)ptr)[1]=data[0];

				break;

				}

			// drop through

#endif

		case EDbColInt64:

		case EDbColDateTime:

			if (ltype==key->iType)

				Mem::Copy(ptr,&lkey->iInt64,size);	// all at same address

			else

				Panic(EDbWrongType);

			break;

		case EDbColText8:

		case EDbColLongText8:

			if (ltype==EDbColText8)

				Mem::Copy(ptr,lkey->iDes8.iPtr,Min(size,lkey->iDes8.iLength));