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 "US_STD.H"
sl@0: #include "D32COMP.H"
sl@0: 
sl@0: // Class TDbStoreIndexStats::TBound
sl@0: 
sl@0: inline void TDbStoreIndexStats::TBound::Set(TReal64 aBound)
sl@0: 	{iValue=aBound;}
sl@0: 
sl@0: void TDbStoreIndexStats::TBound::Set(const TInt64& aBound)
sl@0: 	{iValue=I64REAL(aBound);}
sl@0: 
sl@0: void TDbStoreIndexStats::TBound::Set(const TText8* aPtr,TInt aLen,const TTextOps& aConv)
sl@0: 	{
sl@0: 	TInt64 v(0u);
sl@0: 	const TText8* const end=aPtr+aLen;
sl@0: 	TInt shift=48;
sl@0: 	do
sl@0: 		{
sl@0: 		if (aPtr==end)
sl@0: 			break;
sl@0: 		TInt64 t(aConv.Fold(*aPtr++));
sl@0: 		t<<=shift;
sl@0: 		v+=t;
sl@0: 		} while ((shift-=8)>=0);
sl@0: 	Set(v);
sl@0: 	}
sl@0: 
sl@0: void TDbStoreIndexStats::TBound::Set(const TText16* aPtr,TInt aLen,const TTextOps& aConv)
sl@0: 	{
sl@0: 	TInt64 v(0u);
sl@0: 	const TText16* const end=aPtr+aLen;
sl@0: 	TInt shift=32;
sl@0: 	do
sl@0: 		{
sl@0: 		if (aPtr==end)
sl@0: 			break;
sl@0: 		TInt64 t(aConv.Fold(*aPtr++));
sl@0: 		t<<=shift;
sl@0: 		v+=t;
sl@0: 		} while ((shift-=16)>=0);
sl@0: 	Set(v);
sl@0: 	}
sl@0: 
sl@0: void TDbStoreIndexStats::TBound::Set(const TDbLookupKey::SColumn& aBound,const TTextOps& aConv)
sl@0: 	{
sl@0: 	switch (aBound.iType)
sl@0: 		{
sl@0: 	default:
sl@0: 		__ASSERT(0);
sl@0: 	case EDbColInt64:
sl@0: 		Set(aBound.iInt64);
sl@0: 		break;
sl@0: 	case EDbColDateTime:
sl@0: 		Set(aBound.iTime().Int64());
sl@0: 		break;
sl@0: 	case EDbColReal64:
sl@0: 		Set(aBound.iReal64);
sl@0: 		break;
sl@0: 	case EDbColText8:
sl@0: 		Set(aBound.iDes8.iPtr,aBound.iDes8.iLength,aConv);
sl@0: 		break;
sl@0: 	case EDbColText16:
sl@0: 		Set(aBound.iDes16.iPtr,aBound.iDes16.iLength,aConv);
sl@0: 		break;
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: // Class TDbStoreIndexStats
sl@0: 
sl@0: inline TBool TDbStoreIndexStats::NeedsRefresh() const
sl@0: 	{
sl@0: 	return iRefresh<=ERefresh;
sl@0: 	}
sl@0: 
sl@0: inline TInt TDbStoreIndexStats::Cardinality() const
sl@0: 	{
sl@0: 	return iCardinality;
sl@0: 	}
sl@0: 
sl@0: // update the refresh count
sl@0: inline void TDbStoreIndexStats::Touch()
sl@0: 	{
sl@0: 	TInt r=iRefresh-1;
sl@0: 	if (r>=ERefresh) 
sl@0: 		iRefresh=r;
sl@0: 	}
sl@0: 
sl@0: // an entry is inserted
sl@0: inline void TDbStoreIndexStats::Inc()
sl@0: 	{
sl@0: 	++iCardinality;
sl@0: 	Touch();
sl@0: 	}
sl@0: 
sl@0: // an entry is removed
sl@0: inline void TDbStoreIndexStats::Dec()
sl@0: 	{
sl@0: 	--iCardinality;
sl@0: 	Touch();
sl@0: 	}
sl@0: 
sl@0: // contents have changed radically. provoke an immediate refresh
sl@0: inline void TDbStoreIndexStats::Reset(TInt aCardinality)
sl@0: 	{
sl@0: 	iCardinality=aCardinality;
sl@0: 	iRefresh=ERefresh;
sl@0: 	}
sl@0: 
sl@0: // stats have been refreshed. set for next update
sl@0: inline void TDbStoreIndexStats::Refresh(TDbStoreIndexStats::TType aType)
sl@0: 	{
sl@0: 	iFlags=(iFlags&~EFlgDiscrete)|aType;
sl@0: 	iRefresh=(iCardinality>>ERefreshFactor)+1;
sl@0: 	}
sl@0: 
sl@0: //
sl@0: // Internalize the index statistics
sl@0: // This must handle a stream externalized by builds before 052
sl@0: //
sl@0: void TDbStoreIndexStats::InternalizeL(RReadStream& aStream)
sl@0: 	{
sl@0: 	TCardinality c;
sl@0: 	aStream>>c;
sl@0: 	iCardinality=c;
sl@0: 	TUint refresh=aStream.ReadUint32L();
sl@0: 	iFlags=refresh&EFlagsMask;
sl@0: 	iRefresh=TInt(refresh>>ERefreshShift)+EInvalid;
sl@0: //
sl@0: // pre-build-052 data would run out here
sl@0: // if there is no more data, mark the (non-cardinality) stats as invalid
sl@0: //
sl@0: 	TRAPD(r,aStream>>iLower.iValue>>iUpper.iValue;)
sl@0: 	if (r==KErrEof)
sl@0: 		iRefresh=EInvalid;		// mark as invalid data
sl@0: 	else
sl@0: 		__LEAVE_IF_ERROR(r);	// just an "ordinary" error
sl@0: 	}
sl@0: 
sl@0: //
sl@0: // Notes: iCardinality cannot exceed 2^29 (due to storage mechanism)
sl@0: //		thus iRefresh cannot exceed 2^(29-ERefreshFactor)+1
sl@0: //		this leaves the 5 m.s.b. clear in iRefresh-EInvalid
sl@0: //		the flags bits are stored there
sl@0: //
sl@0: void TDbStoreIndexStats::ExternalizeL(RWriteStream& aStream) const
sl@0: 	{
sl@0: 	__ASSERT((iFlags&~EFlagsMask)==0);
sl@0: 	aStream<<TCardinality(iCardinality);
sl@0: 	aStream<<TUint32((TUint(iRefresh-EInvalid)<<ERefreshShift)|iFlags);
sl@0: 	aStream<<iLower.iValue<<iUpper.iValue;
sl@0: 	}
sl@0: 
sl@0: //
sl@0: // Reverse the span and bounds
sl@0: //
sl@0: TInt TDbStoreIndexStats::ReverseSpan(TUint aInclusion,const TDbLookupKey* aLower,const TDbLookupKey* aUpper,const TTextOps& aConv) const
sl@0: 	{
sl@0: 	__ASSERT(iLower.iValue>iUpper.iValue);
sl@0: 	TDbStoreIndexStats stats(*this);
sl@0: 	stats.iLower=iUpper;
sl@0: 	stats.iUpper=iLower;
sl@0: 	return stats.Span((aInclusion<<1)|(aInclusion>>1),aUpper,aLower,aConv);
sl@0: 	}
sl@0: 
sl@0: //
sl@0: // Evaluate the probable proportion of the index set contained within the bounds
sl@0: //
sl@0: TInt TDbStoreIndexStats::Span(TUint aInclusion,const TDbLookupKey* aLower,const TDbLookupKey* aUpper,const TTextOps& aConv) const
sl@0: 	{
sl@0: 	if (!IsValid())
sl@0: 		return CDbTable::EUnavailableSpan;	// No valid index data
sl@0: 	if (iCardinality==0)
sl@0: 		return 0;					// no rows at all
sl@0: //
sl@0: 	if (iLower.iValue>iUpper.iValue)
sl@0: 		return ReverseSpan(aInclusion,aLower,aUpper,aConv);	// descending index
sl@0: //
sl@0: 	aInclusion&=CDbRecordIndex::EIncludeBoth;
sl@0: 	TBound l(iLower);
sl@0: 	if (aLower)
sl@0: 		{
sl@0: 		TBound bound;
sl@0: 		bound.Set(*aLower->First(),aConv);
sl@0: 		if (bound.iValue>=l.iValue)
sl@0: 			l=bound;
sl@0: 		else
sl@0: 			aInclusion|=CDbRecordIndex::EIncludeLower;
sl@0: 		}
sl@0: 	else
sl@0: 		aInclusion|=CDbRecordIndex::EIncludeLower;
sl@0: //
sl@0: 	TBound h(iUpper);
sl@0: 	if (aUpper)
sl@0: 		{
sl@0: 		TBound bound;
sl@0: 		bound.Set(*aUpper->First(),aConv);
sl@0: 		if (bound.iValue<=h.iValue)
sl@0: 			h=bound;
sl@0: 		else
sl@0: 			aInclusion|=CDbRecordIndex::EIncludeUpper;
sl@0: 		}
sl@0: 	else
sl@0: 		aInclusion|=CDbRecordIndex::EIncludeUpper;
sl@0: //
sl@0: 	TRealX restrict(h.iValue);
sl@0: 	restrict.SubEq(l.iValue);		// extended precision--no errors
sl@0: 	TRealX span(iUpper.iValue);
sl@0: 	span.SubEq(iLower.iValue);
sl@0: 	if (iFlags&EFlgDiscrete)
sl@0: 		{
sl@0: 		if (aInclusion==0)
sl@0: 			--restrict;
sl@0: 		else if (aInclusion==CDbRecordIndex::EIncludeBoth)
sl@0: 			++restrict;
sl@0: 		++span;
sl@0: 		}
sl@0: 	else if (restrict.IsZero())		// single value continuous range
sl@0: 		{
sl@0: 		return (span.IsZero() && aInclusion==CDbRecordIndex::EIncludeBoth)
sl@0: 			? CDbTable::EFullIndexSpan : 0;
sl@0: 		}
sl@0: 	if (restrict<=TRealX(0))
sl@0: 		return 0;	// no overlap
sl@0: 	restrict.DivEq(span);
sl@0: 	restrict.MultEq(TInt(CDbTable::EFullIndexSpan));
sl@0: 	return TInt(restrict);
sl@0: 	}
sl@0: 
sl@0: 
sl@0: // Class CDbStoreIndex
sl@0: 
sl@0: inline CDbStoreIndex::HKey& CDbStoreIndex::Key() const
sl@0: 	{
sl@0: 	return *iKey;
sl@0: 	}
sl@0: 	
sl@0: inline const TBtree& CDbStoreIndex::Tree() const
sl@0: 	{
sl@0: 	return iTree;
sl@0: 	}
sl@0: 	
sl@0: inline TInt CDbStoreIndex::Count() const
sl@0: 	{
sl@0: 	return iStats.Cardinality();
sl@0: 	}
sl@0: 
sl@0: 
sl@0: // Class CDbStoreIndex::HKey
sl@0: 
sl@0: NONSHARABLE_CLASS(CDbStoreIndex::HKey) : public MBtreeKey
sl@0: 	{
sl@0: public:
sl@0: 	static HKey* NewL(const CDbKey& aKey,const HDbColumnSet& aColSet);
sl@0: //
sl@0: 	inline TInt EntrySize() const;
sl@0: 	virtual TInt KeySize() const;
sl@0: 	virtual TBool IncompleteKey() const;
sl@0: //
sl@0: 	TInt EntryL(TAny* aPtr,const RDbTableRow& aRow,TDbRecordId aRecord);
sl@0: 	TInt EntryL(TAny* aPtr,const TDbLookupKey& aKey);
sl@0: 	inline const TAny* Restriction() const;
sl@0: 	inline void Restrict(const TAny* aRestriction);
sl@0: //
sl@0: 	void Bound(TDbStoreIndexStats::TBound& aBound,const TAny* aEntry);
sl@0: 	TDbStoreIndexStats::TType KeyType() const;
sl@0: // from MBtreeKey
sl@0: 	const TAny* Key(const TAny* aRecord) const;
sl@0: 	TInt Compare(const TAny* aLeft,const TAny* aRight) const;
sl@0: protected:
sl@0: 	HKey() {}
sl@0: 	inline TBool FullComparison() const;
sl@0: // from MBtreeKey
sl@0: 	void Between(const TAny* aLeft,const TAny* aRight,TBtreePivot& aPivot) const;
sl@0: private:
sl@0: 	struct SKeyCol
sl@0: 		{
sl@0: 		TDbColNo iOrdinal;
sl@0: 		TInt iSize;
sl@0: 		TUint8 iType;
sl@0: 		TUint8 iOrder;
sl@0: 		};
sl@0: 	const TTextOps* iTextOps;
sl@0: 	TInt iSize;
sl@0: 	const SKeyCol* iEndOfKeys;
sl@0: 	const SKeyCol* iRestrictedEndOfKeys;
sl@0: 	SKeyCol iKeys[1];	// one or more keys
sl@0: 	};
sl@0: 
sl@0: NONSHARABLE_CLASS(CDbStoreIndex::HDupKey) : public CDbStoreIndex::HKey
sl@0: 	{
sl@0: 	friend class CDbStoreIndex::HKey;
sl@0: private:
sl@0: 	HDupKey() {}
sl@0: 	TInt KeySize() const;
sl@0: 	const TAny* Key(const TAny* aRecord) const;
sl@0: 	TInt Compare(const TAny* aLeft,const TAny* aRight) const;
sl@0: 	TBool IncompleteKey() const;
sl@0: 	};
sl@0: 
sl@0: inline TInt CDbStoreIndex::HKey::EntrySize() const
sl@0: 	{
sl@0: 	return iSize;
sl@0: 	}
sl@0: 	
sl@0: inline const TAny* CDbStoreIndex::HKey::Restriction() const
sl@0: 	{
sl@0: 	return iRestrictedEndOfKeys;
sl@0: 	}
sl@0: 	
sl@0: inline void CDbStoreIndex::HKey::Restrict(const TAny* aRestriction)
sl@0: 	{
sl@0: 	__ASSERT(aRestriction==0||(aRestriction>=iKeys&&aRestriction<=iEndOfKeys));
sl@0: 	iRestrictedEndOfKeys=(const SKeyCol*)aRestriction;
sl@0: 	}
sl@0: 	
sl@0: inline TBool CDbStoreIndex::HKey::FullComparison() const
sl@0: 	{
sl@0: 	return iRestrictedEndOfKeys==NULL;
sl@0: 	}
sl@0: 
sl@0: //
sl@0: // Construct the key based on the key definition (must be valid for the table)
sl@0: // and the column set provided
sl@0: //
sl@0: CDbStoreIndex::HKey* CDbStoreIndex::HKey::NewL(const CDbKey& aKey,const HDbColumnSet& aColumns)
sl@0: 	{
sl@0: 	TInt count=aKey.Count();
sl@0: 	HKey* self=(HKey*)User::AllocLC(_FOFF(HKey,iKeys[count]));
sl@0: 	if (aKey.IsUnique())
sl@0: 		new(self) HKey;
sl@0: 	else
sl@0: 		new(self) HDupKey;
sl@0: 	self->iTextOps=&TTextOps::Ops(aKey.Comparison());
sl@0: 	self->iEndOfKeys=&self->iKeys[count];
sl@0: 	self->iRestrictedEndOfKeys=NULL;
sl@0: 	TInt len=sizeof(TDbRecordId);
sl@0: 	SKeyCol* pKey=&self->iKeys[0];
sl@0: 	for (TInt ii=0;ii<count;++pKey,++ii)
sl@0: 		{
sl@0: 		const TDbKeyCol& key=aKey[ii];
sl@0: 		pKey->iOrder=TUint8(key.iOrder);
sl@0: 		pKey->iOrdinal=aColumns.ColNoL(key.iName);
sl@0: 		if (pKey->iOrdinal==KDbNullColNo)
sl@0: 			__LEAVE(KErrCorrupt);
sl@0: 		const TDbColumnDef& col=aColumns[pKey->iOrdinal];
sl@0: 		pKey->iType=col.iType;
sl@0: 		pKey->iSize=CDbStoreIndexDef::KeySize(key,col);
sl@0: 		len+=Align4(pKey->iSize);
sl@0: 		}
sl@0: 	self->iSize=len;
sl@0: 	if (self->KeySize()>KMaxIndexKeySize)
sl@0: 		__LEAVE(KErrCorrupt);
sl@0: 	CleanupStack::Pop();
sl@0: 	return self;
sl@0: 	}
sl@0: 
sl@0: //
sl@0: // Construct an entry at aPtr from the record given
sl@0: //
sl@0: TInt CDbStoreIndex::HKey::EntryL(TAny* aPtr,const RDbTableRow& aRow,TDbRecordId aRecord)
sl@0: 	{
sl@0: 	TUint8* ptr=(TUint8*)aPtr;
sl@0: 	Mem::FillZ(ptr,iSize);
sl@0: 	*REINTERPRET_CAST(TDbRecordId*,ptr)=aRecord;
sl@0: 	ptr+=sizeof(TDbRecordId);
sl@0: 	const SKeyCol* const end=iEndOfKeys;
sl@0: 	for (const SKeyCol* key=&iKeys[0];key<end;++key)
sl@0: 		{
sl@0: 		const TDbCell* cell=aRow.ColCell(key->iOrdinal);
sl@0: 		TInt size=key->iSize;
sl@0: 		if (cell->Length()!=0)
sl@0: 			{
sl@0: #ifdef __DOUBLE_WORDS_SWAPPED__
sl@0: 			if (key->iType==EDbColReal64)
sl@0: 				{
sl@0: 				const TUint32* data=(TUint32*)cell->Data();
sl@0: 				((TUint32*)ptr)[0]=data[1];
sl@0: 				((TUint32*)ptr)[1]=data[0];
sl@0: 				}
sl@0: 			else
sl@0: #endif
sl@0: 			if (TDbCol::IsLong(TDbColType(key->iType)))
sl@0: 				{
sl@0: 				const TDbBlob& blob=*(const TDbBlob*)cell->Data();
sl@0: 				if (blob.IsInline())
sl@0: 					Mem::Copy(ptr,blob.Data(),Min(size,blob.Size()));
sl@0: 				else
sl@0: 					{
sl@0: 					aRow.Table().BlobsL()->ReadLC(blob.Id(),TDbColType(key->iType))->ReadL(ptr,size);
sl@0: 					CleanupStack::PopAndDestroy();	// stream buffer
sl@0: 					}
sl@0: 				}
sl@0: 			else
sl@0: 				Mem::Copy(ptr,cell->Data(),Min(size,cell->Length()));
sl@0: 			}
sl@0: 		ptr+=Align4(size);
sl@0: 		}
sl@0: 	iRestrictedEndOfKeys=NULL;		// use the full key for comparison
sl@0: 	return EntrySize();
sl@0: 	}
sl@0: 
sl@0: //
sl@0: // Construct an entry from a lookup key
sl@0: //
sl@0: TInt CDbStoreIndex::HKey::EntryL(TAny* aPtr,const TDbLookupKey& aKey)
sl@0: 	{
sl@0: 	TUint8* ptr=(TUint8*)aPtr;
sl@0: 	Mem::FillZ(ptr,iSize);
sl@0: 	ptr+=sizeof(TDbRecordId);
sl@0: 	const TDbLookupKey::SColumn* lkey=aKey.First();
sl@0: 	const TDbLookupKey::SColumn* const lend=lkey+aKey.Count();
sl@0: 	__ASSERT(lkey<lend);
sl@0: 	const SKeyCol* const end=iEndOfKeys;
sl@0: 	const SKeyCol* key=&iKeys[0];
sl@0: 	for (;;)
sl@0: 		{
sl@0: 		TDbColType ltype=lkey->iType;
sl@0: 		TInt size=key->iSize;
sl@0: 		switch (key->iType)
sl@0: 			{
sl@0: 		default:
sl@0: 			__ASSERT(0);
sl@0: 		case EDbColBit:
sl@0: 		case EDbColUint8:
sl@0: 		case EDbColUint16:
sl@0: 		case EDbColUint32:
sl@0: 			if (ltype==EDbColUint32)
sl@0: 				{
sl@0: 				*(TUint32*)ptr=lkey->iUint32;
sl@0: 				break;
sl@0: 				}
sl@0: 			else if (ltype==EDbColInt32)
sl@0: 				{
sl@0: 				if (lkey->iInt32>=0)	// domain check, unsigned value
sl@0: 					{
sl@0: 					*(TUint32*)ptr=lkey->iInt32;
sl@0: 					break;
sl@0: 					}
sl@0: 				}
sl@0: 			else if (ltype==EDbColInt64)
sl@0: 				{
sl@0: 				const TInt64& v=lkey->iInt64;
sl@0: 				if (I64HIGH(v)==0)		// domain check, in unsigned 32-bit range
sl@0: 					{
sl@0: 					*(TUint32*)ptr=I64LOW(v);
sl@0: 					break;
sl@0: 					}
sl@0: 				}
sl@0: 			Panic(EDbWrongType);
sl@0: 			break;
sl@0: 		case EDbColInt8:
sl@0: 		case EDbColInt16:
sl@0: 		case EDbColInt32:
sl@0: 			if (ltype==EDbColInt32)
sl@0: 				{
sl@0: 				*(TInt32*)ptr=lkey->iInt32;
sl@0: 				break;
sl@0: 				}
sl@0: 			else if (ltype==EDbColUint32)
sl@0: 				{
sl@0: 				if (lkey->iUint32<=TUint(KMaxTInt))	// domain check, in signed range
sl@0: 					{
sl@0: 					*(TInt32*)ptr=lkey->iUint32;
sl@0: 					break;
sl@0: 					}
sl@0: 				}
sl@0: 			else if (ltype==EDbColInt64)
sl@0: 				{
sl@0: 				const TInt64& v=lkey->iInt64;
sl@0: 				TInt32 l=I64LOW(v);
sl@0: 				TInt32 h=I64HIGH(v);
sl@0: 				if (h==(l>>31))	// domain check, in signed 32-bit range
sl@0: 					{
sl@0: 					*(TInt32*)ptr=l;
sl@0: 					break;
sl@0: 					}
sl@0: 				}
sl@0: 			Panic(EDbWrongType);
sl@0: 			break;
sl@0: 		case EDbColReal32:
sl@0: 			if (ltype==EDbColReal32)
sl@0: 				{
sl@0: 				*(TReal32*)ptr=lkey->iReal32;
sl@0: 				break;
sl@0: 				}
sl@0: 			else if (ltype==EDbColReal64)
sl@0: 				{	// convert to TReal32, storing +-#inf if reqd.
sl@0: 				TRealX(lkey->iReal64).GetTReal(*(TReal32*)ptr);
sl@0: 				break;
sl@0: 				}
sl@0: 			Panic(EDbWrongType);
sl@0: 			break;
sl@0: 		case EDbColReal64:
sl@0: #ifdef __DOUBLE_WORDS_SWAPPED__
sl@0: 			if (ltype==EDbColReal64)
sl@0: 				{
sl@0: 				const TUint32* data=(TUint32*)&lkey->iReal64;
sl@0: 				((TUint32*)ptr)[0]=data[1];
sl@0: 				((TUint32*)ptr)[1]=data[0];
sl@0: 				break;
sl@0: 				}
sl@0: 			// drop through
sl@0: #endif
sl@0: 		case EDbColInt64:
sl@0: 		case EDbColDateTime:
sl@0: 			if (ltype==key->iType)
sl@0: 				Mem::Copy(ptr,&lkey->iInt64,size);	// all at same address
sl@0: 			else
sl@0: 				Panic(EDbWrongType);
sl@0: 			break;
sl@0: 		case EDbColText8:
sl@0: 		case EDbColLongText8:
sl@0: 			if (ltype==EDbColText8)
sl@0: 				Mem::Copy(ptr,lkey->iDes8.iPtr,Min(size,lkey->iDes8.iLength));
sl@0: 			else
sl@0: 				Panic(EDbWrongType);
sl@0: 			break;
sl@0: 		case EDbColText16:
sl@0: 		case EDbColLongText16:
sl@0: 			if (ltype==EDbColText16)
sl@0: 				Mem::Copy(ptr,lkey->iDes16.iPtr,Min(size,lkey->iDes16.iLength<<1));
sl@0: 			else
sl@0: 				Panic(EDbWrongType);
sl@0: 			break;
sl@0: 			}
sl@0: 		++key;
sl@0: 		if (++lkey==lend)
sl@0: 			break;							// end of lookup key
sl@0: 		if (key==end)
sl@0: 			__LEAVE(KErrArgument);		// too many keys
sl@0: 		ptr+=Align4(size);
sl@0: 		}
sl@0: 	iRestrictedEndOfKeys=key;				// use only the keys in the lookup for comparison
sl@0: 	return EntrySize();
sl@0: 	}
sl@0: 
sl@0: void CDbStoreIndex::HKey::Bound(TDbStoreIndexStats::TBound& aBound,const TAny* aEntry)
sl@0: 	{
sl@0: 	aEntry=PtrAdd(aEntry,sizeof(TDbRecordId));	// get to real key data
sl@0: 	switch (iKeys[0].iType)
sl@0: 		{
sl@0: 	default:
sl@0: 		__ASSERT(0);
sl@0: 	case EDbColBit:
sl@0: 	case EDbColUint8:
sl@0: 	case EDbColUint16:
sl@0: 	case EDbColUint32:
sl@0: 		aBound.Set(TInt64(TUint(*STATIC_CAST(const TUint32*,aEntry))));
sl@0: 		break;
sl@0: 	case EDbColInt8:
sl@0: 	case EDbColInt16:
sl@0: 	case EDbColInt32:
sl@0: 		aBound.Set(TInt64(TInt(*STATIC_CAST(const TInt32*,aEntry))));
sl@0: 		break;
sl@0: 	case EDbColInt64:
sl@0: 		aBound.Set(*STATIC_CAST(const TInt64*,aEntry));
sl@0: 		break;
sl@0: 	case EDbColDateTime:
sl@0: 		aBound.Set(STATIC_CAST(const TTime*,aEntry)->Int64());
sl@0: 		break;
sl@0: 	case EDbColReal32:
sl@0: 		aBound.Set(TReal64(*STATIC_CAST(const TReal32*,aEntry)));
sl@0: 		break;
sl@0: 	case EDbColReal64:
sl@0: #if !defined(__DOUBLE_WORDS_SWAPPED__)
sl@0: 		aBound.Set(*STATIC_CAST(const TReal64*,aEntry));
sl@0: #else
sl@0: 		{
sl@0: 		TReal64 xKey;
sl@0: 		((TUint32*)&xKey)[0]=STATIC_CAST(const TUint32*,aEntry)[1];
sl@0: 		((TUint32*)&xKey)[1]=STATIC_CAST(const TUint32*,aEntry)[0];
sl@0: 		aBound.Set(xKey);
sl@0: 		}
sl@0: #endif
sl@0: 		break;
sl@0: 	case EDbColText8:
sl@0: 	case EDbColLongText8:
sl@0: 		aBound.Set(STATIC_CAST(const TUint8*,aEntry),iKeys[0].iSize,*iTextOps);
sl@0: 		break;
sl@0: 	case EDbColText16:
sl@0: 	case EDbColLongText16:
sl@0: 		aBound.Set(STATIC_CAST(const TUint16*,aEntry),iKeys[0].iSize>>1,*iTextOps);
sl@0: 		break;
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: // Is the index key discrete or continous?
sl@0: inline TDbStoreIndexStats::TType CDbStoreIndex::HKey::KeyType() const
sl@0: 	{
sl@0: 	return iKeys[0].iType==EDbColReal32 || iKeys[0].iType==EDbColReal64
sl@0: 		? TDbStoreIndexStats::EContinuous : TDbStoreIndexStats::EDiscrete;
sl@0: 	}
sl@0: 
sl@0: TInt CDbStoreIndex::HKey::KeySize() const
sl@0: 	{
sl@0: 	return EntrySize()-sizeof(TDbRecordId);
sl@0: 	}
sl@0: 
sl@0: //
sl@0: // Report 'true' if the lookup key is not the entire B+tree key
sl@0: // For a unique index this is if there is a restriction to less than the full key
sl@0: //
sl@0: TBool CDbStoreIndex::HKey::IncompleteKey() const
sl@0: 	{
sl@0: 	return iRestrictedEndOfKeys!=0 && iRestrictedEndOfKeys!=iEndOfKeys;
sl@0: 	}
sl@0: 
sl@0: //
sl@0: // For unique keys, key is after record id
sl@0: //
sl@0: const TAny* CDbStoreIndex::HKey::Key(const TAny* aRecord) const
sl@0: 	{
sl@0: 	return PtrAdd(aRecord,sizeof(TDbRecordId));
sl@0: 	}
sl@0: 
sl@0: //
sl@0: // compare the key part of the entry
sl@0: //
sl@0: TInt CDbStoreIndex::HKey::Compare(const TAny* aLeft,const TAny* aRight) const
sl@0: 	{
sl@0: 	const SKeyCol* end=iRestrictedEndOfKeys;
sl@0: 	if (end==NULL)
sl@0: 		end=iEndOfKeys;
sl@0: 	const SKeyCol* key=&iKeys[0];
sl@0: 	for (;;)
sl@0: 		{
sl@0: 		TInt size=key->iSize;
sl@0: 		TInt rr;
sl@0: 		switch (key->iType)
sl@0: 			{
sl@0: 		default:
sl@0: 			__ASSERT(0);
sl@0: 		case EDbColBit:
sl@0: 		case EDbColUint8:
sl@0: 		case EDbColUint16:
sl@0: 		case EDbColUint32:
sl@0: 			rr=Comp::Compare(*STATIC_CAST(const TUint32*,aLeft),*STATIC_CAST(const TUint32*,aRight));
sl@0: 			break;
sl@0: 		case EDbColInt8:
sl@0: 		case EDbColInt16:
sl@0: 		case EDbColInt32:
sl@0: 			rr=Comp::Compare(*STATIC_CAST(const TInt32*,aLeft),*STATIC_CAST(const TInt32*,aRight));
sl@0: 			break;
sl@0: 		case EDbColInt64:
sl@0: 			rr=Comp::Compare(*STATIC_CAST(const TInt64*,aLeft),*STATIC_CAST(const TInt64*,aRight));
sl@0: 			break;
sl@0: 		case EDbColDateTime:
sl@0: 			rr=Comp::Compare(*STATIC_CAST(const TTime*,aLeft),*STATIC_CAST(const TTime*,aRight));
sl@0: 			break;
sl@0: 		case EDbColReal32:
sl@0: 			rr=Comp::Compare(*STATIC_CAST(const TReal32*,aLeft),*STATIC_CAST(const TReal32*,aRight));
sl@0: 			break;
sl@0: 		case EDbColReal64:
sl@0: #if !defined(__DOUBLE_WORDS_SWAPPED__)
sl@0: 			rr=Comp::Compare(*STATIC_CAST(const TReal64*,aLeft),*STATIC_CAST(const TReal64*,aRight));
sl@0: #else
sl@0: 			TReal64 xLeft;
sl@0: 			((TUint32*)&xLeft)[0]=STATIC_CAST(const TUint32*,aLeft)[1];
sl@0: 			((TUint32*)&xLeft)[1]=STATIC_CAST(const TUint32*,aLeft)[0];
sl@0: 			TReal64 xRight;
sl@0: 			((TUint32*)&xRight)[0]=STATIC_CAST(const TUint32*,aRight)[1];
sl@0: 			((TUint32*)&xRight)[1]=STATIC_CAST(const TUint32*,aRight)[0];
sl@0: 			rr=Comp::Compare(xLeft,xRight);
sl@0: #endif
sl@0: 			break;
sl@0: 		case EDbColText8:
sl@0: 		case EDbColLongText8:
sl@0: 			rr=iTextOps->Compare(STATIC_CAST(const TUint8*,aLeft),size,STATIC_CAST(const TUint8*,aRight),size);
sl@0: 			break;
sl@0: 		case EDbColText16:
sl@0: 		case EDbColLongText16:
sl@0: 			rr=iTextOps->Order(STATIC_CAST(const TUint16*,aLeft),size>>1,STATIC_CAST(const TUint16*,aRight),size>>1);
sl@0: 			break;
sl@0: 			}
sl@0: 		if (rr!=0)
sl@0: 			return key->iOrder==TDbKeyCol::EAsc ? rr : -rr;
sl@0: 		if (++key==end)
sl@0: 			return rr;
sl@0: 		size=Align4(size);
sl@0: 		aLeft=PtrAdd(aLeft,size);
sl@0: 		aRight=PtrAdd(aRight,size);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: //
sl@0: // No clever stuff yet
sl@0: //
sl@0: void CDbStoreIndex::HKey::Between(const TAny* aLeft,const TAny* /*aRight*/,TBtreePivot& aPivot) const
sl@0: 	{
sl@0: 	aPivot.Copy((const TUint8*)aLeft,KeySize());
sl@0: 	}
sl@0: 
sl@0: // Class CDbStoreIndex::HDupKey
sl@0: 
sl@0: TInt CDbStoreIndex::HDupKey::KeySize() const
sl@0: 	{
sl@0: 	return EntrySize();
sl@0: 	}
sl@0: 
sl@0: //
sl@0: // Report 'true' if the lookup key is not the entire B+tree key
sl@0: // For a duplicates index this is if there is a restriction (as record id is ingored)
sl@0: //
sl@0: TBool CDbStoreIndex::HDupKey::IncompleteKey() const
sl@0: 	{
sl@0: 	return Restriction()!=0;
sl@0: 	}
sl@0: 
sl@0: //
sl@0: // The key includes the record id
sl@0: //
sl@0: const TAny* CDbStoreIndex::HDupKey::Key(const TAny* aRecord) const
sl@0: 	{
sl@0: 	return aRecord;
sl@0: 	}
sl@0: 
sl@0: TInt CDbStoreIndex::HDupKey::Compare(const TAny* aLeft,const TAny* aRight) const
sl@0: 	{
sl@0: 	const TDbRecordId* const left=(const TDbRecordId*)aLeft;
sl@0: 	const TDbRecordId* const right=(const TDbRecordId*)aRight;
sl@0: 	TInt rr=HKey::Compare(left+1,right+1);
sl@0: 	if (rr==0 && FullComparison())
sl@0: 		return Comp::Compare(left->Value(),right->Value());
sl@0: 	return rr;
sl@0: 	}
sl@0: 
sl@0: // Class CDbStoreIndex::CIter
sl@0: 
sl@0: NONSHARABLE_CLASS(CDbStoreIndex::CIter) : public CDbRecordIter
sl@0: 	{
sl@0: public:
sl@0: 	static CIter* NewL(CDbStoreIndex& aIndex,TUint aInclusion,const TDbLookupKey* aLowerBound,const TDbLookupKey* aUpperBound);
sl@0: private:
sl@0: 	inline CIter(CDbStoreIndex& aIndex);
sl@0: 	~CIter();
sl@0: 	void ConstructL(TUint aInclusion,const TDbLookupKey* aLowerBound,const TDbLookupKey* aUpperBound);
sl@0: 	TAny* BoundL(const TDbLookupKey& aBound,const TAny*& aRestriction);
sl@0: //
sl@0: 	inline const CDbStoreIndex& Index() const;
sl@0: 	TBool FindL(TDbRecordId aRecordId,const RDbTableRow& aRow,TBtree::TFind aFind);
sl@0: 	TInt CompareL(const TAny* aBound,const TAny* aRestriction);
sl@0: 	TBool _GotoL(TDbPosition aPosition);
sl@0: //
sl@0: 	TInt Count() const;
sl@0: 	TDbRecordId CurrentL();
sl@0: 	TBool GotoL(TDbPosition aPosition);
sl@0: 	TBool GotoL(TDbRecordId aRecordId,RDbTableRow& aBuffer);
sl@0: 	TBool SeekL(const TDbLookupKey& aKey,RDbTable::TComparison aComparison);
sl@0: 	TDeleted DoDeletedL(TDbPosition aPosition,TDbRecordId aRecordId,const RDbTableRow* aRow);
sl@0: private:
sl@0: 	TBtreePos iPos;
sl@0: 	TUint8 iLowerSeek;
sl@0: 	TUint8 iLowerCheck;
sl@0: 	TUint8 iUpperSeek;
sl@0: 	TUint8 iUpperCheck;
sl@0: 	TAny* iLowerBound;
sl@0: 	const TAny* iLowerRestriction;
sl@0: 	TAny* iUpperBound;
sl@0: 	const TAny* iUpperRestriction;
sl@0: 	};
sl@0: 
sl@0: inline CDbStoreIndex::CIter::CIter(CDbStoreIndex& aIndex) :
sl@0: 	CDbRecordIter(aIndex)
sl@0: 	{
sl@0: 	}
sl@0: 	
sl@0: inline const CDbStoreIndex& CDbStoreIndex::CIter::Index() const
sl@0: 	{
sl@0: 	return STATIC_CAST(CDbStoreIndex&,Host());
sl@0: 	}
sl@0: 
sl@0: CDbStoreIndex::CIter* CDbStoreIndex::CIter::NewL(CDbStoreIndex& aIndex,TUint aInclusion,const TDbLookupKey* aLowerBound,const TDbLookupKey* aUpperBound)
sl@0: 	{
sl@0: 	CIter* self=new(ELeave) CIter(aIndex);
sl@0: 	CleanupStack::PushL(self);
sl@0: 	self->ConstructL(aInclusion,aLowerBound,aUpperBound);
sl@0: 	CleanupStack::Pop();
sl@0: 	return self;
sl@0: 	}
sl@0: 
sl@0: CDbStoreIndex::CIter::~CIter()
sl@0: 	{
sl@0: 	User::Free(iLowerBound);
sl@0: 	User::Free(iUpperBound);
sl@0: 	}
sl@0: 
sl@0: void CDbStoreIndex::CIter::ConstructL(TUint aInclusion,const TDbLookupKey* aLowerBound,const TDbLookupKey* aUpperBound)
sl@0: 	{
sl@0: 	if (aLowerBound)
sl@0: 		{
sl@0: 		TBtree::TFind seek=TBtree::EGreaterEqual;
sl@0: 		if ((aInclusion&CDbRecordIndex::EIncludeLower)==0)
sl@0: 			{
sl@0: 			seek=TBtree::EGreaterThan;
sl@0: 			iLowerCheck=1;
sl@0: 			}
sl@0: 		iLowerSeek=TUint8(seek);
sl@0: 		iLowerBound=BoundL(*aLowerBound,iLowerRestriction);
sl@0: 		}
sl@0: 	if (aUpperBound)
sl@0: 		{
sl@0: 		TBtree::TFind seek=TBtree::ELessThan;
sl@0: 		if (aInclusion&CDbRecordIndex::EIncludeUpper)
sl@0: 			{
sl@0: 			seek=TBtree::ELessEqual;
sl@0: 			iUpperCheck=1;
sl@0: 			}
sl@0: 		iUpperSeek=TUint8(seek);
sl@0: 		iUpperBound=BoundL(*aUpperBound,iUpperRestriction);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: //
sl@0: // Construct and allocate a key for the boundary value
sl@0: //
sl@0: TAny* CDbStoreIndex::CIter::BoundL(const TDbLookupKey& aBound,const TAny*& aRestriction)
sl@0: 	{
sl@0: 	TUint8 entry[KMaxBtreeKeyLength];
sl@0: 	HKey& key=Index().Key();
sl@0: 	TInt size=key.EntryL(entry,aBound);
sl@0: 	const TUint8* ekey=(const TUint8*)key.Key(entry);
sl@0: 	size-=ekey-entry;
sl@0: 	TAny* e=User::AllocL(size);
sl@0: 	Mem::Copy(e,ekey,size);
sl@0: 	aRestriction=key.Restriction();
sl@0: 	return e;
sl@0: 	}
sl@0: 
sl@0: //
sl@0: // Extract the current key and compare it with a boundary key
sl@0: //
sl@0: TInt CDbStoreIndex::CIter::CompareL(const TAny* aBound,const TAny* aRestriction)
sl@0: 	{
sl@0: 	TUint8 entry[KMaxBtreeKeyLength];
sl@0: 	HKey& key=Index().Key();
sl@0: 	key.Restrict(aRestriction);
sl@0: 	Index().Tree().ExtractAtL(iPos,entry,key.EntrySize());
sl@0: 	return key.Compare(key.Key(entry),aBound);
sl@0: 	}
sl@0: 
sl@0: //
sl@0: // return the cardinality of the index
sl@0: //
sl@0: TInt CDbStoreIndex::CIter::Count() const
sl@0: 	{
sl@0: 	if (iLowerBound)
sl@0: 		return KDbUndefinedCount;
sl@0: 	if (iUpperBound)
sl@0: 		return KDbUndefinedCount;
sl@0: 	return Index().Count();
sl@0: 	}
sl@0: 
sl@0: //
sl@0: // return the current record id
sl@0: //
sl@0: TDbRecordId CDbStoreIndex::CIter::CurrentL()
sl@0: 	{
sl@0: 	TDbRecordId id;
sl@0: 	Index().Tree().ExtractAtL(iPos,&id,sizeof(id));
sl@0: 	return id;
sl@0: 	}
sl@0: 
sl@0: //
sl@0: // iterate to the required position, does not test the boundary condition
sl@0: //
sl@0: TBool CDbStoreIndex::CIter::_GotoL(TDbPosition aPosition)
sl@0: 	{
sl@0: 	const TBtree& tree=Index().Tree();
sl@0: 	switch (aPosition)
sl@0: 		{
sl@0: 	default:	// all control paths return a value
sl@0: 		__ASSERT(0);
sl@0: 	case EDbNext:
sl@0: 		return tree.NextL(iPos);
sl@0: 	case EDbPrevious:
sl@0: 		return tree.PreviousL(iPos);
sl@0: 	case EDbFirst:
sl@0: 		if (!iLowerBound)
sl@0: 			return tree.FirstL(iPos);
sl@0: 		Index().Key().Restrict(iLowerRestriction);
sl@0: 		return tree.FindL(iPos,iLowerBound,TBtree::TFind(iLowerSeek));
sl@0: 	case EDbLast:
sl@0: 		if (!iUpperBound)
sl@0: 			return tree.LastL(iPos);
sl@0: 		Index().Key().Restrict(iUpperRestriction);
sl@0: 		return tree.FindL(iPos,iUpperBound,TBtree::TFind(iUpperSeek));
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: //
sl@0: // iterate to the required position and check that it is in bounds
sl@0: //
sl@0: TBool CDbStoreIndex::CIter::GotoL(TDbPosition aPosition)
sl@0: 	{
sl@0: 	TBool r=_GotoL(aPosition);
sl@0: 	if (r)
sl@0: 		{
sl@0: 		if (aPosition==EDbFirst || aPosition==EDbNext)
sl@0: 			{
sl@0: 			if (iUpperBound)
sl@0: 				return CompareL(iUpperBound,iUpperRestriction)-iUpperCheck<0;
sl@0: 			}
sl@0: 		else
sl@0: 			{
sl@0: 			if (iLowerBound)
sl@0: 				return CompareL(iLowerBound,iLowerRestriction)-iLowerCheck>=0;
sl@0: 			}
sl@0: 		}
sl@0: 	return r;
sl@0: 	}
sl@0: 
sl@0: //
sl@0: // Construct the Btree key for the row and lookup
sl@0: //
sl@0: TBool CDbStoreIndex::CIter::FindL(TDbRecordId aRecordId,const RDbTableRow& aRow,TBtree::TFind aFind)
sl@0: 	{
sl@0: 	TUint8 entry[KMaxBtreeKeyLength];
sl@0: 	HKey& key=Index().Key();
sl@0: 	key.EntryL(entry,aRow,aRecordId);
sl@0: 	return Index().Tree().FindL(iPos,key.Key(entry),aFind);
sl@0: 	}
sl@0: 
sl@0: //
sl@0: // Go directly to a row
sl@0: //
sl@0: TBool CDbStoreIndex::CIter::GotoL(TDbRecordId aRecordId,RDbTableRow& aRow)
sl@0: 	{
sl@0: 	aRow.ReadL(aRecordId);
sl@0: 	return FindL(aRecordId,aRow,TBtree::EEqualTo);
sl@0: 	}
sl@0: 
sl@0: //
sl@0: // Do a keyed lookup in the index
sl@0: //
sl@0: TBool CDbStoreIndex::CIter::SeekL(const TDbLookupKey& aKey,RDbTable::TComparison aComparison)
sl@0: 	{
sl@0: 	TUint8 entry[KMaxBtreeKeyLength];
sl@0: 	HKey& key=Index().Key();
sl@0: 	key.EntryL(entry,aKey);
sl@0: 	const TAny* ekey=key.Key(entry);
sl@0: 	TBtree::TFind find;
sl@0: 	switch (aComparison)
sl@0: 		{
sl@0: 	default:
sl@0: 		__ASSERT(0);
sl@0: 	case RDbTable::ELessThan:
sl@0: 		find=TBtree::ELessThan;
sl@0: 		break;
sl@0: 	case RDbTable::ELessEqual:
sl@0: 		find=TBtree::ELessEqual;
sl@0: 		break;
sl@0: 	case RDbTable::EEqualTo:
sl@0: 		if (key.IncompleteKey())
sl@0: 			{
sl@0: 			// The B+tree search code cannot correctly do a == search when the
sl@0: 			// comparison key is not complete. Instead we do a >= search and then
sl@0: 			// check the returned entry does match
sl@0: 			//
sl@0: 			if (!Index().Tree().FindL(iPos,ekey,TBtree::EGreaterEqual))
sl@0: 				return EFalse;	// off the end
sl@0: 			return CompareL(ekey,key.Restriction())==0;
sl@0: 			}
sl@0: 		find=TBtree::EEqualTo;
sl@0: 		break;
sl@0: 	case RDbTable::EGreaterEqual:
sl@0: 		find=TBtree::EGreaterEqual;
sl@0: 		break;
sl@0: 	case RDbTable::EGreaterThan:
sl@0: 		find=TBtree::EGreaterThan;
sl@0: 		break;
sl@0: 		}
sl@0: 	return Index().Tree().FindL(iPos,ekey,find);
sl@0: 	}
sl@0: 
sl@0: //
sl@0: // Set the iterator following a record deletion
sl@0: //
sl@0: CDbStoreIndex::CIter::TDeleted CDbStoreIndex::CIter::DoDeletedL(TDbPosition aPosition,TDbRecordId aRecordId,const RDbTableRow* aRow)
sl@0: 	{
sl@0: 	if (aRow==0)
sl@0: 		return ENotSupported;
sl@0: 	return FindL(aRecordId,*aRow,aPosition==EDbNext ? TBtree::EGreaterEqual : TBtree::ELessEqual) ? EAtRow : ENoRow;
sl@0: 	}
sl@0: 
sl@0: // Class CDbStoreIndex
sl@0: 
sl@0: CDbStoreIndex::CDbStoreIndex(CDbStoreDatabase& aDatabase,const CDbStoreIndexDef& aDef) :
sl@0: 	iDatabase(aDatabase), 
sl@0: 	iTree(EBtreeFast), 
sl@0: 	iStats(MUTABLE_CAST(TDbStoreIndexStats&,aDef.iStats))
sl@0: 	{
sl@0: 	}
sl@0: 
sl@0: CDbStoreIndex::~CDbStoreIndex()
sl@0: 	{
sl@0: 	delete iKey;
sl@0: 	}
sl@0: 
sl@0: //
sl@0: // Create the persistent representation of the index in the store
sl@0: //
sl@0: TStreamId CDbStoreIndex::CreateL(CDbStoreDatabase& aDatabase,const CDbStoreIndexDef& aDef)
sl@0: 	{
sl@0: 	MUTABLE_CAST(TDbStoreIndexStats&,aDef.iStats).Reset();
sl@0: 	RStoreWriteStream strm;
sl@0: 	TStreamId id=strm.CreateLC(aDatabase.Store());
sl@0: 	strm<<KEmptyBtreeToken<<aDef.iStats;
sl@0: 	strm.CommitL();
sl@0: 	CleanupStack::PopAndDestroy();
sl@0: 	return id;
sl@0: 	}
sl@0: 
sl@0: //
sl@0: // Check the index for damage (without constructing the object)
sl@0: //
sl@0: TBool CDbStoreIndex::IsDamagedL(CDbStoreDatabase& aDatabase,const CDbStoreIndexDef& aDef)
sl@0: 	{
sl@0: 	RStoreReadStream strm;
sl@0: 	strm.OpenLC(aDatabase.Store(),aDef.TokenId());
sl@0: 	TBtreeToken token;
sl@0: 	strm>>token;
sl@0: 	CleanupStack::PopAndDestroy();
sl@0: 	return token.IsBroken();
sl@0: 	}
sl@0: 
sl@0: //
sl@0: // Create a StoreIndex object
sl@0: //
sl@0: CDbStoreIndex* CDbStoreIndex::NewL(CDbStoreDatabase& aDatabase,const CDbStoreIndexDef& aDef,const CDbTableDef& aTable)
sl@0: 	{
sl@0: 	CDbStoreIndex* self=new(ELeave) CDbStoreIndex(aDatabase,aDef);
sl@0: 	CleanupStack::PushL(self);
sl@0: 	self->iTokenId=aDef.TokenId();
sl@0: 	HKey* key=self->iKey=HKey::NewL(aDef.Key(),aTable.Columns());
sl@0: 	self->iLeafOrg.SetEntrySize(key->EntrySize());
sl@0: 	self->iIndexOrg.SetEntrySize(key->KeySize());
sl@0: 	self->iTree.Connect(&aDatabase.PagePoolL(),key,&self->iLeafOrg,&self->iIndexOrg);
sl@0: 	CleanupStack::Pop();
sl@0: 	return self;
sl@0: 	}
sl@0: 
sl@0: //
sl@0: // restore from the Store
sl@0: //
sl@0: TBool CDbStoreIndex::RestoreL()
sl@0: 	{
sl@0: 	RStoreReadStream strm;
sl@0: 	strm.OpenLC(iDatabase.Store(),iTokenId);
sl@0: 	TBtreeToken token;
sl@0: 	strm>>token>>iStats;
sl@0: 	CleanupStack::PopAndDestroy();
sl@0: 	iTree.Set(token,EBtreeFast);
sl@0: 	return iTree.IsBroken();
sl@0: 	}
sl@0: 
sl@0: //
sl@0: // Update the index statistics from the index
sl@0: //
sl@0: void CDbStoreIndex::RefreshStatsL()
sl@0: 	{
sl@0: 	HKey& key=Key();
sl@0: 	TBtreePos pos;
sl@0: 	if (iTree.FirstL(pos))
sl@0: 		{
sl@0: 		TUint8 entry[KMaxBtreeKeyLength];
sl@0: 		Tree().ExtractAtL(pos,entry,key.EntrySize());
sl@0: 		key.Bound(iStats.iLower,entry);
sl@0: 		iTree.LastL(pos);
sl@0: 		Tree().ExtractAtL(pos,entry,key.EntrySize());
sl@0: 		key.Bound(iStats.iUpper,entry);
sl@0: 		}
sl@0: 	iStats.Refresh(key.KeyType());
sl@0: 	}
sl@0: 
sl@0: //
sl@0: // Framework member: synchronise the persistent data
sl@0: //
sl@0: void CDbStoreIndex::SynchL()
sl@0: 	{
sl@0: 	if (iStats.NeedsRefresh())
sl@0: 		RefreshStatsL();
sl@0: 	RStoreWriteStream strm;
sl@0: 	strm.ReplaceLC(iDatabase.Store(),iTokenId);
sl@0: 	strm<<iTree.Token()<<iStats;
sl@0: 	strm.CommitL();
sl@0: 	CleanupStack::PopAndDestroy();
sl@0: 	}
sl@0: 
sl@0: //
sl@0: // Framework member: mark the persistent token dirty
sl@0: //
sl@0: void CDbStoreIndex::AboutToModifyL()
sl@0: 	{
sl@0: 	iDatabase.MarkL();
sl@0: 	if (!iTree.IsEmpty())	// empty btrees are unbreakable
sl@0: 		{
sl@0: 		TBtreeToken token=iTree.Token();
sl@0: 		token.Touch();		// mark persistent data as broken
sl@0: 		RStoreWriteStream strm;
sl@0: 		strm.OpenLC(iDatabase.Store(),iTokenId);
sl@0: 		strm<<token;
sl@0: 		strm.CommitL();
sl@0: 		CleanupStack::PopAndDestroy();
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: //
sl@0: // Try to find a record in the index
sl@0: // return ENoMatch if no key match, EEntryMatch if entire entry is present
sl@0: // EKeyMatch if only key matches (only for unique indexes)
sl@0: //
sl@0: CDbStoreIndex::TFind CDbStoreIndex::FindL(TDbRecordId aRecordId,const RDbTableRow& aRow)
sl@0: 	{
sl@0: 	__ASSERT((!iTree.IsEmpty())==(Count()!=0));
sl@0: 	TUint8 entry[KMaxBtreeKeyLength];
sl@0: 	iKey->EntryL(entry,aRow,aRecordId);
sl@0: 	TBtreePos pos;
sl@0: 	if (!iTree.FindL(pos,iKey->Key(entry)))
sl@0: 		return ENoMatch;
sl@0: 	TDbRecordId id;
sl@0: 	iTree.ExtractAtL(pos,&id,sizeof(id));
sl@0: 	return id==aRecordId ? EEntryMatch : EKeyMatch;
sl@0: 	}
sl@0: 
sl@0: //
sl@0: // Add the row to the index
sl@0: // return True if insertion was good, false if duplicate found
sl@0: //
sl@0: TBool CDbStoreIndex::DoInsertL(TDbRecordId aRecordId,const RDbTableRow& aRow)
sl@0: 	{
sl@0: 	__ASSERT((!iTree.IsEmpty())==(Count()!=0));
sl@0: 	TUint8 entry[KMaxBtreeKeyLength];
sl@0: 	TInt len=iKey->EntryL(entry,aRow,aRecordId);
sl@0: 	TBtreePos pos;
sl@0: 	TBool insert=iTree.InsertL(pos,entry,len);
sl@0: 	if (insert)
sl@0: 		iStats.Inc();
sl@0: 	return insert;
sl@0: 	}
sl@0: 
sl@0: //
sl@0: // Remove row from index
sl@0: //
sl@0: void CDbStoreIndex::DoDeleteL(TDbRecordId aRecordId,const RDbTableRow& aRow)
sl@0: 	{
sl@0: 	__ASSERT((!iTree.IsEmpty())==(Count()!=0));
sl@0: 	TUint8 entry[KMaxBtreeKeyLength];
sl@0: 	iKey->EntryL(entry,aRow,aRecordId);
sl@0: 	__DEBUG(TInt dbgchk=) iTree.DeleteL(iKey->Key(entry));
sl@0: 	__ASSERT(dbgchk);
sl@0: 	iStats.Dec();
sl@0: 	}
sl@0: 
sl@0: //
sl@0: // Provide an iterator for the index ordering
sl@0: //
sl@0: CDbRecordIter* CDbStoreIndex::IteratorL(TUint aInclusion,const TDbLookupKey* aLowerBound,const TDbLookupKey* aUpperBound)
sl@0: 	{
sl@0: 	return CIter::NewL(*this,aInclusion,aLowerBound,aUpperBound);
sl@0: 	}
sl@0: 
sl@0: //
sl@0: // repair the tree from the sequence set after reclamation of the page pool
sl@0: //
sl@0: void CDbStoreIndex::RepairL()
sl@0: 	{
sl@0: 	if (!iTree.IsEmpty())	// empty trees are unbreakable
sl@0: 		{
sl@0: 		TouchL();
sl@0: 		iTree.MarkBroken();
sl@0: 		iStats.Reset(iTree.RepairL());
sl@0: 		SynchL();
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: //
sl@0: // Throw away the index data, also used prior to a recovering rebuild
sl@0: //
sl@0: void CDbStoreIndex::DiscardL()
sl@0: 	{
sl@0: 	TouchL();
sl@0: 	iTree.ClearL();
sl@0: 	iStats.Reset();
sl@0: 	MarkIntact();
sl@0: 	}
sl@0: 
sl@0: //
sl@0: // Throw away the token
sl@0: //
sl@0: void CDbStoreIndex::DestroyL()
sl@0: 	{
sl@0: 	iDatabase.Store().DeleteL(iTokenId);
sl@0: 	}
sl@0: 
sl@0: // Class CDbStoreIndex::CDiscarder
sl@0: 
sl@0: CDbStoreIndex::CDiscarder::CDiscarder()
sl@0: 	{}
sl@0: 
sl@0: CDbStoreIndex::CDiscarder::~CDiscarder()
sl@0: 	{
sl@0: 	delete iIndex;
sl@0: 	}
sl@0: 
sl@0: TInt CDbStoreIndex::CDiscarder::Open(CDbStoreIndex* anIndex)
sl@0: 	{
sl@0: 	__ASSERT(!iIndex);
sl@0: 	iIndex=anIndex;
sl@0: 	return 1;
sl@0: 	}
sl@0: 
sl@0: //
sl@0: // Do the single step of index discard
sl@0: //
sl@0: TInt CDbStoreIndex::CDiscarder::StepL(TInt)
sl@0: 	{
sl@0: 	__ASSERT(iIndex);
sl@0: 	CDbStoreIndex& index=*iIndex;
sl@0: 	index.DiscardL();
sl@0: 	index.DestroyL();
sl@0: 	return 0;
sl@0: 	}