1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/dbms/pcdbms/utable/UT_CURS.CPP Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,629 @@
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 + iDataSource->ReadRowL(KDbNullRecordId); // row buffer contains NULL row (cannot fail)
1.394 + iFlags&=(EUpdatable|EReadable);
1.395 + }
1.396 + }
1.397 +
1.398 +void CDbTableCursor::PutL()
1.399 + {
1.400 + AssertInUpdate();
1.401 + CheckStateL();
1.402 + CDbDataSource::TWrite mode=iFlags&EUpdating ? CDbDataSource::EReplace : CDbDataSource::EAppend;
1.403 + iDataSource->PrepareToWriteRowL(mode);
1.404 + RDbTransaction& t=Transaction();
1.405 + t.DMLTouch();
1.406 + iFlags&=~EDirty;
1.407 + iRecord=iDataSource->WriteRowL(mode,iFlags&EReadable ? CDbDataSource::ESynch : CDbDataSource::ENoSynch);
1.408 + t.DMLCommitL();
1.409 + if ((iFlags&(EInserting|EReadable))==(EInserting|EReadable))
1.410 + iState=ERowOK;
1.411 + iFlags&=(EUpdatable|EReadable|ERead);
1.412 + }
1.413 +
1.414 +void CDbTableCursor::DeleteL()
1.415 + {
1.416 + AssertValidRow();
1.417 + CheckUpdateL();
1.418 + RDbTransaction& t=Transaction();
1.419 + t.DMLPrepareL(*this);
1.420 + t.DMLBeginLC();
1.421 + CDbDataSource::TDelete del=iDataSource->DeleteRowL(iRecord);
1.422 + t.DMLCommitL();
1.423 + CleanupStack::Pop(); // rollback not required
1.424 + iState=TUint8(del+ERowDeletedAtNext);
1.425 + }
1.426 +
1.427 +TInt CDbTableCursor::ColumnCount()
1.428 + {
1.429 + return iColumns->Count();
1.430 + }
1.431 +
1.432 +void CDbTableCursor::ColumnDef(TDbCol& aCol,TDbColNo aColNo)
1.433 + {
1.434 + iColumns->Check(aColNo);
1.435 + if (iValid)
1.436 + iDataSource->ColumnDef(aColNo).AsTDbCol(aCol);
1.437 + }
1.438 +
1.439 +TDbColType CDbTableCursor::ColumnType(TDbColNo aCol)
1.440 + {
1.441 + return Type(aCol);
1.442 + }
1.443 +
1.444 +void CDbTableCursor::ReplaceBlobL(TDbColumn& aCol)
1.445 + {
1.446 + CheckStateL();
1.447 + const TDbBlob& blob=TDbColumnC(aCol).Blob();
1.448 + if (!blob.IsInline())
1.449 + {
1.450 + iFlags|=EDirty;
1.451 + BlobsL().DeleteL(blob.Id());
1.452 + }
1.453 + }
1.454 +
1.455 +void CDbTableCursor::AddBlobSource()
1.456 +//
1.457 +// Increment the source count and take a read-lock on the database
1.458 +//
1.459 + {
1.460 + AddSource();
1.461 + Transaction().ReadBegin(*this);
1.462 + }
1.463 +
1.464 +void CDbTableCursor::ReleaseBlobSource()
1.465 +//
1.466 +// Decrement the source count and release the read-lock on the database
1.467 +//
1.468 + {
1.469 + ReleaseSource();
1.470 + Transaction().ReadRelease(*this);
1.471 + }
1.472 +
1.473 +MStreamBuf* CDbTableCursor::ColumnSourceL(TDbColNo aCol)
1.474 + {
1.475 + TDbColumnC col(ColumnC(aCol));
1.476 + if ((iFlags&EWriteBuf) || iReadBuf==EMaxReadBuf)
1.477 + __LEAVE(KErrInUse); // only allow 1-write or 255-read streambufs
1.478 + TDbColType type=iColumns->Type(aCol);
1.479 + if (!TDbCol::IsLong(type))
1.480 + return HMemBuf::NewL(*this,col.PtrC8());
1.481 + // blobs
1.482 + const TDbBlob& blob=col.Blob();
1.483 + if (blob.IsInline())
1.484 + return HMemBuf::NewL(*this,blob.PtrC8());
1.485 + // if small enough, pull the blob data through immediately and avoid locking the database
1.486 + if (blob.Size()<=HHeapBuf::EMaxBlobBuffer)
1.487 + return HHeapBuf::NewL(*this,blob,type);
1.488 + //
1.489 + CheckStateL();
1.490 + Transaction().ReadPrepareL(*this);
1.491 + HReadBuf* buf=HReadBuf::NewLC(*this);
1.492 + buf->Set(BlobsL().ReadL(blob.Id(),type));
1.493 + CleanupStack::Pop();
1.494 + return buf;
1.495 + }
1.496 +
1.497 +MStreamBuf* CDbTableCursor::ColumnSinkL(TDbColNo aCol)
1.498 + {
1.499 + TDbColType type=Type(aCol);
1.500 + __ASSERT_ALWAYS(TDbCol::IsLong(type),Panic(EDbWrongType));
1.501 + TDbColumn col=Column(aCol);
1.502 + ReplaceBlobL(col);
1.503 + iFlags|=EDirty;
1.504 + return HWriteBuf::NewL(*this,col,type);
1.505 + }
1.506 +
1.507 +void CDbTableCursor::SetNullL(TDbColNo aCol)
1.508 +//
1.509 +// Make the column Null
1.510 +//
1.511 + {
1.512 + TDbColumn col=Column(aCol);
1.513 + if (TDbCol::IsLong(Type(aCol)))
1.514 + ReplaceBlobL(col);
1.515 + col.SetNull();
1.516 + }
1.517 +
1.518 +TInt CDbTableCursor::ColumnSize(TDbColNo aCol)
1.519 + {
1.520 + TDbColumnC col(ColumnC(aCol));
1.521 + return TDbCol::IsLong(Type(aCol)) ? col.Blob().Size() : col.Size();
1.522 + }
1.523 +
1.524 +RDbRow* CDbTableCursor::RowBuffer()
1.525 +//
1.526 +// Invoked by the server for whole-row access where possible
1.527 +//
1.528 + {
1.529 + __ASSERT(iFlags&ERead);
1.530 + return iDataSource->RowBuffer();
1.531 + }
1.532 +
1.533 +TDbColumnC CDbTableCursor::ColumnC(TDbColNo aCol)
1.534 +//
1.535 +// check row is valid for extraction
1.536 +//
1.537 + {
1.538 + __ASSERT_ALWAYS(iFlags&ERead,Panic(EDbRowNotRead));
1.539 + return iDataSource->Column(aCol);
1.540 + }
1.541 +
1.542 +TDbColumn CDbTableCursor::Column(TDbColNo aCol)
1.543 +//
1.544 +// check row is valid for writing
1.545 +//
1.546 + {
1.547 + AssertInUpdate();
1.548 + return iDataSource->Column(aCol);
1.549 + }
1.550 +
1.551 +void CDbTableCursor::SetIndexL(const TDesC* anIndex)
1.552 + {
1.553 + AssertNotInUpdate();
1.554 + CheckReadL();
1.555 + iDataSource->SetIndexL(anIndex);
1.556 + iState=ERowBeginning;
1.557 + }
1.558 +
1.559 +TBool CDbTableCursor::SeekL(const TDbLookupKey& aKey,RDbTable::TComparison aComparison)
1.560 + {
1.561 + AssertNotInUpdate();
1.562 + CheckReadL();
1.563 + iFlags&=~ERead;
1.564 + iState=ERowInvalid;
1.565 + TBool atrow=iDataSource->SeekL(aKey,aComparison,iRecord);
1.566 + if (atrow)
1.567 + iState=ERowOK;
1.568 + return atrow;
1.569 + }
1.570 +
1.571 +CDbRowConstraint* CDbTableCursor::OpenConstraintL(const TDbQuery& aCriteria)
1.572 +//
1.573 +// Construct a constraint for this rowset
1.574 +//
1.575 + {
1.576 + CSqlSearchCondition* sc=iDataSource->ParseConstraintLC(aCriteria.Query());
1.577 + CDbRowConstraint* constraint=new(ELeave) CConstraint(*this,sc,aCriteria.Comparison());
1.578 + CleanupStack::Pop();
1.579 + return constraint;
1.580 + }
1.581 +
1.582 +TBool CDbTableCursor::MatchL(CDbRowConstraint& aConstraint)
1.583 + {
1.584 + CConstraint& c=STATIC_CAST(CConstraint&,aConstraint);
1.585 + __ASSERT_ALWAYS(c.Check(*this),Panic(EDbRowSetConstraintMismatch));
1.586 + GetL();
1.587 + return c.MatchL();
1.588 + }
1.589 +
1.590 +void CDbTableCursor::CheckReadL() const
1.591 +//
1.592 +// Ensure we are a readable cursor
1.593 +//
1.594 + {
1.595 + CheckStateL();
1.596 + if ((iFlags&EReadable)==0)
1.597 + __LEAVE(KErrWrite);
1.598 + }
1.599 +
1.600 +void CDbTableCursor::CheckUpdateL() const
1.601 +//
1.602 +// Ensure we are a writable cursor
1.603 +//
1.604 + {
1.605 + CheckStateL();
1.606 + if ((iFlags&EUpdatable)==0)
1.607 + __LEAVE(KErrWrite);
1.608 + }
1.609 +
1.610 +void CDbTableCursor::AssertNoStreams() const
1.611 + {
1.612 + __ASSERT_ALWAYS((iFlags&EWriteBuf)==0 && iReadBuf==0,Panic(EDbStreamOpen));
1.613 + }
1.614 +
1.615 +void CDbTableCursor::AssertNotInUpdate() const
1.616 + {
1.617 + __ASSERT_ALWAYS(!InUpdate(),Panic(EDbInUpdate));
1.618 + AssertNoStreams();
1.619 + }
1.620 +
1.621 +void CDbTableCursor::AssertInUpdate() const
1.622 + {
1.623 + __ASSERT_ALWAYS(InUpdate(),Panic(EDbNotInUpdate));
1.624 + AssertNoStreams();
1.625 + }
1.626 +
1.627 +void CDbTableCursor::AssertValidRow() const
1.628 + {
1.629 + AssertNotInUpdate();
1.630 + __ASSERT_ALWAYS(iState==ERowOK||(iFlags&EInserting),Panic(EDbInvalidRow));
1.631 + }
1.632 +