1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/dbms/utable/UT_TABLE.CPP Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,672 @@
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 "UT_STD.H"
1.20 +
1.21 +#define UNUSED_VAR(a) a = a
1.22 +
1.23 +const TUint KTableExpiry=0x100000; // ~1.0s
1.24 +
1.25 +// Class Blob cleanup
1.26 +
1.27 +NONSHARABLE_CLASS(CDbBlobCleanup) : public CArrayFixFlat<TDbBlobId>
1.28 + {
1.29 +public:
1.30 + static CDbBlobCleanup* NewLC(CDbBlobSpace& aBlobSpace);
1.31 + ~CDbBlobCleanup();
1.32 +private:
1.33 + inline CDbBlobCleanup(CDbBlobSpace& aBlobSpace);
1.34 +private:
1.35 + CDbBlobSpace& iBlobSpace;
1.36 + };
1.37 +
1.38 +inline CDbBlobCleanup::CDbBlobCleanup(CDbBlobSpace& aBlobSpace)
1.39 + : CArrayFixFlat<TDbBlobId>(8),iBlobSpace(aBlobSpace)
1.40 + {}
1.41 +
1.42 +CDbBlobCleanup* CDbBlobCleanup::NewLC(CDbBlobSpace& aBlobSpace)
1.43 + {
1.44 + CDbBlobCleanup* self=new(ELeave) CDbBlobCleanup(aBlobSpace);
1.45 + CleanupStack::PushL(self);
1.46 + return self;
1.47 + }
1.48 +
1.49 +CDbBlobCleanup::~CDbBlobCleanup()
1.50 + {
1.51 + TInt count=Count();
1.52 + if (count)
1.53 + {
1.54 + const TDbBlobId* blob=&(*this)[0];
1.55 + const TDbBlobId* const end=blob+count;
1.56 + for (;blob<end;++blob)
1.57 + iBlobSpace.Delete(*blob);
1.58 + }
1.59 + }
1.60 +
1.61 +// Class CDbTable
1.62 +
1.63 +
1.64 +EXPORT_C CDbTable::CDbTable(CDbTableDatabase& aDatabase,const CDbTableDef& aDef)
1.65 + : iDatabase(&aDatabase),iDef(&aDef)
1.66 + {
1.67 + aDatabase.Open();
1.68 + aDatabase.AddTable(*this); // we reference database
1.69 + }
1.70 +
1.71 +EXPORT_C CDbTable::~CDbTable()
1.72 +//
1.73 +// Destroy components
1.74 +//
1.75 + {
1.76 + __ASSERT(!InUse()); // cannot be directly deleted
1.77 + if (IsActive())
1.78 + Disconnect();
1.79 + }
1.80 +
1.81 +void CDbTable::Disconnect()
1.82 +//
1.83 +// Disconnect the table from the database collection.
1.84 +//
1.85 + {
1.86 + __ASSERT(IsActive());
1.87 + Database().RemoveTable(*this);
1.88 + TRAPD(errCode, ApplyToComponentsL(CDbRecordBase::DoDelete));
1.89 + UNUSED_VAR(errCode);
1.90 + }
1.91 +
1.92 +void CDbTable::Open()
1.93 + {
1.94 + __ASSERT(IsActive());
1.95 + TInt r=++iRef;
1.96 + if (r<=0)
1.97 + { // were idle or cached
1.98 + if (r<0)
1.99 + {
1.100 + Cache().Release(*this); // was cached
1.101 + iRef=0;
1.102 + }
1.103 + Database().Open();
1.104 + }
1.105 + }
1.106 +
1.107 +void CDbTable::Close()
1.108 +//
1.109 +// We may destroy this object when the last reference goes away
1.110 +//
1.111 + {
1.112 + __ASSERT(InUse());
1.113 + if (--iRef<0)
1.114 + {
1.115 + if (!IsActive())
1.116 + delete this; // disconnected table
1.117 + else
1.118 + {
1.119 + CDbTableDatabase& db=Database();
1.120 + if (!db.Transaction().IsLocked())
1.121 + Idle(); // no transaction, idle now
1.122 + db.Close(); // this must be done last to avoid early self destruction
1.123 + }
1.124 + }
1.125 + }
1.126 +
1.127 +void CDbTable::Idle()
1.128 +//
1.129 +// Called when idle, change to cached state
1.130 +//
1.131 + {
1.132 + __ASSERT(IsIdle());
1.133 + __ASSERT(IsActive());
1.134 +//
1.135 + iRef=ECached;
1.136 + Cache().Hold(this,KTableExpiry); // may delete this
1.137 + }
1.138 +
1.139 +void CDbTable::FlushL()
1.140 +//
1.141 +// Ensure all records objects are flushed
1.142 +//
1.143 + {
1.144 + __ASSERT(IsActive());
1.145 + if (iRef!=ECached)
1.146 + ApplyToComponentsL(CDbRecordBase::DoFlushL);
1.147 + }
1.148 +
1.149 +void CDbTable::Abandon()
1.150 +//
1.151 +// Discard all components
1.152 +//
1.153 + {
1.154 + __ASSERT(IsActive());
1.155 + TRAPD(errCode, ApplyToComponentsL(CDbRecordBase::DoAbandon));
1.156 + UNUSED_VAR(errCode);
1.157 + iIndexesEnd=NULL; // flags indexes as abandoned
1.158 + ++iGeneration;
1.159 + }
1.160 +
1.161 +void CDbTable::Release()
1.162 +//
1.163 +// Release the table and all its cursors as DDL is about to begin
1.164 +//
1.165 + {
1.166 + __ASSERT(IsActive());
1.167 + switch (iRef)
1.168 + {
1.169 + case ECached:
1.170 + Cache().Release(*this);
1.171 + // fall throught to Idle
1.172 + case EIdle:
1.173 + delete this;
1.174 + break;
1.175 + default:
1.176 + __ASSERT(InUse());
1.177 + Database().Close();
1.178 + Disconnect();
1.179 + iDatabase=0; // this marks us as released
1.180 + iDef=0;
1.181 + break;
1.182 + }
1.183 + }
1.184 +
1.185 +void CDbTable::ApplyToBlobsL(RDbRow& aRow,TBlobFuncL aFuncL,CDbBlobCleanup* aCleanup)
1.186 + {
1.187 + __ASSERT(Def().Columns().HasLongColumns());
1.188 + CDbBlobSpace* blobs=BlobsL();
1.189 + __ASSERT(blobs);
1.190 + TDbColNo col=1;
1.191 + HDbColumnSet::TIteratorC iter=Def().Columns().Begin();
1.192 + const HDbColumnSet::TIteratorC end=Def().Columns().End();
1.193 + do
1.194 + {
1.195 + if (!TDbCol::IsLong(iter->Type()))
1.196 + continue;
1.197 + const TDbColumnC column(aRow,col);
1.198 + if (column.IsNull())
1.199 + continue;
1.200 + aFuncL(*blobs,CONST_CAST(TDbBlob&,column.Blob()),iter->Type(),aCleanup);
1.201 + } while (++col,++iter<end);
1.202 + }
1.203 +
1.204 +LOCAL_C void DuplicateBlobL(CDbBlobSpace& aBlobStore,TDbBlob& aBlob,TDbColType aType,CDbBlobCleanup* aCleanup)
1.205 + {
1.206 + __ASSERT(aCleanup);
1.207 + if (aBlob.IsInline())
1.208 + return;
1.209 +// need to duplicate blob
1.210 + RReadStream old(aBlobStore.ReadLC(aBlob.Id(),aType));
1.211 + TDbBlobId& newId=aCleanup->ExtendL();
1.212 + newId=KDbNullBlobId;
1.213 + RWriteStream dup(aBlobStore.CreateL(newId,aType));
1.214 + dup.PushL();
1.215 + dup.WriteL(old,aBlob.Size());
1.216 + dup.CommitL();
1.217 + CleanupStack::PopAndDestroy(2); // old and dup streams
1.218 + aBlob.SetId(newId); // row is writable
1.219 + }
1.220 +
1.221 +void CDbTable::DuplicateBlobsL(RDbRow& aRow)
1.222 +//
1.223 +// duplicate any blobs
1.224 +//
1.225 + {
1.226 + if (!Def().Columns().HasLongColumns())
1.227 + return;
1.228 +
1.229 + CDbBlobCleanup* cleaner=CDbBlobCleanup::NewLC(*BlobsL());
1.230 + ApplyToBlobsL(aRow,DuplicateBlobL,cleaner);
1.231 + cleaner->Reset();
1.232 + CleanupStack::PopAndDestroy();
1.233 + }
1.234 +
1.235 +TBool CDbTable::ExistsL(TDbRecordId aRecordId)
1.236 +//
1.237 +// Check that aRecordId is good for this table
1.238 +//
1.239 + {
1.240 + __ASSERT(IsActive() && InUse());
1.241 + return RecordsL().ExistsL(aRecordId);
1.242 + }
1.243 +
1.244 +void CDbTable::NewRowL(RDbRow& aRow)
1.245 +//
1.246 +// Initialise any auto-increment columns in the row
1.247 +//
1.248 + {
1.249 + const HDbColumnSet& columns=Def().Columns();
1.250 + if (!columns.HasAutoIncrement())
1.251 + return;
1.252 +
1.253 + TUint value=RecordsL().AutoIncrementL();
1.254 + TDbColNo col=1;
1.255 + HDbColumnSet::TIteratorC iter=columns.Begin();
1.256 + const HDbColumnSet::TIteratorC end=columns.End();
1.257 + do
1.258 + {
1.259 + if (iter->iAttributes&TDbCol::EAutoIncrement)
1.260 + {
1.261 + // auto-increment only for integral types <=32 bits wide
1.262 + __ASSERT(iter->iType<=EDbColUint32);
1.263 + TDbColumn column(aRow,col);
1.264 + column.SetL(TUint32(value));
1.265 + }
1.266 + } while (++col,++iter<end);
1.267 + }
1.268 +
1.269 +void CDbTable::ValidateL(const RDbRow& aRow)
1.270 +//
1.271 +// Ensure that the column data conforms to type size/flags etc
1.272 +//
1.273 + {
1.274 + HDbColumnSet::TIteratorC iter=Def().Columns().Begin();
1.275 + const HDbColumnSet::TIteratorC end=Def().Columns().End();
1.276 + const TDbCell* const last=aRow.Last();
1.277 + for (const TDbCell* column=aRow.First();column<last;++iter,column=column->Next())
1.278 + {
1.279 + TInt size=column->Length();
1.280 + if (size==0)
1.281 + { // check for Null
1.282 + if (iter->iAttributes&TDbCol::ENotNull)
1.283 + {
1.284 + __LEAVE(KErrNotFound);
1.285 + return;
1.286 + }
1.287 + continue;
1.288 + }
1.289 + const TUint32* data=(const TUint32*)column->Data();
1.290 + switch (iter->iType)
1.291 + {
1.292 + case EDbColBit:
1.293 + if (*data>1)
1.294 + __LEAVE(KErrOverflow);
1.295 + break;
1.296 + case EDbColInt8:
1.297 + {
1.298 + TInt val=*data;
1.299 + if (TInt8(val)!=val)
1.300 + __LEAVE(KErrOverflow);
1.301 + }
1.302 + break;
1.303 + case EDbColInt16:
1.304 + {
1.305 + TInt val=*data;
1.306 + if (TInt16(val)!=val)
1.307 + __LEAVE(KErrOverflow);
1.308 + }
1.309 + break;
1.310 + case EDbColUint8:
1.311 + {
1.312 + TUint val=*data;
1.313 + if (TUint8(val)!=val)
1.314 + __LEAVE(KErrOverflow);
1.315 + }
1.316 + break;
1.317 + case EDbColUint16:
1.318 + {
1.319 + TUint val=*data;
1.320 + if (TUint16(val)!=val)
1.321 + __LEAVE(KErrOverflow);
1.322 + }
1.323 + break;
1.324 + case EDbColText16:
1.325 + size>>=1;
1.326 + case EDbColBinary:
1.327 + case EDbColText8:
1.328 + if (iter->iMaxLength==KDbUndefinedLength)
1.329 + break;
1.330 + if (size>iter->iMaxLength)
1.331 + __LEAVE(KErrOverflow);
1.332 + break;
1.333 + case EDbColLongBinary:
1.334 + case EDbColLongText8:
1.335 + case EDbColLongText16:
1.336 + if (iter->iMaxLength==KDbUndefinedLength)
1.337 + break;
1.338 + size=((TDbBlob*)data)->Size();
1.339 + if (size==KDbUndefinedLength)
1.340 + break;
1.341 + if (iter->iType==EDbColText16)
1.342 + size>>=1;
1.343 + if (size>iter->iMaxLength)
1.344 + __LEAVE(KErrOverflow);
1.345 + break;
1.346 + default:
1.347 + break;
1.348 + }
1.349 + }
1.350 + for (;iter<end;++iter)
1.351 + { // check for Null
1.352 + if (iter->iAttributes&TDbCol::ENotNull)
1.353 + {
1.354 + __LEAVE(KErrNotFound);
1.355 + return;
1.356 + }
1.357 + }
1.358 + }
1.359 +
1.360 +void CDbTable::ReadRowL(RDbRow& aRow,TDbRecordId aRecordId)
1.361 +//
1.362 +// Read a record from the table
1.363 +//
1.364 + {
1.365 + CopyToRowL(aRow,RecordsL().ReadL(aRecordId));
1.366 + }
1.367 +
1.368 +void CDbTable::PrepareAppendL(const RDbTableRow& aRow)
1.369 +//
1.370 +// Validate a new record for appending
1.371 +//
1.372 + {
1.373 + EnsureIndexesL();
1.374 + ValidateL(aRow);
1.375 + CDbRecordIndex** end=iIndexesEnd;
1.376 + for (CDbRecordIndex** pix=iIndexes;pix<end;++pix)
1.377 + {
1.378 + CDbRecordIndex& ix=**pix;
1.379 + if (ix.IsBroken())
1.380 + continue;
1.381 + if (ix.FindL(KDbNullRecordId,aRow)==CDbRecordIndex::EKeyMatch)
1.382 + __LEAVE(KErrAlreadyExists); // duplicate found
1.383 + }
1.384 + }
1.385 +
1.386 +TDbRecordId CDbTable::AppendRowL(const RDbTableRow& aRow)
1.387 +//
1.388 +// Validate and add a new record to the table and any open indexes
1.389 +//
1.390 + {
1.391 + CDbRecordSpace& records=RecordsL();
1.392 + CopyFromRow(records.NewL(RecordLength(aRow)),aRow);
1.393 + TDbRecordId id=records.AppendL();
1.394 + CDbRecordIndex** end=iIndexesEnd;
1.395 + for (CDbRecordIndex** pix=iIndexes;pix<end;++pix)
1.396 + {
1.397 + CDbRecordIndex& ix=**pix;
1.398 + if (ix.IsBroken())
1.399 + continue;
1.400 + __DEBUG(TInt dbgchk=) ix.InsertL(id,aRow);
1.401 + __ASSERT(dbgchk);
1.402 + }
1.403 + ++iGeneration;
1.404 + return id;
1.405 + }
1.406 +
1.407 +void CDbTable::PrepareReplaceL(const RDbTableRow& aRow,TDbRecordId aRecordId)
1.408 +//
1.409 +// Validate a record for replacement
1.410 +//
1.411 + {
1.412 + EnsureIndexesL();
1.413 + ValidateL(aRow);
1.414 + TUint32 update=0;
1.415 + CDbRecordIndex** end=iIndexes;
1.416 + for (CDbRecordIndex** pix=iIndexesEnd;--pix>=end;)
1.417 + {
1.418 + update<<=1;
1.419 + CDbRecordIndex& ix=**pix;
1.420 + if (ix.IsBroken())
1.421 + continue;
1.422 + switch (ix.FindL(aRecordId,aRow))
1.423 + {
1.424 + case CDbRecordIndex::ENoMatch: // key has changed in index
1.425 + update|=1;
1.426 + break;
1.427 + case CDbRecordIndex::EKeyMatch: // duplicate found
1.428 + __LEAVE(KErrAlreadyExists);
1.429 + case CDbRecordIndex::EEntryMatch: // no change in index
1.430 + break;
1.431 + }
1.432 + }
1.433 + iUpdateMap=update;
1.434 + }
1.435 +
1.436 +void CDbTable::DoReplaceRowL(const RDbRow& aRow,TDbRecordId aRecordId)
1.437 + {
1.438 + CopyFromRow(RecordsL().ReplaceL(aRecordId,RecordLength(aRow)),aRow);
1.439 + ++iGeneration;
1.440 + }
1.441 +
1.442 +void CDbTable::ReplaceRowL(RDbTableRow& aRow,TDbRecordId aRecordId)
1.443 +//
1.444 +// Replace a record in the table
1.445 +//
1.446 + {
1.447 + if (Def().Columns().HasLongColumns())
1.448 + CheckInliningL(aRow);
1.449 + TUint32 update=iUpdateMap;
1.450 + if (update==0)
1.451 + {
1.452 + DoReplaceRowL(aRow,aRecordId);
1.453 + return;
1.454 + }
1.455 + RDbTableRow oldRow; // temporary row buffer for old row values
1.456 + oldRow.Open(this);
1.457 + oldRow.PushL(); // cleanup buffer if there is trouble
1.458 + ReadRowL(oldRow,aRecordId);
1.459 + DoReplaceRowL(aRow,aRecordId);
1.460 + for (CDbRecordIndex** pix=iIndexes;update;++pix,update>>=1)
1.461 + {
1.462 + if (update&1)
1.463 + {
1.464 + CDbRecordIndex& index=**pix;
1.465 + index.DeleteL(aRecordId,oldRow);
1.466 + __DEBUG(TInt dbgchk=) index.InsertL(aRecordId,aRow);
1.467 + __ASSERT(dbgchk);
1.468 + }
1.469 + }
1.470 + CleanupStack::PopAndDestroy(); // temp row buffer
1.471 + }
1.472 +
1.473 +LOCAL_C void CheckInlineL(CDbBlobSpace& aBlobStore,TDbBlob& aBlob,TDbColType aType,CDbBlobCleanup*)
1.474 + {
1.475 + if (!aBlob.IsInline())
1.476 + return;
1.477 + if (aBlob.Size()>aBlobStore.InlineLimit())
1.478 + aBlob.SetId(aBlobStore.CreateL(aType,aBlob.Data(),aBlob.Size()));
1.479 + }
1.480 +
1.481 +void CDbTable::CheckInliningL(RDbRow& aRow)
1.482 +//
1.483 +// Ensure that all Blobs are within the current inline limit
1.484 +//
1.485 + {
1.486 + ApplyToBlobsL(aRow,CheckInlineL);
1.487 + }
1.488 +
1.489 +LOCAL_C void DiscardBlobL(CDbBlobSpace& aBlobStore,TDbBlob& aBlob,TDbColType,CDbBlobCleanup*)
1.490 + {
1.491 + if (!aBlob.IsInline())
1.492 + aBlobStore.DeleteL(aBlob.Id());
1.493 + }
1.494 +
1.495 +EXPORT_C void CDbTable::DiscardBlobsL(RDbRow& aRow)
1.496 +//
1.497 +// Default implemtation xlates the record and then walks the row buffer
1.498 +//
1.499 + {
1.500 + ApplyToBlobsL(aRow,DiscardBlobL);
1.501 + }
1.502 +
1.503 +void CDbTable::DeleteRowL(RDbTableRow& aRow,TDbRecordId aRecordId)
1.504 +//
1.505 +// Delete the record from the file and unlock it.
1.506 +//
1.507 + {
1.508 + EnsureIndexesL();
1.509 +
1.510 + if (Def().Columns().HasLongColumns())
1.511 + {
1.512 + // Read data from the stream but do not delete the stream yet.
1.513 + aRow.ReadL(aRecordId);
1.514 + }
1.515 +
1.516 + CDbRecordIndex** end=iIndexes;
1.517 + CDbRecordIndex** pix=iIndexesEnd;
1.518 + if (pix!=end)
1.519 + aRow.ReadL(aRecordId);
1.520 + RecordsL().EraseL(aRecordId);
1.521 + while (--pix>=end)
1.522 + {
1.523 + CDbRecordIndex& ix=**pix;
1.524 + if (!ix.IsBroken())
1.525 + ix.DeleteL(aRecordId,aRow);
1.526 + }
1.527 +
1.528 + if (Def().Columns().HasLongColumns())
1.529 + {
1.530 + // Now delete the stream.
1.531 + DiscardBlobsL(aRow);
1.532 + }
1.533 +
1.534 + ++iGeneration;
1.535 + }
1.536 +
1.537 +EXPORT_C CDbRecordSpace& CDbTable::RecordsL()
1.538 + {
1.539 + __ASSERT(IsActive() && InUse());
1.540 + CDbRecordSpace* rec=iRecords;
1.541 + if (rec==NULL)
1.542 + iRecords=rec=RecordSpaceL();
1.543 + if (rec->OpenL())
1.544 + __LEAVE(KErrCorrupt);
1.545 + return *rec;
1.546 + }
1.547 +
1.548 +EXPORT_C CDbBlobSpace* CDbTable::BlobsL()
1.549 + {
1.550 + __ASSERT(IsActive() && InUse());
1.551 + CDbBlobSpace* blob=iBlobs;
1.552 + if (blob==NULL)
1.553 + iBlobs=blob=BlobSpaceL();
1.554 + if (blob->OpenL())
1.555 + __LEAVE(KErrCorrupt);
1.556 + return blob;
1.557 + }
1.558 +
1.559 +EXPORT_C CDbRecordIndex& CDbTable::IndexL(const CDbTableIndexDef& aIndex)
1.560 +//
1.561 +// Load the index associated with the index definition and ensure it is operational
1.562 +//
1.563 + {
1.564 + __ASSERT(IsActive() && InUse());
1.565 + // find the matching slot in the indexes array
1.566 + CDbRecordIndex** slot=&iIndexes[0];
1.567 + for (TSglQueIterC<CDbTableIndexDef> iter(Def().Indexes().AsQue());iter++!=&aIndex;)
1.568 + ++slot;
1.569 + __ASSERT(iIndexesEnd==NULL||(slot>=iIndexes&&slot<iIndexesEnd));
1.570 + // load (if required) and open the index
1.571 + CDbRecordIndex* index=*slot;
1.572 + if (index==0)
1.573 + *slot=index=RecordIndexL(aIndex);
1.574 + if (index->OpenL())
1.575 + __LEAVE(KErrCorrupt);
1.576 + return *index;
1.577 + }
1.578 +
1.579 +void CDbTable::EnsureIndexesL()
1.580 +//
1.581 +// Ensure that all indexes are open
1.582 +//
1.583 + {
1.584 + __ASSERT(IsActive() && InUse());
1.585 + if (iIndexesEnd==NULL)
1.586 + {
1.587 + CDbRecordIndex** pp=iIndexes;
1.588 + TSglQueIterC<CDbTableIndexDef> iter(Def().Indexes().AsQue());
1.589 + for (const CDbTableIndexDef* xDef;(xDef=iter++)!=NULL;++pp)
1.590 + {
1.591 + CDbRecordIndex* ix=*pp;
1.592 + if (ix==NULL)
1.593 + *pp=ix=RecordIndexL(*xDef);
1.594 + ix->OpenL(); // ignore broken-ness
1.595 + }
1.596 + iIndexesEnd=pp;
1.597 + }
1.598 + }
1.599 +
1.600 +CDbRecordIter* CDbTable::IteratorL()
1.601 + {
1.602 + return RecordsL().IteratorL();
1.603 + }
1.604 +
1.605 +CDbRecordIter* CDbTable::IteratorL(const CDbTableIndexDef& aIndex,TUint aInclusion,const TDbLookupKey* aLowerBound,const TDbLookupKey* aUpperBound)
1.606 +//
1.607 +// create an interator for the index parameter
1.608 +//
1.609 + {
1.610 + return IndexL(aIndex).IteratorL(aInclusion,aLowerBound,aUpperBound);
1.611 + }
1.612 +
1.613 +EXPORT_C TInt CDbTable::IndexSpanL(const CDbTableIndexDef&,TUint,const TDbLookupKey*,const TDbLookupKey*)
1.614 +//
1.615 +// Default implementation: no statistics are available
1.616 +//
1.617 + {
1.618 + return EUnavailableSpan;
1.619 + }
1.620 +
1.621 +CDbRecordIter* CDbTable::IteratorL(const TDesC& aIndex)
1.622 +//
1.623 +// create an interator for the index named
1.624 +//
1.625 + {
1.626 + return IteratorL(Def().Indexes().FindL(aIndex));
1.627 + }
1.628 +
1.629 +void CDbTable::ApplyToComponentsL(void (*anOperationL)(CDbRecordBase*))
1.630 +//
1.631 +// Invoke anOperation on all components of the table
1.632 +//
1.633 + {
1.634 + if (iRecords)
1.635 + anOperationL(iRecords);
1.636 + if (iBlobs)
1.637 + anOperationL(iBlobs);
1.638 + CDbRecordIndex** const ixs=iIndexes;
1.639 + CDbRecordIndex** pix=iIndexesEnd;
1.640 + if (pix==NULL)
1.641 + pix=&iIndexes[KDbTableMaxIndexes];
1.642 + while (--pix>=ixs)
1.643 + if (*pix)
1.644 + anOperationL(*pix);
1.645 + }
1.646 +
1.647 +// Class CDbtable::TValid
1.648 +
1.649 +// this class is used by the cursor to check that it is still operational
1.650 +
1.651 +CDbTable::TValid::TValid(CDbTable& aTable)
1.652 + :iTable(aTable)
1.653 + {
1.654 + __ASSERT(aTable.IsActive());
1.655 + iRollback.Construct(aTable.Database().Transaction().RollbackGeneration());
1.656 + }
1.657 +
1.658 +TBool CDbTable::TValid::Reset()
1.659 + {
1.660 + TBool b=Table().IsActive();
1.661 + if (b)
1.662 + iRollback.Mark();
1.663 + return b;
1.664 + }
1.665 +
1.666 +void CDbTable::TValid::CheckL() const
1.667 + {
1.668 + CDbTableDatabase* d=Table().iDatabase;
1.669 + if (!d)
1.670 + __LEAVE(KErrDisconnected);
1.671 + else
1.672 + d->Transaction().ReadyL();
1.673 + if (iRollback.Changed())
1.674 + __LEAVE(KErrNotReady);
1.675 + }