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