1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/dbms/ustor/US_INDEX.CPP Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,1237 @@
1.4 +// Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).
1.5 +// All rights reserved.
1.6 +// This component and the accompanying materials are made available
1.7 +// under the terms of "Eclipse Public License v1.0"
1.8 +// which accompanies this distribution, and is available
1.9 +// at the URL "http://www.eclipse.org/legal/epl-v10.html".
1.10 +//
1.11 +// Initial Contributors:
1.12 +// Nokia Corporation - initial contribution.
1.13 +//
1.14 +// Contributors:
1.15 +//
1.16 +// Description:
1.17 +//
1.18 +
1.19 +#include "US_STD.H"
1.20 +#include "D32COMP.H"
1.21 +
1.22 +// Class TDbStoreIndexStats::TBound
1.23 +
1.24 +inline void TDbStoreIndexStats::TBound::Set(TReal64 aBound)
1.25 + {iValue=aBound;}
1.26 +
1.27 +void TDbStoreIndexStats::TBound::Set(const TInt64& aBound)
1.28 + {iValue=I64REAL(aBound);}
1.29 +
1.30 +void TDbStoreIndexStats::TBound::Set(const TText8* aPtr,TInt aLen,const TTextOps& aConv)
1.31 + {
1.32 + TInt64 v(0u);
1.33 + const TText8* const end=aPtr+aLen;
1.34 + TInt shift=48;
1.35 + do
1.36 + {
1.37 + if (aPtr==end)
1.38 + break;
1.39 + TInt64 t(aConv.Fold(*aPtr++));
1.40 + t<<=shift;
1.41 + v+=t;
1.42 + } while ((shift-=8)>=0);
1.43 + Set(v);
1.44 + }
1.45 +
1.46 +void TDbStoreIndexStats::TBound::Set(const TText16* aPtr,TInt aLen,const TTextOps& aConv)
1.47 + {
1.48 + TInt64 v(0u);
1.49 + const TText16* const end=aPtr+aLen;
1.50 + TInt shift=32;
1.51 + do
1.52 + {
1.53 + if (aPtr==end)
1.54 + break;
1.55 + TInt64 t(aConv.Fold(*aPtr++));
1.56 + t<<=shift;
1.57 + v+=t;
1.58 + } while ((shift-=16)>=0);
1.59 + Set(v);
1.60 + }
1.61 +
1.62 +void TDbStoreIndexStats::TBound::Set(const TDbLookupKey::SColumn& aBound,const TTextOps& aConv)
1.63 + {
1.64 + switch (aBound.iType)
1.65 + {
1.66 + default:
1.67 + __ASSERT(0);
1.68 + case EDbColInt64:
1.69 + Set(aBound.iInt64);
1.70 + break;
1.71 + case EDbColDateTime:
1.72 + Set(aBound.iTime().Int64());
1.73 + break;
1.74 + case EDbColReal64:
1.75 + Set(aBound.iReal64);
1.76 + break;
1.77 + case EDbColText8:
1.78 + Set(aBound.iDes8.iPtr,aBound.iDes8.iLength,aConv);
1.79 + break;
1.80 + case EDbColText16:
1.81 + Set(aBound.iDes16.iPtr,aBound.iDes16.iLength,aConv);
1.82 + break;
1.83 + }
1.84 + }
1.85 +
1.86 +// Class TDbStoreIndexStats
1.87 +
1.88 +inline TBool TDbStoreIndexStats::NeedsRefresh() const
1.89 + {
1.90 + return iRefresh<=ERefresh;
1.91 + }
1.92 +
1.93 +inline TInt TDbStoreIndexStats::Cardinality() const
1.94 + {
1.95 + return iCardinality;
1.96 + }
1.97 +
1.98 +// update the refresh count
1.99 +inline void TDbStoreIndexStats::Touch()
1.100 + {
1.101 + TInt r=iRefresh-1;
1.102 + if (r>=ERefresh)
1.103 + iRefresh=r;
1.104 + }
1.105 +
1.106 +// an entry is inserted
1.107 +inline void TDbStoreIndexStats::Inc()
1.108 + {
1.109 + ++iCardinality;
1.110 + Touch();
1.111 + }
1.112 +
1.113 +// an entry is removed
1.114 +inline void TDbStoreIndexStats::Dec()
1.115 + {
1.116 + --iCardinality;
1.117 + Touch();
1.118 + }
1.119 +
1.120 +// contents have changed radically. provoke an immediate refresh
1.121 +inline void TDbStoreIndexStats::Reset(TInt aCardinality)
1.122 + {
1.123 + iCardinality=aCardinality;
1.124 + iRefresh=ERefresh;
1.125 + }
1.126 +
1.127 +// stats have been refreshed. set for next update
1.128 +inline void TDbStoreIndexStats::Refresh(TDbStoreIndexStats::TType aType)
1.129 + {
1.130 + iFlags=(iFlags&~EFlgDiscrete)|aType;
1.131 + iRefresh=(iCardinality>>ERefreshFactor)+1;
1.132 + }
1.133 +
1.134 +//
1.135 +// Internalize the index statistics
1.136 +// This must handle a stream externalized by builds before 052
1.137 +//
1.138 +void TDbStoreIndexStats::InternalizeL(RReadStream& aStream)
1.139 + {
1.140 + TCardinality c;
1.141 + aStream>>c;
1.142 + iCardinality=c;
1.143 + TUint refresh=aStream.ReadUint32L();
1.144 + iFlags=refresh&EFlagsMask;
1.145 + iRefresh=TInt(refresh>>ERefreshShift)+EInvalid;
1.146 +//
1.147 +// pre-build-052 data would run out here
1.148 +// if there is no more data, mark the (non-cardinality) stats as invalid
1.149 +//
1.150 + TRAPD(r,aStream>>iLower.iValue>>iUpper.iValue;)
1.151 + if (r==KErrEof)
1.152 + iRefresh=EInvalid; // mark as invalid data
1.153 + else
1.154 + __LEAVE_IF_ERROR(r); // just an "ordinary" error
1.155 + }
1.156 +
1.157 +//
1.158 +// Notes: iCardinality cannot exceed 2^29 (due to storage mechanism)
1.159 +// thus iRefresh cannot exceed 2^(29-ERefreshFactor)+1
1.160 +// this leaves the 5 m.s.b. clear in iRefresh-EInvalid
1.161 +// the flags bits are stored there
1.162 +//
1.163 +void TDbStoreIndexStats::ExternalizeL(RWriteStream& aStream) const
1.164 + {
1.165 + __ASSERT((iFlags&~EFlagsMask)==0);
1.166 + aStream<<TCardinality(iCardinality);
1.167 + aStream<<TUint32((TUint(iRefresh-EInvalid)<<ERefreshShift)|iFlags);
1.168 + aStream<<iLower.iValue<<iUpper.iValue;
1.169 + }
1.170 +
1.171 +//
1.172 +// Reverse the span and bounds
1.173 +//
1.174 +TInt TDbStoreIndexStats::ReverseSpan(TUint aInclusion,const TDbLookupKey* aLower,const TDbLookupKey* aUpper,const TTextOps& aConv) const
1.175 + {
1.176 + __ASSERT(iLower.iValue>iUpper.iValue);
1.177 + TDbStoreIndexStats stats(*this);
1.178 + stats.iLower=iUpper;
1.179 + stats.iUpper=iLower;
1.180 + return stats.Span((aInclusion<<1)|(aInclusion>>1),aUpper,aLower,aConv);
1.181 + }
1.182 +
1.183 +//
1.184 +// Evaluate the probable proportion of the index set contained within the bounds
1.185 +//
1.186 +TInt TDbStoreIndexStats::Span(TUint aInclusion,const TDbLookupKey* aLower,const TDbLookupKey* aUpper,const TTextOps& aConv) const
1.187 + {
1.188 + if (!IsValid())
1.189 + return CDbTable::EUnavailableSpan; // No valid index data
1.190 + if (iCardinality==0)
1.191 + return 0; // no rows at all
1.192 +//
1.193 + if (iLower.iValue>iUpper.iValue)
1.194 + return ReverseSpan(aInclusion,aLower,aUpper,aConv); // descending index
1.195 +//
1.196 + aInclusion&=CDbRecordIndex::EIncludeBoth;
1.197 + TBound l(iLower);
1.198 + if (aLower)
1.199 + {
1.200 + TBound bound;
1.201 + bound.Set(*aLower->First(),aConv);
1.202 + if (bound.iValue>=l.iValue)
1.203 + l=bound;
1.204 + else
1.205 + aInclusion|=CDbRecordIndex::EIncludeLower;
1.206 + }
1.207 + else
1.208 + aInclusion|=CDbRecordIndex::EIncludeLower;
1.209 +//
1.210 + TBound h(iUpper);
1.211 + if (aUpper)
1.212 + {
1.213 + TBound bound;
1.214 + bound.Set(*aUpper->First(),aConv);
1.215 + if (bound.iValue<=h.iValue)
1.216 + h=bound;
1.217 + else
1.218 + aInclusion|=CDbRecordIndex::EIncludeUpper;
1.219 + }
1.220 + else
1.221 + aInclusion|=CDbRecordIndex::EIncludeUpper;
1.222 +//
1.223 + TRealX restrict(h.iValue);
1.224 + restrict.SubEq(l.iValue); // extended precision--no errors
1.225 + TRealX span(iUpper.iValue);
1.226 + span.SubEq(iLower.iValue);
1.227 + if (iFlags&EFlgDiscrete)
1.228 + {
1.229 + if (aInclusion==0)
1.230 + --restrict;
1.231 + else if (aInclusion==CDbRecordIndex::EIncludeBoth)
1.232 + ++restrict;
1.233 + ++span;
1.234 + }
1.235 + else if (restrict.IsZero()) // single value continuous range
1.236 + {
1.237 + return (span.IsZero() && aInclusion==CDbRecordIndex::EIncludeBoth)
1.238 + ? CDbTable::EFullIndexSpan : 0;
1.239 + }
1.240 + if (restrict<=TRealX(0))
1.241 + return 0; // no overlap
1.242 + restrict.DivEq(span);
1.243 + restrict.MultEq(TInt(CDbTable::EFullIndexSpan));
1.244 + return TInt(restrict);
1.245 + }
1.246 +
1.247 +
1.248 +// Class CDbStoreIndex
1.249 +
1.250 +inline CDbStoreIndex::HKey& CDbStoreIndex::Key() const
1.251 + {
1.252 + return *iKey;
1.253 + }
1.254 +
1.255 +inline const TBtree& CDbStoreIndex::Tree() const
1.256 + {
1.257 + return iTree;
1.258 + }
1.259 +
1.260 +inline TInt CDbStoreIndex::Count() const
1.261 + {
1.262 + return iStats.Cardinality();
1.263 + }
1.264 +
1.265 +
1.266 +// Class CDbStoreIndex::HKey
1.267 +
1.268 +NONSHARABLE_CLASS(CDbStoreIndex::HKey) : public MBtreeKey
1.269 + {
1.270 +public:
1.271 + static HKey* NewL(const CDbKey& aKey,const HDbColumnSet& aColSet);
1.272 +//
1.273 + inline TInt EntrySize() const;
1.274 + virtual TInt KeySize() const;
1.275 + virtual TBool IncompleteKey() const;
1.276 +//
1.277 + TInt EntryL(TAny* aPtr,const RDbTableRow& aRow,TDbRecordId aRecord);
1.278 + TInt EntryL(TAny* aPtr,const TDbLookupKey& aKey);
1.279 + inline const TAny* Restriction() const;
1.280 + inline void Restrict(const TAny* aRestriction);
1.281 +//
1.282 + void Bound(TDbStoreIndexStats::TBound& aBound,const TAny* aEntry);
1.283 + TDbStoreIndexStats::TType KeyType() const;
1.284 +// from MBtreeKey
1.285 + const TAny* Key(const TAny* aRecord) const;
1.286 + TInt Compare(const TAny* aLeft,const TAny* aRight) const;
1.287 +protected:
1.288 + HKey() {}
1.289 + inline TBool FullComparison() const;
1.290 +// from MBtreeKey
1.291 + void Between(const TAny* aLeft,const TAny* aRight,TBtreePivot& aPivot) const;
1.292 +private:
1.293 + struct SKeyCol
1.294 + {
1.295 + TDbColNo iOrdinal;
1.296 + TInt iSize;
1.297 + TUint8 iType;
1.298 + TUint8 iOrder;
1.299 + };
1.300 + const TTextOps* iTextOps;
1.301 + TInt iSize;
1.302 + const SKeyCol* iEndOfKeys;
1.303 + const SKeyCol* iRestrictedEndOfKeys;
1.304 + SKeyCol iKeys[1]; // one or more keys
1.305 + };
1.306 +
1.307 +NONSHARABLE_CLASS(CDbStoreIndex::HDupKey) : public CDbStoreIndex::HKey
1.308 + {
1.309 + friend class CDbStoreIndex::HKey;
1.310 +private:
1.311 + HDupKey() {}
1.312 + TInt KeySize() const;
1.313 + const TAny* Key(const TAny* aRecord) const;
1.314 + TInt Compare(const TAny* aLeft,const TAny* aRight) const;
1.315 + TBool IncompleteKey() const;
1.316 + };
1.317 +
1.318 +inline TInt CDbStoreIndex::HKey::EntrySize() const
1.319 + {
1.320 + return iSize;
1.321 + }
1.322 +
1.323 +inline const TAny* CDbStoreIndex::HKey::Restriction() const
1.324 + {
1.325 + return iRestrictedEndOfKeys;
1.326 + }
1.327 +
1.328 +inline void CDbStoreIndex::HKey::Restrict(const TAny* aRestriction)
1.329 + {
1.330 + __ASSERT(aRestriction==0||(aRestriction>=iKeys&&aRestriction<=iEndOfKeys));
1.331 + iRestrictedEndOfKeys=(const SKeyCol*)aRestriction;
1.332 + }
1.333 +
1.334 +inline TBool CDbStoreIndex::HKey::FullComparison() const
1.335 + {
1.336 + return iRestrictedEndOfKeys==NULL;
1.337 + }
1.338 +
1.339 +//
1.340 +// Construct the key based on the key definition (must be valid for the table)
1.341 +// and the column set provided
1.342 +//
1.343 +CDbStoreIndex::HKey* CDbStoreIndex::HKey::NewL(const CDbKey& aKey,const HDbColumnSet& aColumns)
1.344 + {
1.345 + TInt count=aKey.Count();
1.346 + HKey* self=(HKey*)User::AllocLC(_FOFF(HKey,iKeys[count]));
1.347 + if (aKey.IsUnique())
1.348 + new(self) HKey;
1.349 + else
1.350 + new(self) HDupKey;
1.351 + self->iTextOps=&TTextOps::Ops(aKey.Comparison());
1.352 + self->iEndOfKeys=&self->iKeys[count];
1.353 + self->iRestrictedEndOfKeys=NULL;
1.354 + TInt len=sizeof(TDbRecordId);
1.355 + SKeyCol* pKey=&self->iKeys[0];
1.356 + for (TInt ii=0;ii<count;++pKey,++ii)
1.357 + {
1.358 + const TDbKeyCol& key=aKey[ii];
1.359 + pKey->iOrder=TUint8(key.iOrder);
1.360 + pKey->iOrdinal=aColumns.ColNoL(key.iName);
1.361 + if (pKey->iOrdinal==KDbNullColNo)
1.362 + __LEAVE(KErrCorrupt);
1.363 + const TDbColumnDef& col=aColumns[pKey->iOrdinal];
1.364 + pKey->iType=col.iType;
1.365 + pKey->iSize=CDbStoreIndexDef::KeySize(key,col);
1.366 + len+=Align4(pKey->iSize);
1.367 + }
1.368 + self->iSize=len;
1.369 + if (self->KeySize()>KMaxIndexKeySize)
1.370 + __LEAVE(KErrCorrupt);
1.371 + CleanupStack::Pop();
1.372 + return self;
1.373 + }
1.374 +
1.375 +//
1.376 +// Construct an entry at aPtr from the record given
1.377 +//
1.378 +TInt CDbStoreIndex::HKey::EntryL(TAny* aPtr,const RDbTableRow& aRow,TDbRecordId aRecord)
1.379 + {
1.380 + TUint8* ptr=(TUint8*)aPtr;
1.381 + Mem::FillZ(ptr,iSize);
1.382 + *REINTERPRET_CAST(TDbRecordId*,ptr)=aRecord;
1.383 + ptr+=sizeof(TDbRecordId);
1.384 + const SKeyCol* const end=iEndOfKeys;
1.385 + for (const SKeyCol* key=&iKeys[0];key<end;++key)
1.386 + {
1.387 + const TDbCell* cell=aRow.ColCell(key->iOrdinal);
1.388 + TInt size=key->iSize;
1.389 + if (cell->Length()!=0)
1.390 + {
1.391 +#ifdef __DOUBLE_WORDS_SWAPPED__
1.392 + if (key->iType==EDbColReal64)
1.393 + {
1.394 + const TUint32* data=(TUint32*)cell->Data();
1.395 + ((TUint32*)ptr)[0]=data[1];
1.396 + ((TUint32*)ptr)[1]=data[0];
1.397 + }
1.398 + else
1.399 +#endif
1.400 + if (TDbCol::IsLong(TDbColType(key->iType)))
1.401 + {
1.402 + const TDbBlob& blob=*(const TDbBlob*)cell->Data();
1.403 + if (blob.IsInline())
1.404 + Mem::Copy(ptr,blob.Data(),Min(size,blob.Size()));
1.405 + else
1.406 + {
1.407 + aRow.Table().BlobsL()->ReadLC(blob.Id(),TDbColType(key->iType))->ReadL(ptr,size);
1.408 + CleanupStack::PopAndDestroy(); // stream buffer
1.409 + }
1.410 + }
1.411 + else
1.412 + Mem::Copy(ptr,cell->Data(),Min(size,cell->Length()));
1.413 + }
1.414 + ptr+=Align4(size);
1.415 + }
1.416 + iRestrictedEndOfKeys=NULL; // use the full key for comparison
1.417 + return EntrySize();
1.418 + }
1.419 +
1.420 +//
1.421 +// Construct an entry from a lookup key
1.422 +//
1.423 +TInt CDbStoreIndex::HKey::EntryL(TAny* aPtr,const TDbLookupKey& aKey)
1.424 + {
1.425 + TUint8* ptr=(TUint8*)aPtr;
1.426 + Mem::FillZ(ptr,iSize);
1.427 + ptr+=sizeof(TDbRecordId);
1.428 + const TDbLookupKey::SColumn* lkey=aKey.First();
1.429 + const TDbLookupKey::SColumn* const lend=lkey+aKey.Count();
1.430 + __ASSERT(lkey<lend);
1.431 + const SKeyCol* const end=iEndOfKeys;
1.432 + const SKeyCol* key=&iKeys[0];
1.433 + for (;;)
1.434 + {
1.435 + TDbColType ltype=lkey->iType;
1.436 + TInt size=key->iSize;
1.437 + switch (key->iType)
1.438 + {
1.439 + default:
1.440 + __ASSERT(0);
1.441 + case EDbColBit:
1.442 + case EDbColUint8:
1.443 + case EDbColUint16:
1.444 + case EDbColUint32:
1.445 + if (ltype==EDbColUint32)
1.446 + {
1.447 + *(TUint32*)ptr=lkey->iUint32;
1.448 + break;
1.449 + }
1.450 + else if (ltype==EDbColInt32)
1.451 + {
1.452 + if (lkey->iInt32>=0) // domain check, unsigned value
1.453 + {
1.454 + *(TUint32*)ptr=lkey->iInt32;
1.455 + break;
1.456 + }
1.457 + }
1.458 + else if (ltype==EDbColInt64)
1.459 + {
1.460 + const TInt64& v=lkey->iInt64;
1.461 + if (I64HIGH(v)==0) // domain check, in unsigned 32-bit range
1.462 + {
1.463 + *(TUint32*)ptr=I64LOW(v);
1.464 + break;
1.465 + }
1.466 + }
1.467 + Panic(EDbWrongType);
1.468 + break;
1.469 + case EDbColInt8:
1.470 + case EDbColInt16:
1.471 + case EDbColInt32:
1.472 + if (ltype==EDbColInt32)
1.473 + {
1.474 + *(TInt32*)ptr=lkey->iInt32;
1.475 + break;
1.476 + }
1.477 + else if (ltype==EDbColUint32)
1.478 + {
1.479 + if (lkey->iUint32<=TUint(KMaxTInt)) // domain check, in signed range
1.480 + {
1.481 + *(TInt32*)ptr=lkey->iUint32;
1.482 + break;
1.483 + }
1.484 + }
1.485 + else if (ltype==EDbColInt64)
1.486 + {
1.487 + const TInt64& v=lkey->iInt64;
1.488 + TInt32 l=I64LOW(v);
1.489 + TInt32 h=I64HIGH(v);
1.490 + if (h==(l>>31)) // domain check, in signed 32-bit range
1.491 + {
1.492 + *(TInt32*)ptr=l;
1.493 + break;
1.494 + }
1.495 + }
1.496 + Panic(EDbWrongType);
1.497 + break;
1.498 + case EDbColReal32:
1.499 + if (ltype==EDbColReal32)
1.500 + {
1.501 + *(TReal32*)ptr=lkey->iReal32;
1.502 + break;
1.503 + }
1.504 + else if (ltype==EDbColReal64)
1.505 + { // convert to TReal32, storing +-#inf if reqd.
1.506 + TRealX(lkey->iReal64).GetTReal(*(TReal32*)ptr);
1.507 + break;
1.508 + }
1.509 + Panic(EDbWrongType);
1.510 + break;
1.511 + case EDbColReal64:
1.512 +#ifdef __DOUBLE_WORDS_SWAPPED__
1.513 + if (ltype==EDbColReal64)
1.514 + {
1.515 + const TUint32* data=(TUint32*)&lkey->iReal64;
1.516 + ((TUint32*)ptr)[0]=data[1];
1.517 + ((TUint32*)ptr)[1]=data[0];
1.518 + break;
1.519 + }
1.520 + // drop through
1.521 +#endif
1.522 + case EDbColInt64:
1.523 + case EDbColDateTime:
1.524 + if (ltype==key->iType)
1.525 + Mem::Copy(ptr,&lkey->iInt64,size); // all at same address
1.526 + else
1.527 + Panic(EDbWrongType);
1.528 + break;
1.529 + case EDbColText8:
1.530 + case EDbColLongText8:
1.531 + if (ltype==EDbColText8)
1.532 + Mem::Copy(ptr,lkey->iDes8.iPtr,Min(size,lkey->iDes8.iLength));
1.533 + else
1.534 + Panic(EDbWrongType);
1.535 + break;
1.536 + case EDbColText16:
1.537 + case EDbColLongText16:
1.538 + if (ltype==EDbColText16)
1.539 + Mem::Copy(ptr,lkey->iDes16.iPtr,Min(size,lkey->iDes16.iLength<<1));
1.540 + else
1.541 + Panic(EDbWrongType);
1.542 + break;
1.543 + }
1.544 + ++key;
1.545 + if (++lkey==lend)
1.546 + break; // end of lookup key
1.547 + if (key==end)
1.548 + __LEAVE(KErrArgument); // too many keys
1.549 + ptr+=Align4(size);
1.550 + }
1.551 + iRestrictedEndOfKeys=key; // use only the keys in the lookup for comparison
1.552 + return EntrySize();
1.553 + }
1.554 +
1.555 +void CDbStoreIndex::HKey::Bound(TDbStoreIndexStats::TBound& aBound,const TAny* aEntry)
1.556 + {
1.557 + aEntry=PtrAdd(aEntry,sizeof(TDbRecordId)); // get to real key data
1.558 + switch (iKeys[0].iType)
1.559 + {
1.560 + default:
1.561 + __ASSERT(0);
1.562 + case EDbColBit:
1.563 + case EDbColUint8:
1.564 + case EDbColUint16:
1.565 + case EDbColUint32:
1.566 + aBound.Set(TInt64(TUint(*STATIC_CAST(const TUint32*,aEntry))));
1.567 + break;
1.568 + case EDbColInt8:
1.569 + case EDbColInt16:
1.570 + case EDbColInt32:
1.571 + aBound.Set(TInt64(TInt(*STATIC_CAST(const TInt32*,aEntry))));
1.572 + break;
1.573 + case EDbColInt64:
1.574 + aBound.Set(*STATIC_CAST(const TInt64*,aEntry));
1.575 + break;
1.576 + case EDbColDateTime:
1.577 + aBound.Set(STATIC_CAST(const TTime*,aEntry)->Int64());
1.578 + break;
1.579 + case EDbColReal32:
1.580 + aBound.Set(TReal64(*STATIC_CAST(const TReal32*,aEntry)));
1.581 + break;
1.582 + case EDbColReal64:
1.583 +#if !defined(__DOUBLE_WORDS_SWAPPED__)
1.584 + aBound.Set(*STATIC_CAST(const TReal64*,aEntry));
1.585 +#else
1.586 + {
1.587 + TReal64 xKey;
1.588 + ((TUint32*)&xKey)[0]=STATIC_CAST(const TUint32*,aEntry)[1];
1.589 + ((TUint32*)&xKey)[1]=STATIC_CAST(const TUint32*,aEntry)[0];
1.590 + aBound.Set(xKey);
1.591 + }
1.592 +#endif
1.593 + break;
1.594 + case EDbColText8:
1.595 + case EDbColLongText8:
1.596 + aBound.Set(STATIC_CAST(const TUint8*,aEntry),iKeys[0].iSize,*iTextOps);
1.597 + break;
1.598 + case EDbColText16:
1.599 + case EDbColLongText16:
1.600 + aBound.Set(STATIC_CAST(const TUint16*,aEntry),iKeys[0].iSize>>1,*iTextOps);
1.601 + break;
1.602 + }
1.603 + }
1.604 +
1.605 +// Is the index key discrete or continous?
1.606 +inline TDbStoreIndexStats::TType CDbStoreIndex::HKey::KeyType() const
1.607 + {
1.608 + return iKeys[0].iType==EDbColReal32 || iKeys[0].iType==EDbColReal64
1.609 + ? TDbStoreIndexStats::EContinuous : TDbStoreIndexStats::EDiscrete;
1.610 + }
1.611 +
1.612 +TInt CDbStoreIndex::HKey::KeySize() const
1.613 + {
1.614 + return EntrySize()-sizeof(TDbRecordId);
1.615 + }
1.616 +
1.617 +//
1.618 +// Report 'true' if the lookup key is not the entire B+tree key
1.619 +// For a unique index this is if there is a restriction to less than the full key
1.620 +//
1.621 +TBool CDbStoreIndex::HKey::IncompleteKey() const
1.622 + {
1.623 + return iRestrictedEndOfKeys!=0 && iRestrictedEndOfKeys!=iEndOfKeys;
1.624 + }
1.625 +
1.626 +//
1.627 +// For unique keys, key is after record id
1.628 +//
1.629 +const TAny* CDbStoreIndex::HKey::Key(const TAny* aRecord) const
1.630 + {
1.631 + return PtrAdd(aRecord,sizeof(TDbRecordId));
1.632 + }
1.633 +
1.634 +//
1.635 +// compare the key part of the entry
1.636 +//
1.637 +TInt CDbStoreIndex::HKey::Compare(const TAny* aLeft,const TAny* aRight) const
1.638 + {
1.639 + const SKeyCol* end=iRestrictedEndOfKeys;
1.640 + if (end==NULL)
1.641 + end=iEndOfKeys;
1.642 + const SKeyCol* key=&iKeys[0];
1.643 + for (;;)
1.644 + {
1.645 + TInt size=key->iSize;
1.646 + TInt rr;
1.647 + switch (key->iType)
1.648 + {
1.649 + default:
1.650 + __ASSERT(0);
1.651 + case EDbColBit:
1.652 + case EDbColUint8:
1.653 + case EDbColUint16:
1.654 + case EDbColUint32:
1.655 + rr=Comp::Compare(*STATIC_CAST(const TUint32*,aLeft),*STATIC_CAST(const TUint32*,aRight));
1.656 + break;
1.657 + case EDbColInt8:
1.658 + case EDbColInt16:
1.659 + case EDbColInt32:
1.660 + rr=Comp::Compare(*STATIC_CAST(const TInt32*,aLeft),*STATIC_CAST(const TInt32*,aRight));
1.661 + break;
1.662 + case EDbColInt64:
1.663 + rr=Comp::Compare(*STATIC_CAST(const TInt64*,aLeft),*STATIC_CAST(const TInt64*,aRight));
1.664 + break;
1.665 + case EDbColDateTime:
1.666 + rr=Comp::Compare(*STATIC_CAST(const TTime*,aLeft),*STATIC_CAST(const TTime*,aRight));
1.667 + break;
1.668 + case EDbColReal32:
1.669 + rr=Comp::Compare(*STATIC_CAST(const TReal32*,aLeft),*STATIC_CAST(const TReal32*,aRight));
1.670 + break;
1.671 + case EDbColReal64:
1.672 +#if !defined(__DOUBLE_WORDS_SWAPPED__)
1.673 + rr=Comp::Compare(*STATIC_CAST(const TReal64*,aLeft),*STATIC_CAST(const TReal64*,aRight));
1.674 +#else
1.675 + TReal64 xLeft;
1.676 + ((TUint32*)&xLeft)[0]=STATIC_CAST(const TUint32*,aLeft)[1];
1.677 + ((TUint32*)&xLeft)[1]=STATIC_CAST(const TUint32*,aLeft)[0];
1.678 + TReal64 xRight;
1.679 + ((TUint32*)&xRight)[0]=STATIC_CAST(const TUint32*,aRight)[1];
1.680 + ((TUint32*)&xRight)[1]=STATIC_CAST(const TUint32*,aRight)[0];
1.681 + rr=Comp::Compare(xLeft,xRight);
1.682 +#endif
1.683 + break;
1.684 + case EDbColText8:
1.685 + case EDbColLongText8:
1.686 + rr=iTextOps->Compare(STATIC_CAST(const TUint8*,aLeft),size,STATIC_CAST(const TUint8*,aRight),size);
1.687 + break;
1.688 + case EDbColText16:
1.689 + case EDbColLongText16:
1.690 + rr=iTextOps->Order(STATIC_CAST(const TUint16*,aLeft),size>>1,STATIC_CAST(const TUint16*,aRight),size>>1);
1.691 + break;
1.692 + }
1.693 + if (rr!=0)
1.694 + return key->iOrder==TDbKeyCol::EAsc ? rr : -rr;
1.695 + if (++key==end)
1.696 + return rr;
1.697 + size=Align4(size);
1.698 + aLeft=PtrAdd(aLeft,size);
1.699 + aRight=PtrAdd(aRight,size);
1.700 + }
1.701 + }
1.702 +
1.703 +//
1.704 +// No clever stuff yet
1.705 +//
1.706 +void CDbStoreIndex::HKey::Between(const TAny* aLeft,const TAny* /*aRight*/,TBtreePivot& aPivot) const
1.707 + {
1.708 + aPivot.Copy((const TUint8*)aLeft,KeySize());
1.709 + }
1.710 +
1.711 +// Class CDbStoreIndex::HDupKey
1.712 +
1.713 +TInt CDbStoreIndex::HDupKey::KeySize() const
1.714 + {
1.715 + return EntrySize();
1.716 + }
1.717 +
1.718 +//
1.719 +// Report 'true' if the lookup key is not the entire B+tree key
1.720 +// For a duplicates index this is if there is a restriction (as record id is ingored)
1.721 +//
1.722 +TBool CDbStoreIndex::HDupKey::IncompleteKey() const
1.723 + {
1.724 + return Restriction()!=0;
1.725 + }
1.726 +
1.727 +//
1.728 +// The key includes the record id
1.729 +//
1.730 +const TAny* CDbStoreIndex::HDupKey::Key(const TAny* aRecord) const
1.731 + {
1.732 + return aRecord;
1.733 + }
1.734 +
1.735 +TInt CDbStoreIndex::HDupKey::Compare(const TAny* aLeft,const TAny* aRight) const
1.736 + {
1.737 + const TDbRecordId* const left=(const TDbRecordId*)aLeft;
1.738 + const TDbRecordId* const right=(const TDbRecordId*)aRight;
1.739 + TInt rr=HKey::Compare(left+1,right+1);
1.740 + if (rr==0 && FullComparison())
1.741 + return Comp::Compare(left->Value(),right->Value());
1.742 + return rr;
1.743 + }
1.744 +
1.745 +// Class CDbStoreIndex::CIter
1.746 +
1.747 +NONSHARABLE_CLASS(CDbStoreIndex::CIter) : public CDbRecordIter
1.748 + {
1.749 +public:
1.750 + static CIter* NewL(CDbStoreIndex& aIndex,TUint aInclusion,const TDbLookupKey* aLowerBound,const TDbLookupKey* aUpperBound);
1.751 +private:
1.752 + inline CIter(CDbStoreIndex& aIndex);
1.753 + ~CIter();
1.754 + void ConstructL(TUint aInclusion,const TDbLookupKey* aLowerBound,const TDbLookupKey* aUpperBound);
1.755 + TAny* BoundL(const TDbLookupKey& aBound,const TAny*& aRestriction);
1.756 +//
1.757 + inline const CDbStoreIndex& Index() const;
1.758 + TBool FindL(TDbRecordId aRecordId,const RDbTableRow& aRow,TBtree::TFind aFind);
1.759 + TInt CompareL(const TAny* aBound,const TAny* aRestriction);
1.760 + TBool _GotoL(TDbPosition aPosition);
1.761 +//
1.762 + TInt Count() const;
1.763 + TDbRecordId CurrentL();
1.764 + TBool GotoL(TDbPosition aPosition);
1.765 + TBool GotoL(TDbRecordId aRecordId,RDbTableRow& aBuffer);
1.766 + TBool SeekL(const TDbLookupKey& aKey,RDbTable::TComparison aComparison);
1.767 + TDeleted DoDeletedL(TDbPosition aPosition,TDbRecordId aRecordId,const RDbTableRow* aRow);
1.768 +private:
1.769 + TBtreePos iPos;
1.770 + TUint8 iLowerSeek;
1.771 + TUint8 iLowerCheck;
1.772 + TUint8 iUpperSeek;
1.773 + TUint8 iUpperCheck;
1.774 + TAny* iLowerBound;
1.775 + const TAny* iLowerRestriction;
1.776 + TAny* iUpperBound;
1.777 + const TAny* iUpperRestriction;
1.778 + };
1.779 +
1.780 +inline CDbStoreIndex::CIter::CIter(CDbStoreIndex& aIndex) :
1.781 + CDbRecordIter(aIndex)
1.782 + {
1.783 + }
1.784 +
1.785 +inline const CDbStoreIndex& CDbStoreIndex::CIter::Index() const
1.786 + {
1.787 + return STATIC_CAST(CDbStoreIndex&,Host());
1.788 + }
1.789 +
1.790 +CDbStoreIndex::CIter* CDbStoreIndex::CIter::NewL(CDbStoreIndex& aIndex,TUint aInclusion,const TDbLookupKey* aLowerBound,const TDbLookupKey* aUpperBound)
1.791 + {
1.792 + CIter* self=new(ELeave) CIter(aIndex);
1.793 + CleanupStack::PushL(self);
1.794 + self->ConstructL(aInclusion,aLowerBound,aUpperBound);
1.795 + CleanupStack::Pop();
1.796 + return self;
1.797 + }
1.798 +
1.799 +CDbStoreIndex::CIter::~CIter()
1.800 + {
1.801 + User::Free(iLowerBound);
1.802 + User::Free(iUpperBound);
1.803 + }
1.804 +
1.805 +void CDbStoreIndex::CIter::ConstructL(TUint aInclusion,const TDbLookupKey* aLowerBound,const TDbLookupKey* aUpperBound)
1.806 + {
1.807 + if (aLowerBound)
1.808 + {
1.809 + TBtree::TFind seek=TBtree::EGreaterEqual;
1.810 + if ((aInclusion&CDbRecordIndex::EIncludeLower)==0)
1.811 + {
1.812 + seek=TBtree::EGreaterThan;
1.813 + iLowerCheck=1;
1.814 + }
1.815 + iLowerSeek=TUint8(seek);
1.816 + iLowerBound=BoundL(*aLowerBound,iLowerRestriction);
1.817 + }
1.818 + if (aUpperBound)
1.819 + {
1.820 + TBtree::TFind seek=TBtree::ELessThan;
1.821 + if (aInclusion&CDbRecordIndex::EIncludeUpper)
1.822 + {
1.823 + seek=TBtree::ELessEqual;
1.824 + iUpperCheck=1;
1.825 + }
1.826 + iUpperSeek=TUint8(seek);
1.827 + iUpperBound=BoundL(*aUpperBound,iUpperRestriction);
1.828 + }
1.829 + }
1.830 +
1.831 +//
1.832 +// Construct and allocate a key for the boundary value
1.833 +//
1.834 +TAny* CDbStoreIndex::CIter::BoundL(const TDbLookupKey& aBound,const TAny*& aRestriction)
1.835 + {
1.836 + TUint8 entry[KMaxBtreeKeyLength];
1.837 + HKey& key=Index().Key();
1.838 + TInt size=key.EntryL(entry,aBound);
1.839 + const TUint8* ekey=(const TUint8*)key.Key(entry);
1.840 + size-=ekey-entry;
1.841 + TAny* e=User::AllocL(size);
1.842 + Mem::Copy(e,ekey,size);
1.843 + aRestriction=key.Restriction();
1.844 + return e;
1.845 + }
1.846 +
1.847 +//
1.848 +// Extract the current key and compare it with a boundary key
1.849 +//
1.850 +TInt CDbStoreIndex::CIter::CompareL(const TAny* aBound,const TAny* aRestriction)
1.851 + {
1.852 + TUint8 entry[KMaxBtreeKeyLength];
1.853 + HKey& key=Index().Key();
1.854 + key.Restrict(aRestriction);
1.855 + Index().Tree().ExtractAtL(iPos,entry,key.EntrySize());
1.856 + return key.Compare(key.Key(entry),aBound);
1.857 + }
1.858 +
1.859 +//
1.860 +// return the cardinality of the index
1.861 +//
1.862 +TInt CDbStoreIndex::CIter::Count() const
1.863 + {
1.864 + if (iLowerBound)
1.865 + return KDbUndefinedCount;
1.866 + if (iUpperBound)
1.867 + return KDbUndefinedCount;
1.868 + return Index().Count();
1.869 + }
1.870 +
1.871 +//
1.872 +// return the current record id
1.873 +//
1.874 +TDbRecordId CDbStoreIndex::CIter::CurrentL()
1.875 + {
1.876 + TDbRecordId id;
1.877 + Index().Tree().ExtractAtL(iPos,&id,sizeof(id));
1.878 + return id;
1.879 + }
1.880 +
1.881 +//
1.882 +// iterate to the required position, does not test the boundary condition
1.883 +//
1.884 +TBool CDbStoreIndex::CIter::_GotoL(TDbPosition aPosition)
1.885 + {
1.886 + const TBtree& tree=Index().Tree();
1.887 + switch (aPosition)
1.888 + {
1.889 + default: // all control paths return a value
1.890 + __ASSERT(0);
1.891 + case EDbNext:
1.892 + return tree.NextL(iPos);
1.893 + case EDbPrevious:
1.894 + return tree.PreviousL(iPos);
1.895 + case EDbFirst:
1.896 + if (!iLowerBound)
1.897 + return tree.FirstL(iPos);
1.898 + Index().Key().Restrict(iLowerRestriction);
1.899 + return tree.FindL(iPos,iLowerBound,TBtree::TFind(iLowerSeek));
1.900 + case EDbLast:
1.901 + if (!iUpperBound)
1.902 + return tree.LastL(iPos);
1.903 + Index().Key().Restrict(iUpperRestriction);
1.904 + return tree.FindL(iPos,iUpperBound,TBtree::TFind(iUpperSeek));
1.905 + }
1.906 + }
1.907 +
1.908 +//
1.909 +// iterate to the required position and check that it is in bounds
1.910 +//
1.911 +TBool CDbStoreIndex::CIter::GotoL(TDbPosition aPosition)
1.912 + {
1.913 + TBool r=_GotoL(aPosition);
1.914 + if (r)
1.915 + {
1.916 + if (aPosition==EDbFirst || aPosition==EDbNext)
1.917 + {
1.918 + if (iUpperBound)
1.919 + return CompareL(iUpperBound,iUpperRestriction)-iUpperCheck<0;
1.920 + }
1.921 + else
1.922 + {
1.923 + if (iLowerBound)
1.924 + return CompareL(iLowerBound,iLowerRestriction)-iLowerCheck>=0;
1.925 + }
1.926 + }
1.927 + return r;
1.928 + }
1.929 +
1.930 +//
1.931 +// Construct the Btree key for the row and lookup
1.932 +//
1.933 +TBool CDbStoreIndex::CIter::FindL(TDbRecordId aRecordId,const RDbTableRow& aRow,TBtree::TFind aFind)
1.934 + {
1.935 + TUint8 entry[KMaxBtreeKeyLength];
1.936 + HKey& key=Index().Key();
1.937 + key.EntryL(entry,aRow,aRecordId);
1.938 + return Index().Tree().FindL(iPos,key.Key(entry),aFind);
1.939 + }
1.940 +
1.941 +//
1.942 +// Go directly to a row
1.943 +//
1.944 +TBool CDbStoreIndex::CIter::GotoL(TDbRecordId aRecordId,RDbTableRow& aRow)
1.945 + {
1.946 + aRow.ReadL(aRecordId);
1.947 + return FindL(aRecordId,aRow,TBtree::EEqualTo);
1.948 + }
1.949 +
1.950 +//
1.951 +// Do a keyed lookup in the index
1.952 +//
1.953 +TBool CDbStoreIndex::CIter::SeekL(const TDbLookupKey& aKey,RDbTable::TComparison aComparison)
1.954 + {
1.955 + TUint8 entry[KMaxBtreeKeyLength];
1.956 + HKey& key=Index().Key();
1.957 + key.EntryL(entry,aKey);
1.958 + const TAny* ekey=key.Key(entry);
1.959 + TBtree::TFind find;
1.960 + switch (aComparison)
1.961 + {
1.962 + default:
1.963 + __ASSERT(0);
1.964 + case RDbTable::ELessThan:
1.965 + find=TBtree::ELessThan;
1.966 + break;
1.967 + case RDbTable::ELessEqual:
1.968 + find=TBtree::ELessEqual;
1.969 + break;
1.970 + case RDbTable::EEqualTo:
1.971 + if (key.IncompleteKey())
1.972 + {
1.973 + // The B+tree search code cannot correctly do a == search when the
1.974 + // comparison key is not complete. Instead we do a >= search and then
1.975 + // check the returned entry does match
1.976 + //
1.977 + if (!Index().Tree().FindL(iPos,ekey,TBtree::EGreaterEqual))
1.978 + return EFalse; // off the end
1.979 + return CompareL(ekey,key.Restriction())==0;
1.980 + }
1.981 + find=TBtree::EEqualTo;
1.982 + break;
1.983 + case RDbTable::EGreaterEqual:
1.984 + find=TBtree::EGreaterEqual;
1.985 + break;
1.986 + case RDbTable::EGreaterThan:
1.987 + find=TBtree::EGreaterThan;
1.988 + break;
1.989 + }
1.990 + return Index().Tree().FindL(iPos,ekey,find);
1.991 + }
1.992 +
1.993 +//
1.994 +// Set the iterator following a record deletion
1.995 +//
1.996 +CDbStoreIndex::CIter::TDeleted CDbStoreIndex::CIter::DoDeletedL(TDbPosition aPosition,TDbRecordId aRecordId,const RDbTableRow* aRow)
1.997 + {
1.998 + if (aRow==0)
1.999 + return ENotSupported;
1.1000 + return FindL(aRecordId,*aRow,aPosition==EDbNext ? TBtree::EGreaterEqual : TBtree::ELessEqual) ? EAtRow : ENoRow;
1.1001 + }
1.1002 +
1.1003 +// Class CDbStoreIndex
1.1004 +
1.1005 +CDbStoreIndex::CDbStoreIndex(CDbStoreDatabase& aDatabase,const CDbStoreIndexDef& aDef) :
1.1006 + iDatabase(aDatabase),
1.1007 + iTree(EBtreeFast),
1.1008 + iStats(MUTABLE_CAST(TDbStoreIndexStats&,aDef.iStats))
1.1009 + {
1.1010 + }
1.1011 +
1.1012 +CDbStoreIndex::~CDbStoreIndex()
1.1013 + {
1.1014 + delete iKey;
1.1015 + }
1.1016 +
1.1017 +//
1.1018 +// Create the persistent representation of the index in the store
1.1019 +//
1.1020 +TStreamId CDbStoreIndex::CreateL(CDbStoreDatabase& aDatabase,const CDbStoreIndexDef& aDef)
1.1021 + {
1.1022 + MUTABLE_CAST(TDbStoreIndexStats&,aDef.iStats).Reset();
1.1023 + RStoreWriteStream strm;
1.1024 + TStreamId id=strm.CreateLC(aDatabase.Store());
1.1025 + strm<<KEmptyBtreeToken<<aDef.iStats;
1.1026 + strm.CommitL();
1.1027 + CleanupStack::PopAndDestroy();
1.1028 + return id;
1.1029 + }
1.1030 +
1.1031 +//
1.1032 +// Check the index for damage (without constructing the object)
1.1033 +//
1.1034 +TBool CDbStoreIndex::IsDamagedL(CDbStoreDatabase& aDatabase,const CDbStoreIndexDef& aDef)
1.1035 + {
1.1036 + RStoreReadStream strm;
1.1037 + strm.OpenLC(aDatabase.Store(),aDef.TokenId());
1.1038 + TBtreeToken token;
1.1039 + strm>>token;
1.1040 + CleanupStack::PopAndDestroy();
1.1041 + return token.IsBroken();
1.1042 + }
1.1043 +
1.1044 +//
1.1045 +// Create a StoreIndex object
1.1046 +//
1.1047 +CDbStoreIndex* CDbStoreIndex::NewL(CDbStoreDatabase& aDatabase,const CDbStoreIndexDef& aDef,const CDbTableDef& aTable)
1.1048 + {
1.1049 + CDbStoreIndex* self=new(ELeave) CDbStoreIndex(aDatabase,aDef);
1.1050 + CleanupStack::PushL(self);
1.1051 + self->iTokenId=aDef.TokenId();
1.1052 + HKey* key=self->iKey=HKey::NewL(aDef.Key(),aTable.Columns());
1.1053 + self->iLeafOrg.SetEntrySize(key->EntrySize());
1.1054 + self->iIndexOrg.SetEntrySize(key->KeySize());
1.1055 + self->iTree.Connect(&aDatabase.PagePoolL(),key,&self->iLeafOrg,&self->iIndexOrg);
1.1056 + CleanupStack::Pop();
1.1057 + return self;
1.1058 + }
1.1059 +
1.1060 +//
1.1061 +// restore from the Store
1.1062 +//
1.1063 +TBool CDbStoreIndex::RestoreL()
1.1064 + {
1.1065 + RStoreReadStream strm;
1.1066 + strm.OpenLC(iDatabase.Store(),iTokenId);
1.1067 + TBtreeToken token;
1.1068 + strm>>token>>iStats;
1.1069 + CleanupStack::PopAndDestroy();
1.1070 + iTree.Set(token,EBtreeFast);
1.1071 + return iTree.IsBroken();
1.1072 + }
1.1073 +
1.1074 +//
1.1075 +// Update the index statistics from the index
1.1076 +//
1.1077 +void CDbStoreIndex::RefreshStatsL()
1.1078 + {
1.1079 + HKey& key=Key();
1.1080 + TBtreePos pos;
1.1081 + if (iTree.FirstL(pos))
1.1082 + {
1.1083 + TUint8 entry[KMaxBtreeKeyLength];
1.1084 + Tree().ExtractAtL(pos,entry,key.EntrySize());
1.1085 + key.Bound(iStats.iLower,entry);
1.1086 + iTree.LastL(pos);
1.1087 + Tree().ExtractAtL(pos,entry,key.EntrySize());
1.1088 + key.Bound(iStats.iUpper,entry);
1.1089 + }
1.1090 + iStats.Refresh(key.KeyType());
1.1091 + }
1.1092 +
1.1093 +//
1.1094 +// Framework member: synchronise the persistent data
1.1095 +//
1.1096 +void CDbStoreIndex::SynchL()
1.1097 + {
1.1098 + if (iStats.NeedsRefresh())
1.1099 + RefreshStatsL();
1.1100 + RStoreWriteStream strm;
1.1101 + strm.ReplaceLC(iDatabase.Store(),iTokenId);
1.1102 + strm<<iTree.Token()<<iStats;
1.1103 + strm.CommitL();
1.1104 + CleanupStack::PopAndDestroy();
1.1105 + }
1.1106 +
1.1107 +//
1.1108 +// Framework member: mark the persistent token dirty
1.1109 +//
1.1110 +void CDbStoreIndex::AboutToModifyL()
1.1111 + {
1.1112 + iDatabase.MarkL();
1.1113 + if (!iTree.IsEmpty()) // empty btrees are unbreakable
1.1114 + {
1.1115 + TBtreeToken token=iTree.Token();
1.1116 + token.Touch(); // mark persistent data as broken
1.1117 + RStoreWriteStream strm;
1.1118 + strm.OpenLC(iDatabase.Store(),iTokenId);
1.1119 + strm<<token;
1.1120 + strm.CommitL();
1.1121 + CleanupStack::PopAndDestroy();
1.1122 + }
1.1123 + }
1.1124 +
1.1125 +//
1.1126 +// Try to find a record in the index
1.1127 +// return ENoMatch if no key match, EEntryMatch if entire entry is present
1.1128 +// EKeyMatch if only key matches (only for unique indexes)
1.1129 +//
1.1130 +CDbStoreIndex::TFind CDbStoreIndex::FindL(TDbRecordId aRecordId,const RDbTableRow& aRow)
1.1131 + {
1.1132 + __ASSERT((!iTree.IsEmpty())==(Count()!=0));
1.1133 + TUint8 entry[KMaxBtreeKeyLength];
1.1134 + iKey->EntryL(entry,aRow,aRecordId);
1.1135 + TBtreePos pos;
1.1136 + if (!iTree.FindL(pos,iKey->Key(entry)))
1.1137 + return ENoMatch;
1.1138 + TDbRecordId id;
1.1139 + iTree.ExtractAtL(pos,&id,sizeof(id));
1.1140 + return id==aRecordId ? EEntryMatch : EKeyMatch;
1.1141 + }
1.1142 +
1.1143 +//
1.1144 +// Add the row to the index
1.1145 +// return True if insertion was good, false if duplicate found
1.1146 +//
1.1147 +TBool CDbStoreIndex::DoInsertL(TDbRecordId aRecordId,const RDbTableRow& aRow)
1.1148 + {
1.1149 + __ASSERT((!iTree.IsEmpty())==(Count()!=0));
1.1150 + TUint8 entry[KMaxBtreeKeyLength];
1.1151 + TInt len=iKey->EntryL(entry,aRow,aRecordId);
1.1152 + TBtreePos pos;
1.1153 + TBool insert=iTree.InsertL(pos,entry,len);
1.1154 + if (insert)
1.1155 + iStats.Inc();
1.1156 + return insert;
1.1157 + }
1.1158 +
1.1159 +//
1.1160 +// Remove row from index
1.1161 +//
1.1162 +void CDbStoreIndex::DoDeleteL(TDbRecordId aRecordId,const RDbTableRow& aRow)
1.1163 + {
1.1164 + __ASSERT((!iTree.IsEmpty())==(Count()!=0));
1.1165 + TUint8 entry[KMaxBtreeKeyLength];
1.1166 + iKey->EntryL(entry,aRow,aRecordId);
1.1167 + __DEBUG(TInt dbgchk=) iTree.DeleteL(iKey->Key(entry));
1.1168 + __ASSERT(dbgchk);
1.1169 + iStats.Dec();
1.1170 + }
1.1171 +
1.1172 +//
1.1173 +// Provide an iterator for the index ordering
1.1174 +//
1.1175 +CDbRecordIter* CDbStoreIndex::IteratorL(TUint aInclusion,const TDbLookupKey* aLowerBound,const TDbLookupKey* aUpperBound)
1.1176 + {
1.1177 + return CIter::NewL(*this,aInclusion,aLowerBound,aUpperBound);
1.1178 + }
1.1179 +
1.1180 +//
1.1181 +// repair the tree from the sequence set after reclamation of the page pool
1.1182 +//
1.1183 +void CDbStoreIndex::RepairL()
1.1184 + {
1.1185 + if (!iTree.IsEmpty()) // empty trees are unbreakable
1.1186 + {
1.1187 + TouchL();
1.1188 + iTree.MarkBroken();
1.1189 + iStats.Reset(iTree.RepairL());
1.1190 + SynchL();
1.1191 + }
1.1192 + }
1.1193 +
1.1194 +//
1.1195 +// Throw away the index data, also used prior to a recovering rebuild
1.1196 +//
1.1197 +void CDbStoreIndex::DiscardL()
1.1198 + {
1.1199 + TouchL();
1.1200 + iTree.ClearL();
1.1201 + iStats.Reset();
1.1202 + MarkIntact();
1.1203 + }
1.1204 +
1.1205 +//
1.1206 +// Throw away the token
1.1207 +//
1.1208 +void CDbStoreIndex::DestroyL()
1.1209 + {
1.1210 + iDatabase.Store().DeleteL(iTokenId);
1.1211 + }
1.1212 +
1.1213 +// Class CDbStoreIndex::CDiscarder
1.1214 +
1.1215 +CDbStoreIndex::CDiscarder::CDiscarder()
1.1216 + {}
1.1217 +
1.1218 +CDbStoreIndex::CDiscarder::~CDiscarder()
1.1219 + {
1.1220 + delete iIndex;
1.1221 + }
1.1222 +
1.1223 +TInt CDbStoreIndex::CDiscarder::Open(CDbStoreIndex* anIndex)
1.1224 + {
1.1225 + __ASSERT(!iIndex);
1.1226 + iIndex=anIndex;
1.1227 + return 1;
1.1228 + }
1.1229 +
1.1230 +//
1.1231 +// Do the single step of index discard
1.1232 +//
1.1233 +TInt CDbStoreIndex::CDiscarder::StepL(TInt)
1.1234 + {
1.1235 + __ASSERT(iIndex);
1.1236 + CDbStoreIndex& index=*iIndex;
1.1237 + index.DiscardL();
1.1238 + index.DestroyL();
1.1239 + return 0;
1.1240 + }