1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/dbms/utable/UT_CURS.CPP Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,631 @@
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 +// Class CDbTableCursor::HColumns
1.22 +
1.23 +class CDbTableCursor::HColumns
1.24 + {
1.25 +public:
1.26 + static HColumns* NewL(const CDbDataSource* aSource);
1.27 + inline TInt Count() const
1.28 + {return iCount;}
1.29 + inline TDbColType Type(TDbColNo aCol) const
1.30 + {__DEBUG(Check(aCol));return TDbColType(iType[aCol-1]);}
1.31 + void Check(TDbColNo aCol) const;
1.32 +private:
1.33 + TInt iCount;
1.34 + TUint8 iType[1];
1.35 + };
1.36 +
1.37 +CDbTableCursor::HColumns* CDbTableCursor::HColumns::NewL(const CDbDataSource* aSource)
1.38 + {
1.39 + TInt count=aSource->ColumnCount();
1.40 + HColumns* self=(HColumns*)User::AllocL(_FOFF(HColumns,iType[count]));
1.41 + self->iCount=count;
1.42 + TUint8* pp=&self->iType[0];
1.43 + for (TDbColNo ii=1;ii<=count;++ii,++pp)
1.44 + *pp=aSource->ColumnDef(ii).iType;
1.45 + return self;
1.46 + }
1.47 +
1.48 +void CDbTableCursor::HColumns::Check(TDbColNo aColNo) const
1.49 + {
1.50 + __ASSERT_ALWAYS(TUint(aColNo-1)<TUint(iCount),Panic(EDbInvalidColumn));
1.51 + }
1.52 +
1.53 +// Class CDbTableCursor::CConstraint
1.54 +
1.55 +NONSHARABLE_CLASS(CDbTableCursor::CConstraint) : public CDbRowConstraint
1.56 + {
1.57 +public:
1.58 + CConstraint(CDbTableCursor& aCursor,CSqlSearchCondition* aSearchCondition,TDbTextComparison aComparison);
1.59 + ~CConstraint();
1.60 +//
1.61 + inline TBool Check(CDbTableCursor& aCursor) const;
1.62 + inline TBool MatchL() const;
1.63 +private:
1.64 + CDbTableCursor& iCursor;
1.65 + CSqlSearchCondition* iSearchCondition;
1.66 + const TTextOps& iTextOps;
1.67 + };
1.68 +
1.69 +CDbTableCursor::CConstraint::CConstraint(CDbTableCursor& aCursor,CSqlSearchCondition* aSearchCondition,TDbTextComparison aComparison)
1.70 + : iCursor(aCursor), iSearchCondition(aSearchCondition), iTextOps(TTextOps::Ops(aComparison))
1.71 + {}
1.72 +
1.73 +CDbTableCursor::CConstraint::~CConstraint()
1.74 + {
1.75 + delete iSearchCondition;
1.76 + }
1.77 +
1.78 +inline TBool CDbTableCursor::CConstraint::Check(CDbTableCursor& aCursor) const
1.79 + {return &iCursor==&aCursor;}
1.80 +inline TBool CDbTableCursor::CConstraint::MatchL() const
1.81 + {return iSearchCondition->EvaluateL(iTextOps);}
1.82 +
1.83 +// Class CDbTableCursor
1.84 +
1.85 +inline void CDbTableCursor::CheckStateL() const
1.86 + {iValid.CheckL();}
1.87 +inline RDbTransaction& CDbTableCursor::Transaction()
1.88 + {__ASSERT(iValid);return iValid.Transaction();}
1.89 +inline TBool CDbTableCursor::InUpdate() const
1.90 + {return iFlags&(EUpdating|EInserting);}
1.91 +
1.92 +CDbTableCursor::CDbTableCursor(RDbAccessPlan& aPlan,RDbRowSet::TAccess aAccess)
1.93 + : iState(ERowBeginning),iValid(aPlan.Table()),iDataSource(aPlan.Adopt())
1.94 + {
1.95 + switch (aAccess)
1.96 + {
1.97 + default:
1.98 + __ASSERT(0);
1.99 + case RDbRowSet::EUpdatable:
1.100 + iFlags=EUpdatable|EReadable;
1.101 + break;
1.102 + case RDbRowSet::EReadOnly:
1.103 + iFlags=EReadable;
1.104 + break;
1.105 + case RDbRowSet::EInsertOnly:
1.106 + iFlags=EUpdatable;
1.107 + break;
1.108 + }
1.109 + }
1.110 +
1.111 +CDbTableCursor::~CDbTableCursor()
1.112 + {
1.113 + Cancel();
1.114 + delete iDataSource;
1.115 + delete iColumns;
1.116 + }
1.117 +
1.118 +CDbTableCursor* CDbTableCursor::NewL(RDbAccessPlan& aPlan,RDbRowSet::TAccess aAccess)
1.119 + {
1.120 + CDbTableCursor* self=new(ELeave) CDbTableCursor(aPlan,aAccess);
1.121 + CleanupStack::PushL(self);
1.122 + self->iColumns=HColumns::NewL(self->iDataSource);
1.123 + self->Reset();
1.124 + CleanupStack::Pop();
1.125 + return self;
1.126 + }
1.127 +
1.128 +TDbColType CDbTableCursor::Type(TDbColNo aCol) const
1.129 + {
1.130 + iColumns->Check(aCol);
1.131 + return iColumns->Type(aCol);
1.132 + }
1.133 +
1.134 +void CDbTableCursor::Reset()
1.135 +//
1.136 +// Reset the cursor for re-evaluation
1.137 +//
1.138 + {
1.139 + AssertNotInUpdate();
1.140 + if (iValid.Reset())
1.141 + {
1.142 + iDataSource->Reset();
1.143 + iState=ERowBeginning;
1.144 + }
1.145 + }
1.146 +
1.147 +TBool CDbTableCursor::EvaluateL()
1.148 +//
1.149 +// Do a unit of evaluation work
1.150 +//
1.151 + {
1.152 + AssertNotInUpdate();
1.153 + CheckStateL();
1.154 + TInt work=256;
1.155 + TBool atRow=EFalse;
1.156 + TBool more=iDataSource->EvaluateL(work,iRecord,atRow);
1.157 + if (atRow)
1.158 + { // evaluation results in a record appearing under the cursor
1.159 + switch (iState)
1.160 + {
1.161 + case ERowEnd:
1.162 + case ERowBeginning:
1.163 + iState=ERowOK;
1.164 + break;
1.165 + case ERowDeletedAtEnd:
1.166 + iState=ERowDeletedAtNext;
1.167 + break;
1.168 + default:
1.169 + break;
1.170 + }
1.171 + }
1.172 + return more?1:0;
1.173 + }
1.174 +
1.175 +void CDbTableCursor::Evaluate(TRequestStatus& aStatus)
1.176 +//
1.177 +// Asynchronous evaluation: invoke synchronous version
1.178 +//
1.179 + {
1.180 + TRequestStatus* pStatus=&aStatus;
1.181 + User::RequestComplete(pStatus,CDbCursor::Evaluate());
1.182 + }
1.183 +
1.184 +TBool CDbTableCursor::Unevaluated()
1.185 +//
1.186 +// Report if there is evaluation to be done
1.187 +//
1.188 + {
1.189 + return iValid ? iDataSource->Unevaluated() : EFalse;
1.190 + }
1.191 +
1.192 +TInt CDbTableCursor::CountL(RDbRowSet::TAccuracy aAccuracy)
1.193 + {
1.194 + AssertNotInUpdate();
1.195 + CheckReadL();
1.196 + TInt count=iDataSource->CountL();
1.197 + return (count==KDbUndefinedCount && aAccuracy==RDbRowSet::EEnsure)
1.198 + ? CDbCursor::CountL(aAccuracy)
1.199 + : count;
1.200 + }
1.201 +
1.202 +TBool CDbTableCursor::AtBeginning()
1.203 + {
1.204 + return iState==ERowBeginning;
1.205 + }
1.206 +
1.207 +TBool CDbTableCursor::AtEnd()
1.208 + {
1.209 + return iState==ERowEnd;
1.210 + }
1.211 +
1.212 +TBool CDbTableCursor::AtRow()
1.213 + {
1.214 + return (iState==ERowOK||(iFlags&EInserting));
1.215 + }
1.216 +
1.217 +TBool CDbTableCursor::GotoL(RDbRowSet::TPosition aPosition)
1.218 +//
1.219 +// Move the cursor in the requested direction
1.220 +// return whether we are at a row or not
1.221 +//
1.222 + {
1.223 + AssertNotInUpdate();
1.224 + CheckReadL();
1.225 + iFlags&=~ERead;
1.226 + switch (aPosition)
1.227 + {
1.228 + default:
1.229 + __ASSERT(0);
1.230 + case RDbRowSet::EFirst:
1.231 + case RDbRowSet::ELast:
1.232 + break;
1.233 + case RDbRowSet::ENext:
1.234 + switch (iState)
1.235 + {
1.236 + default:
1.237 + __ASSERT(0);
1.238 + case ERowInLimbo: // in between previous and next, must evaluate
1.239 + case ERowOK:
1.240 + break;
1.241 + case ERowBeginning: // goto first record
1.242 + aPosition=RDbRowSet::EFirst;
1.243 + break;
1.244 + case ERowEnd:
1.245 + case ERowInvalid:
1.246 + Panic(EDbInvalidRow);
1.247 + break;
1.248 + case ERowDeletedAtNext: // already have the id
1.249 + if (iDataSource->GotoL(iRecord))
1.250 + { // and the record is still there
1.251 + iState=ERowOK;
1.252 + return ETrue;
1.253 + }
1.254 + break;
1.255 + case ERowDeletedAtEnd: // straight to end
1.256 + iState=ERowEnd;
1.257 + return EFalse;
1.258 + }
1.259 + break;
1.260 + case RDbRowSet::EPrevious:
1.261 + switch (iState)
1.262 + {
1.263 + default:
1.264 + __ASSERT(0);
1.265 + case ERowOK:
1.266 + case ERowDeletedAtNext: // goto previous will do what we want
1.267 + case ERowInLimbo: // in between previous and next, must evaluate
1.268 + break;
1.269 + case ERowEnd: // goto last row
1.270 + case ERowDeletedAtEnd: // previous is last row
1.271 + aPosition=RDbRowSet::ELast;
1.272 + break;
1.273 + case ERowBeginning:
1.274 + case ERowInvalid:
1.275 + Panic(EDbInvalidRow);
1.276 + break;
1.277 + }
1.278 + break;
1.279 + case RDbRowSet::EBeginning:
1.280 + iState=ERowBeginning;
1.281 + return EFalse;
1.282 + case RDbRowSet::EEnd:
1.283 + iState=ERowEnd;
1.284 + return EFalse;
1.285 + }
1.286 + iState=ERowInvalid;
1.287 + switch (iDataSource->GotoL(TDbPosition(aPosition),iRecord))
1.288 + {
1.289 + default:
1.290 + __ASSERT(0);
1.291 + case CDbDataSource::ESynchFailure:
1.292 + __LEAVE(KErrNotReady);
1.293 + case CDbDataSource::ESuccess:
1.294 + iState=ERowOK;
1.295 + return ETrue;
1.296 + case CDbDataSource::ENoRow:
1.297 + iState=TUint8(aPosition<RDbRowSet::EPrevious ? ERowEnd : ERowBeginning);
1.298 + return EFalse;
1.299 + }
1.300 + }
1.301 +
1.302 +void CDbTableCursor::Bookmark(TDbBookmark::TMark& aMark)
1.303 +//
1.304 +// Create a bookmark for the current cursor state
1.305 +// Can bookmark ANY position.
1.306 +//
1.307 + {
1.308 + AssertNotInUpdate();
1.309 + aMark.iMark[0]=iState;
1.310 + aMark.iMark[1]=iRecord.Value();
1.311 + }
1.312 +
1.313 +void CDbTableCursor::GotoL(const TDbBookmark::TMark& aMark)
1.314 +//
1.315 +// Reestablish the cursor state from a bookmark (if possible)
1.316 +//
1.317 + {
1.318 + AssertNotInUpdate();
1.319 + CheckStateL();
1.320 + iState=ERowInvalid;
1.321 + iRecord=aMark.iMark[1];
1.322 + TState state=TState(aMark.iMark[0]);
1.323 + switch (state)
1.324 + {
1.325 + default:
1.326 + Panic(EDbInvalidBookmark);
1.327 + case ERowBeginning:
1.328 + case ERowEnd:
1.329 + case ERowDeletedAtEnd:
1.330 + case ERowInLimbo:
1.331 + case ERowInvalid:
1.332 + break;
1.333 + case ERowDeletedAtNext:
1.334 + case ERowOK:
1.335 + if (!iDataSource->GotoL(iRecord))
1.336 + __LEAVE(KErrNotFound);
1.337 + break;
1.338 + }
1.339 + iState=TUint8(state);
1.340 + }
1.341 +
1.342 +void CDbTableCursor::GetL()
1.343 +//
1.344 +// read the current row into the row buffer for access
1.345 +//
1.346 + {
1.347 + AssertValidRow();
1.348 + CheckStateL();
1.349 + iFlags&=~ERead;
1.350 + iDataSource->ReadRowL(iRecord);
1.351 + iFlags|=ERead;
1.352 + }
1.353 +
1.354 +void CDbTableCursor::InsertL(TInsert aClearRow)
1.355 +//
1.356 +// Insert a new row. If aCLearRow==aCopy, then copy the current row
1.357 +//
1.358 + {
1.359 + AssertNotInUpdate();
1.360 + CheckUpdateL();
1.361 + Transaction().DMLPrepareL(*this);
1.362 + if (aClearRow==ECopy)
1.363 + {
1.364 + AssertValidRow();
1.365 + iFlags&=~ERead; // in case of failure in NewRowL
1.366 + iDataSource->NewRowL(iRecord);
1.367 + }
1.368 + else
1.369 + iDataSource->NewRowL(KDbNullRecordId);
1.370 + iFlags|=EInserting|ERead;
1.371 + Transaction().DMLBegin();
1.372 + }
1.373 +
1.374 +void CDbTableCursor::UpdateL()
1.375 + {
1.376 + CheckUpdateL();
1.377 + Transaction().DMLPrepareL(*this);
1.378 + GetL();
1.379 + iFlags|=EUpdating;
1.380 + Transaction().DMLBegin();
1.381 + }
1.382 +
1.383 +void CDbTableCursor::Cancel()
1.384 + {
1.385 + AssertNoStreams();
1.386 + if (InUpdate())
1.387 + {
1.388 + RDbTransaction& t=Transaction();
1.389 + if (iFlags&EDirty)
1.390 + t.DMLTouch(); // we've mucked about with BLOBs, so force true roll-back
1.391 + t.DMLRollback();
1.392 + if (iFlags&EUpdating)
1.393 + {
1.394 + TRAP_IGNORE(iDataSource->ReadRowL(KDbNullRecordId)); // row buffer contains NULL row (cannot fail)
1.395 + }
1.396 + iFlags&=(EUpdatable|EReadable);
1.397 + }
1.398 + }
1.399 +
1.400 +void CDbTableCursor::PutL()
1.401 + {
1.402 + AssertInUpdate();
1.403 + CheckStateL();
1.404 + CDbDataSource::TWrite mode=iFlags&EUpdating ? CDbDataSource::EReplace : CDbDataSource::EAppend;
1.405 + iDataSource->PrepareToWriteRowL(mode);
1.406 + RDbTransaction& t=Transaction();
1.407 + t.DMLTouch();
1.408 + iFlags&=~EDirty;
1.409 + iRecord=iDataSource->WriteRowL(mode,iFlags&EReadable ? CDbDataSource::ESynch : CDbDataSource::ENoSynch);
1.410 + t.DMLCommitL();
1.411 + if ((iFlags&(EInserting|EReadable))==(EInserting|EReadable))
1.412 + iState=ERowOK;
1.413 + iFlags&=(EUpdatable|EReadable|ERead);
1.414 + }
1.415 +
1.416 +void CDbTableCursor::DeleteL()
1.417 + {
1.418 + AssertValidRow();
1.419 + CheckUpdateL();
1.420 + RDbTransaction& t=Transaction();
1.421 + t.DMLPrepareL(*this);
1.422 + t.DMLBeginLC();
1.423 + CDbDataSource::TDelete del=iDataSource->DeleteRowL(iRecord);
1.424 + t.DMLCommitL();
1.425 + CleanupStack::Pop(); // rollback not required
1.426 + iState=TUint8(del+ERowDeletedAtNext);
1.427 + }
1.428 +
1.429 +TInt CDbTableCursor::ColumnCount()
1.430 + {
1.431 + return iColumns->Count();
1.432 + }
1.433 +
1.434 +void CDbTableCursor::ColumnDef(TDbCol& aCol,TDbColNo aColNo)
1.435 + {
1.436 + iColumns->Check(aColNo);
1.437 + if (iValid)
1.438 + iDataSource->ColumnDef(aColNo).AsTDbCol(aCol);
1.439 + }
1.440 +
1.441 +TDbColType CDbTableCursor::ColumnType(TDbColNo aCol)
1.442 + {
1.443 + return Type(aCol);
1.444 + }
1.445 +
1.446 +void CDbTableCursor::ReplaceBlobL(TDbColumn& aCol)
1.447 + {
1.448 + CheckStateL();
1.449 + const TDbBlob& blob=TDbColumnC(aCol).Blob();
1.450 + if (!blob.IsInline())
1.451 + {
1.452 + iFlags|=EDirty;
1.453 + BlobsL().DeleteL(blob.Id());
1.454 + }
1.455 + }
1.456 +
1.457 +void CDbTableCursor::AddBlobSource()
1.458 +//
1.459 +// Increment the source count and take a read-lock on the database
1.460 +//
1.461 + {
1.462 + AddSource();
1.463 + Transaction().ReadBegin(*this);
1.464 + }
1.465 +
1.466 +void CDbTableCursor::ReleaseBlobSource()
1.467 +//
1.468 +// Decrement the source count and release the read-lock on the database
1.469 +//
1.470 + {
1.471 + ReleaseSource();
1.472 + Transaction().ReadRelease(*this);
1.473 + }
1.474 +
1.475 +MStreamBuf* CDbTableCursor::ColumnSourceL(TDbColNo aCol)
1.476 + {
1.477 + TDbColumnC col(ColumnC(aCol));
1.478 + if ((iFlags&EWriteBuf) || iReadBuf==EMaxReadBuf)
1.479 + __LEAVE(KErrInUse); // only allow 1-write or 255-read streambufs
1.480 + TDbColType type=iColumns->Type(aCol);
1.481 + if (!TDbCol::IsLong(type))
1.482 + return HMemBuf::NewL(*this,col.PtrC8());
1.483 + // blobs
1.484 + const TDbBlob& blob=col.Blob();
1.485 + if (blob.IsInline())
1.486 + return HMemBuf::NewL(*this,blob.PtrC8());
1.487 + // if small enough, pull the blob data through immediately and avoid locking the database
1.488 + if (blob.Size()<=HHeapBuf::EMaxBlobBuffer)
1.489 + return HHeapBuf::NewL(*this,blob,type);
1.490 + //
1.491 + CheckStateL();
1.492 + Transaction().ReadPrepareL(*this);
1.493 + HReadBuf* buf=HReadBuf::NewLC(*this);
1.494 + buf->Set(BlobsL().ReadL(blob.Id(),type));
1.495 + CleanupStack::Pop();
1.496 + return buf;
1.497 + }
1.498 +
1.499 +MStreamBuf* CDbTableCursor::ColumnSinkL(TDbColNo aCol)
1.500 + {
1.501 + TDbColType type=Type(aCol);
1.502 + __ASSERT_ALWAYS(TDbCol::IsLong(type),Panic(EDbWrongType));
1.503 + TDbColumn col=Column(aCol);
1.504 + ReplaceBlobL(col);
1.505 + iFlags|=EDirty;
1.506 + return HWriteBuf::NewL(*this,col,type);
1.507 + }
1.508 +
1.509 +void CDbTableCursor::SetNullL(TDbColNo aCol)
1.510 +//
1.511 +// Make the column Null
1.512 +//
1.513 + {
1.514 + TDbColumn col=Column(aCol);
1.515 + if (TDbCol::IsLong(Type(aCol)))
1.516 + ReplaceBlobL(col);
1.517 + col.SetNull();
1.518 + }
1.519 +
1.520 +TInt CDbTableCursor::ColumnSize(TDbColNo aCol)
1.521 + {
1.522 + TDbColumnC col(ColumnC(aCol));
1.523 + return TDbCol::IsLong(Type(aCol)) ? col.Blob().Size() : col.Size();
1.524 + }
1.525 +
1.526 +RDbRow* CDbTableCursor::RowBuffer()
1.527 +//
1.528 +// Invoked by the server for whole-row access where possible
1.529 +//
1.530 + {
1.531 + __ASSERT(iFlags&ERead);
1.532 + return iDataSource->RowBuffer();
1.533 + }
1.534 +
1.535 +TDbColumnC CDbTableCursor::ColumnC(TDbColNo aCol)
1.536 +//
1.537 +// check row is valid for extraction
1.538 +//
1.539 + {
1.540 + __ASSERT_ALWAYS(iFlags&ERead,Panic(EDbRowNotRead));
1.541 + return iDataSource->Column(aCol);
1.542 + }
1.543 +
1.544 +TDbColumn CDbTableCursor::Column(TDbColNo aCol)
1.545 +//
1.546 +// check row is valid for writing
1.547 +//
1.548 + {
1.549 + AssertInUpdate();
1.550 + return iDataSource->Column(aCol);
1.551 + }
1.552 +
1.553 +void CDbTableCursor::SetIndexL(const TDesC* anIndex)
1.554 + {
1.555 + AssertNotInUpdate();
1.556 + CheckReadL();
1.557 + iDataSource->SetIndexL(anIndex);
1.558 + iState=ERowBeginning;
1.559 + }
1.560 +
1.561 +TBool CDbTableCursor::SeekL(const TDbLookupKey& aKey,RDbTable::TComparison aComparison)
1.562 + {
1.563 + AssertNotInUpdate();
1.564 + CheckReadL();
1.565 + iFlags&=~ERead;
1.566 + iState=ERowInvalid;
1.567 + TBool atrow=iDataSource->SeekL(aKey,aComparison,iRecord);
1.568 + if (atrow)
1.569 + iState=ERowOK;
1.570 + return atrow;
1.571 + }
1.572 +
1.573 +CDbRowConstraint* CDbTableCursor::OpenConstraintL(const TDbQuery& aCriteria)
1.574 +//
1.575 +// Construct a constraint for this rowset
1.576 +//
1.577 + {
1.578 + CSqlSearchCondition* sc=iDataSource->ParseConstraintLC(aCriteria.Query());
1.579 + CDbRowConstraint* constraint=new(ELeave) CConstraint(*this,sc,aCriteria.Comparison());
1.580 + CleanupStack::Pop();
1.581 + return constraint;
1.582 + }
1.583 +
1.584 +TBool CDbTableCursor::MatchL(CDbRowConstraint& aConstraint)
1.585 + {
1.586 + CConstraint& c=STATIC_CAST(CConstraint&,aConstraint);
1.587 + __ASSERT_ALWAYS(c.Check(*this),Panic(EDbRowSetConstraintMismatch));
1.588 + GetL();
1.589 + return c.MatchL();
1.590 + }
1.591 +
1.592 +void CDbTableCursor::CheckReadL() const
1.593 +//
1.594 +// Ensure we are a readable cursor
1.595 +//
1.596 + {
1.597 + CheckStateL();
1.598 + if ((iFlags&EReadable)==0)
1.599 + __LEAVE(KErrWrite);
1.600 + }
1.601 +
1.602 +void CDbTableCursor::CheckUpdateL() const
1.603 +//
1.604 +// Ensure we are a writable cursor
1.605 +//
1.606 + {
1.607 + CheckStateL();
1.608 + if ((iFlags&EUpdatable)==0)
1.609 + __LEAVE(KErrWrite);
1.610 + }
1.611 +
1.612 +void CDbTableCursor::AssertNoStreams() const
1.613 + {
1.614 + __ASSERT_ALWAYS((iFlags&EWriteBuf)==0 && iReadBuf==0,Panic(EDbStreamOpen));
1.615 + }
1.616 +
1.617 +void CDbTableCursor::AssertNotInUpdate() const
1.618 + {
1.619 + __ASSERT_ALWAYS(!InUpdate(),Panic(EDbInUpdate));
1.620 + AssertNoStreams();
1.621 + }
1.622 +
1.623 +void CDbTableCursor::AssertInUpdate() const
1.624 + {
1.625 + __ASSERT_ALWAYS(InUpdate(),Panic(EDbNotInUpdate));
1.626 + AssertNoStreams();
1.627 + }
1.628 +
1.629 +void CDbTableCursor::AssertValidRow() const
1.630 + {
1.631 + AssertNotInUpdate();
1.632 + __ASSERT_ALWAYS(iState==ERowOK||(iFlags&EInserting),Panic(EDbInvalidRow));
1.633 + }
1.634 +