// Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).

 // All rights reserved.

 // This component and the accompanying materials are made available

 // under the terms of "Eclipse Public License v1.0"

 // which accompanies this distribution, and is available

 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

 //

 // Initial Contributors:

 // Nokia Corporation - initial contribution.

 //

 // Contributors:

 //

 // Description:

 //

 #include "UD_STD.H"

 // Class RDbRowSet

 /** Resets the rowset.

 For a Table, this just sets the rowset cursor to the beginning position.

 For an SQL view, this discards any evaluated rows and returns the cursor to 

 the beginning. The view then requires reevaluation.

 The Store Database implementation requires this function to be called in order 

 to recover an open rowset object after the database has been rolled back. 

 The rowset does not need to be closed in this situation.

 If a rowset object requires a reset, then all row functions return or leave 

 with KErrNotReady. */

 EXPORT_C void RDbRowSet::Reset()

 	{

 	iCursor->Reset();

 	}

 /** Closes the rowset and releases any owned resources. It is safe to close a rowset 

 object which is not open. */

 EXPORT_C void RDbRowSet::Close()

 	{

 	iCursor.Close();

 	}

 /** Returns the number of rows available in a rowset.

 This can take some time to complete, and a parameter can be passed to request 

 a quick but not always thorough count of the rows.

 For SQL views, the value returned depends on the evaluation window being used 

 by the view. If there is an evaluation window this function will always return 

 the number of rows available in the window, not the total number which could 

 be returned by the query.

 @param anAccuracy This specifies whether to ensure that an accurate count 

 is returned, or to give up if this value is not readily available. The default 

 is to ensure an accurate count.

 @return The number of rows available in the rowset, or KDbUndefinedCount if 

 EQuick was specified and the count was not available. 

 @capability Note For a secure shared database, the caller must satisfy either the read

             or the write access policy for the table.

 */

 EXPORT_C TInt RDbRowSet::CountL(TAccuracy aAccuracy) const

 	{

 	return iCursor->CountL(aAccuracy);

 	}

 /** Tests whether there are any rows in the rowset. This is often faster than testing 

 whether CountL()==0.

 @return ETrue if there are no rows available in the rowset, EFalse if there 

 are one or more. 

 @capability Note For a secure shared database, the caller must satisfy the read

             access policy for the table.

 */

 EXPORT_C TBool RDbRowSet::IsEmptyL() const

 	{

 	if (AtRow())

 		return EFalse;

 	TInt count=CountL(EQuick);

 	if (count!=KDbUndefinedCount)

 		return count==0;

 	TDbBookmark mark=Bookmark();

 	CDbCursor& cursor=*iCursor;

 	TBool hasRow=cursor.GotoL(EFirst);

 	cursor.GotoL(mark.iMark);

 	return !hasRow;

 	}

 /** Returns the entire column set for the rowset. This can be used to discover 

 column ordinals for named columns in this rowset.

 The function leaves with KErrNoMemory if there is not enough memory to carry 

 out the operation. 

 @return The column set object which describes this rowset structure. The caller 

 should delete it when it is no longer required. */

 EXPORT_C CDbColSet* RDbRowSet::ColSetL() const

 	{

 	CDbColSet* cs=CDbColSet::NewLC();

 	iCursor->ColumnsL(*cs);

 	CleanupStack::Pop();

 	return cs;

 	}

 /** Returns the number of columns which are defined in this rowset.

 @return The number of columns which are defined in this rowset. */

 EXPORT_C TInt RDbRowSet::ColCount() const

 	{

 	return iCursor->ColumnCount();

 	}

 /** Returns the type of a column in the rowset.

 @param aCol The column ordinal for which the column type is required. Column 

 ordinals range from 1 to ColCount().

 @return The type of the column aCol. */

 EXPORT_C TDbColType RDbRowSet::ColType(TDbColNo aColNo) const

 	{

 	return iCursor->ColumnType(aColNo);

 	}

 /** Returns the definition of a column in the rowset.

 @param aCol The column ordinal for which the column definition is required. 

 Column ordinals range from 1 to ColCount().

 @return The definition of the column aCol. */

 EXPORT_C TDbCol RDbRowSet::ColDef(TDbColNo aColNo) const

 	{

 	TDbCol col;

 	iCursor->ColumnDef(col,aColNo);

 	return col;

 	}

 /** Tests whether the cursor is on a row.

 One of the following is true:

 the rowset is currently updating a row

 the rowset is currently inserting a row

 GetL() can be called to retrieve the row

 @return ETrue if the cursor is on a valid row; EFalse, otherwise. */

 EXPORT_C TBool RDbRowSet::AtRow() const

 	{

 	return iCursor->AtRow();

 	}

 /** Tests whether the cursor is at the beginning of the rowset.

 @return ETrue if the cursor is at the beginning, otherwise EFalse. */

 EXPORT_C TBool RDbRowSet::AtBeginning() const

 	{

 	return iCursor->AtBeginning();

 	}

 /** Tests whether the cursor is at the end of the rowset.

 @return ETrue if the cursor is at the end, otherwise EFalse. */

 EXPORT_C TBool RDbRowSet::AtEnd() const

 	{

 	return iCursor->AtEnd();

 	}

 /** Moves the cursor to a specified position.

 This is invoked by Beginning(), End(), FirstL(), LastL(), NextL() and PreviousL() 

 to navigate the cursor. See those functions for descriptions of how the cursor 

 behaves given different position specifications.

 @param aPosition Specifies the position to move the cursor to.

 @return ETrue if the cursor is now at a row, EFalse if it is at the beginning 

 or end. 

 @capability Note For a secure shared database, the caller must satisfy the read

             access policy for the table.

 */

 EXPORT_C TBool RDbRowSet::GotoL(TPosition aPosition)

 	{

 	return iCursor->GotoL(aPosition);

 	}

 /** Gets the bookmark for the current cursor position. Bookmarks cannot be extracted 

 when the rowset is updating or inserting a row.

 The Store Database implementation allows bookmarks to be extracted for any 

 cursor position including the beginning and end.

 @return A bookmark which can be used to return to the current position using 

 the GotoL() function. 

 @capability Note For a secure shared database, the caller must satisfy the read

             access policy for the table.

 */

 EXPORT_C TDbBookmark RDbRowSet::Bookmark() const

 	{

 	TDbBookmark mark;

 	iCursor->Bookmark(mark.iMark);

 	return mark;

 	}

 /** Goes to a previously bookmarked position in a rowset.

 The Store Database implements bookmarks which are valid in any rowset based 

 on the same table or generated by the same query, and which persist across 

 transaction boundaries.

 @param aMark The bookmark to return to. This should have been returned by 

 a previous call to Bookmark() on this or an equivalent rowset object. 

 @capability Note For a secure shared database, the caller must satisfy the read

             access policy for the table.

 */

 EXPORT_C void RDbRowSet::GotoL(const TDbBookmark& aMark)

 	{

 	iCursor->GotoL(aMark.iMark);

 	}

 /** Gets the current row data for access using the column extractor functions. 

 The cursor must be positioned at a valid row. 

 @capability Note For a secure shared database, the caller must satisfy the read

             access policy for the table.

 */

 EXPORT_C void RDbRowSet::GetL()

 	{

 	iCursor->GetL();

 	}

 /** Inserts a new row into the rowset. All auto-increment columns will be initialised 

 with their new values, all other columns will be initialised to NULL values. 

 If no client-begun transaction is in progress, this function begins an automatic 

 transaction, which is committed by PutL().

 After the column values have been set using the SetColL() functions, the row 

 can be written to the database using PutL(). 

 @capability Note For a secure shared database, the caller must satisfy the write

             access policy for the table.

 */

 EXPORT_C void RDbRowSet::InsertL()

 	{

 	iCursor->InsertL(CDbCursor::EClear);

 	}

 /** Inserts a copy of the current row into the rowset. All auto-increment columns 

 will be given a new value (as for InsertL()), the other columns will copy 

 their values from the cursor's current row. If no client-begun transaction 

 is in progress, this function begins an automatic transaction, which is committed 

 by PutL().

 After the column values have been modified using the SetColL() functions, 

 the row can be written to the database using PutL(). 

 @capability Note For a secure shared database, the caller must satisfy the write

             access policy for the table.

 */

 EXPORT_C void RDbRowSet::InsertCopyL()

 	{

 	iCursor->InsertL(CDbCursor::ECopy);

 	}

 /** Prepares the current row for update. If no client-begun transaction is in progress, 

 this function begins an automatic transaction, which is committed by PutL().

 After the column values have been modified using the SetColL() functions, 

 the row can be written back to the database using PutL(). 

 @capability Note For a secure shared database, the caller must satisfy the write

             access policy for the table.

 */

 EXPORT_C void RDbRowSet::UpdateL()

 	{

 	iCursor->UpdateL();

 	}

 /** Completes the update or insertion of a row.

 First the new row data is validated:

 not-null columns are checked to be not NULL

 numerical columns are checked to be in range for their type

 variable length columns are checked to not exceed their maximum length

 unique index keys are checked to ensure uniqueness is not violated

 Note that modifying auto-increment columns is not prevented by DBMS.

 Following validation the data is written to the database and any affected 

 indexes are updated. On successful completion of the write, PutL() will then 

 commit any automatic transaction.

 The cursor is left positioned on the updated or inserted row — where this 

 lies in the rowset is not always well defined. To return to the row which 

 was current prior to the update or insertion, a bookmark can be used.

 In the Store Database implementation the written row is located in the rowset 

 as follows:

 Tables without an active index will leave updated rows in the same location 

 and append new rows to the end of the rowset.

 Tables with an active index place the row according to the active index ordering.

 SQL views without an evaluation window will place it according to the rowset 

 ordering. The row may subsequently disappear if it does not match the WHERE 

 clause of the SQL query.

 SQL views with a full evaluation window will leave updated rows in the same 

 location and append new rows to the end of the rowset. Re-evaluation may cause 

 the row to disappear if it does not match the WHERE clause of the SQL query.

 SQL views with a partial evaluation window will leave updated rows in the 

 same location, new rows are not added to the window and navigation from the 

 new row is undefined. Further navigation and evaluation of the partial window 

 will place the rows in the correct location according to the query. 

 @capability Note For a secure shared database, the caller must satisfy the write

             access policy for the table.

 */

 EXPORT_C void RDbRowSet::PutL()

 	{

 	iCursor->PutL();

 	}

 /** Deletes the current row in a rowset. The rowset must not currently be updating 

 or inserting the row.

 The rowset cursor is left positioned at the "hole" left by the deletion of 

 the current row. Navigation to the next or previous row will have the same 

 effect as if this row had not been deleted. Once the cursor has been moved 

 from the "hole" it will disappear from the rowset.

 If the client has not begun a transaction, this function will use an automatic 

 transaction to update the rowset. 

 @capability Note For a secure shared database, the caller must satisfy the write

             access policy for the table.

 */

 EXPORT_C void RDbRowSet::DeleteL()

 	{

 	iCursor->DeleteL();

 	}

 /** Cancels the update or insertion of a row, or recovers the rowset if PutL() 

 fails. The cursor will return to the location prior to starting the update 

 or insertion. It is also safe to call this function when the rowset object 

 is not updating or inserting a row, in which case it does nothing.

 In the Store database implementation, if this is called to abort a row update 

 or insertion before PutL() is called or during row validation in PutL(), all 

 the changes are discarded without requiring a transaction rollback and the 

 rowset to be Reset(). */

 EXPORT_C void RDbRowSet::Cancel()

 	{

 	iCursor->Cancel();

 	}

 //

 // Checks for valid Cursor and column ID

 //

 CDbCursor& RDbRowSet::CheckCol(TDbColNo aCol) const

 	{

 	CDbCursor& cr=*iCursor;

 	__ASSERT_ALWAYS(aCol>0&&aCol<=cr.ColumnCount(),Panic(EDbInvalidColumn));

 	return cr;

 	}

 //

 // Checks for valid Cursor, column ID and type

 //

 TDbColumnC RDbRowSet::ColumnC(TDbColNo aCol,TDbColType aType) const

 	{

 	CDbCursor& cr=*iCursor;

 	TDbColType cType=cr.ColumnType(aCol);

 	if (cType!=aType)

 		{	// not an exact match

 		if (cType>aType)

 			Panic(EDbWrongType);		// extraction type is narrower

 		else if (!IsIntegral(cType))

 			Panic(EDbWrongType);		// type is non-integral

 		else if (IsSigned(cType) && IsUnsigned(aType))

 			Panic(EDbWrongType);		// cannot get signed column as unsigned

 		}

 	return cr.ColumnC(aCol);

 	}

 TDbColumn RDbRowSet::Column(TDbColNo aCol,TDbColType aType)

 	{

 	CDbCursor& cr=*iCursor;

 	__ASSERT_ALWAYS(cr.ColumnType(aCol)==aType,Panic(EDbWrongType));

 	return cr.Column(aCol);

 	}

 /** Gets the size in bytes of a column value. This can be used for all column types, 

 including Long columns. NULL columns return a size of 0.

 Note:

 This may yield unexpected results for small numerical column types as they 

 are stored in memory as 32-bit values.

 @param aCol The column ordinal of the column to check.

 @return The length in bytes of column aCol's value. */

 EXPORT_C TInt RDbRowSet::ColSize(TDbColNo aCol) const

 	{

 	return iCursor->ColumnSize(aCol);

 	}

 /** Gets the length of a column value. As compared with ColSize(), this returns 

 the number of "units" in the column:

 NULL columns have a length of 0

 non-NULL numerical and date-time columns have a length of 1

 for Text columns the length is the character count

 for Binary columns the length is the byte count

 @param aCol The column ordinal of the column to check.

 @return The length in "units" of column aCol's value. */

 EXPORT_C TInt RDbRowSet::ColLength(TDbColNo aCol) const

 	{

 	TInt size=ColSize(aCol);

 	switch (iCursor()->ColumnType(aCol))

 		{

 	case EDbColText8:

 	case EDbColLongText8:

 	case EDbColBinary:

 	case EDbColLongBinary:

 		break;

 	case EDbColText16:

 	case EDbColLongText16:

 		if (size>0)

 			size>>=1;

 		break;

 	default:

 		if (size)

 			size=1;

 		break;

 		}

 	return size;

 	}

 /** Extracts a TInt8 column value.

 @param aCol The column ordinal of the column to extract.

 @return The value of column aCol. */

 EXPORT_C TInt8 RDbRowSet::ColInt8(TDbColNo aCol) const

 	{

 	return ColumnC(aCol,EDbColInt8).Int8();

 	} 

 /** Extracts a TInt16 or TInt8 column value.

 @param aCol The column ordinal of the column to extract.

 @return The value of column aCol. */

 EXPORT_C TInt16 RDbRowSet::ColInt16(TDbColNo aCol) const

 	{

 	return ColumnC(aCol,EDbColInt16).Int16();

 	} 

 /** Extracts a TInt32, TInt16 or TInt8 column value.

 @param aCol The column ordinal of the column to extract.

 @return The value of column aCol. */

 EXPORT_C TInt32 RDbRowSet::ColInt32(TDbColNo aCol) const

 	{

 	return ColumnC(aCol,EDbColInt32).Int32();

 	} 

 /** Extracts a TInt64 column value.

 @param aCol The column ordinal of the column to extract.

 @return The value of column aCol. */

 EXPORT_C TInt64 RDbRowSet::ColInt64(TDbColNo aCol) const

 	{

 	CDbCursor& cr=*iCursor;

 	TDbColumnC c=cr.ColumnC(aCol);

 	TDbColType t=cr.ColumnType(aCol);

 	if (t==EDbColInt64)

 		return c.Int64();

 	if (t>EDbColInt64)

 		Panic(EDbWrongType);

 	if (IsSigned(t))

 		return TInt(c.Int32());

 	return TUint(c.Uint32());

 	} 

 /** Extracts a Uint8 or Bit column value.

 @param aCol The column ordinal of the column to extract.

 @return The value of column aCol. */

 EXPORT_C TUint8 RDbRowSet::ColUint8(TDbColNo aCol) const

 	{

 	return ColumnC(aCol,EDbColUint8).Uint8();

 	} 

 /** Extracts a Uint16, Uint8 or Bit column value.

 @param aCol The column ordinal of the column to extract.

 @return The value of column aCol. */

 EXPORT_C TUint16 RDbRowSet::ColUint16(TDbColNo aCol) const

 	{

 	return ColumnC(aCol,EDbColUint16).Uint16();

 	} 

 /** Extracts a Uint32, Uint16, Uint8 or Bit column value.

 @param aCol The column ordinal of the column to extract.

 @return The value of column aCol. */

 EXPORT_C TUint32 RDbRowSet::ColUint32(TDbColNo aCol) const

 	{

 	return ColumnC(aCol,EDbColUint32).Uint32();

 	} 

 /** Extracts a TReal32 column value.

 @param aCol The column ordinal of the column to extract.

 @return The value of column aCol. */

 EXPORT_C TReal32 RDbRowSet::ColReal32(TDbColNo aCol) const __SOFTFP

 	{

 	return ColumnC(aCol,EDbColReal32).Real32();

 	} 

 /** Extracts a TReal64 column value.

 @param aCol The column ordinal of the column to extract.

 @return The value of column aCol. */

 EXPORT_C TReal64 RDbRowSet::ColReal64(TDbColNo aCol) const __SOFTFP

 	{

 	return ColumnC(aCol,EDbColReal64).Real64();

 	} 

 /** Extracts a TTime column value.

 @param aCol The column ordinal of the column to extract.

 @return The value of column aCol. TTime may be either local time or universal time. 

 DBMS doesn't interpret the value of TTime, it is left up to the user to know which has been used.*/

 EXPORT_C TTime RDbRowSet::ColTime(TDbColNo aCol) const

 	{

 	return ColumnC(aCol,EDbColDateTime).Time();

 	} 

 /** Extracts any column type, except Long columns, as binary data.

 Can handle any type of non-long column

 @param aCol The column ordinal of the column to extract.

 @return A descriptor of column aCol's value. */

 EXPORT_C TPtrC8 RDbRowSet::ColDes8(TDbColNo aCol) const

 	{

 	CDbCursor& cr=*iCursor;

 	__ASSERT_ALWAYS(!IsLong(cr.ColumnType(aCol)),Panic(EDbWrongType));

 	return cr.ColumnC(aCol).PtrC8();

 	} 

 /** Extracts a column as Unicode text.

 @param aCol The column ordinal of the column to extract

 @return A descriptor of column aCol's value. */

 EXPORT_C TPtrC16 RDbRowSet::ColDes16(TDbColNo aCol) const

 	{

 	return ColumnC(aCol,EDbColText16).PtrC16();

 	}

 /** Extracts a Text column value. The column type must match the default descriptor 

 type to use this extractor, ie. it must be equal to EDbColText.

 @param aCol The column ordinal of the column to extract.

 @return A descriptor of column aCol's value. */

 EXPORT_C TPtrC RDbRowSet::ColDes(TDbColNo aCol) const

 	{

 	return ColDes16(aCol);

 	}

 /** Use this function to set the value of a column to NULL.

 @param aCol The column ordinal of the column to set to NULL. 

 @capability Note For a secure shared database, the caller must satisfy the write

             access policy for the table.

 */

 EXPORT_C void RDbRowSet::SetColNullL(TDbColNo aCol)

 	{

 	iCursor->SetNullL(aCol);

 	}

 /** Sets a TInt32, TInt16 or TInt8 column value.

 @param aCol The column ordinal of the column to set.

 @param aValue The new column value. */

 EXPORT_C void RDbRowSet::SetColL(TDbColNo aCol,TInt32 aValue)

 	{

 	CDbCursor& cr=*iCursor;

 	TDbColType t=cr.ColumnType(aCol);

 	if (t<EDbColInt64)

 		{	// set any <= 32-bit integral type

 		if (IsSigned(t))

 			{

 			cr.Column(aCol).SetL(aValue);

 			return;

 			}

 		if (aValue>=0)

 			{	// check the domain for unsigned columns

 			cr.Column(aCol).SetL(aValue);

 			return;

 			}

 		}

 	Panic(EDbWrongType);

 	}

 /** Sets a TInt64 column value.

 @param aCol The column ordinal of the column to set.

 @param aValue The new column value. */

 EXPORT_C void RDbRowSet::SetColL(TDbColNo aCol,TInt64 aValue)

 	{

 	CDbCursor& cr=*iCursor;

 	TDbColumn c=cr.Column(aCol);

 	TDbColType t=cr.ColumnType(aCol);

 	if (t==EDbColInt64)

 		{		// exact match

 		c.SetL(aValue);

 		return;

 		}

 	if (t<EDbColInt64)

 		{

 		TInt32 l = I64LOW(aValue);

 		TInt32 h = I64HIGH(aValue);

 		if (IsSigned(t))

 			{	// check the domain for signed 32-bit 

 			if (h==l>>31)		// sign-extend l gives aValue

 				{

 				c.SetL(l);

 				return;

 				}

 			}	// invalid type, drop through to panic

 		else

 			{	// check the domain for unsigned 32-bit 

 			if (h==0)

 				{				// zero extend l gives aValue

 				c.SetL(l);	// in unsigned 32 bit range

 				return;

 				}

 			}	// invalid type, drop through to panic

 		}

 	Panic(EDbWrongType);

 	}

 /** Sets a TUint32, TUint16, TUint8 or Bit column value.

 @param aCol The column ordinal of the column to set.

 @param aValue The new column value. */

 EXPORT_C void RDbRowSet::SetColL(TDbColNo aCol,TUint32 aValue)

 	{

 	CDbCursor& cr=*iCursor;

 	TDbColType t=cr.ColumnType(aCol);

 	if (t<EDbColInt64)

 		{	// set any <= 32-bit integral type

 		if (IsUnsigned(t))

 			{

 			cr.Column(aCol).SetL(aValue);

 			return;

 			}

 		if (aValue<=TUint32(KMaxTInt))

 			{	// check the domain for signed columns

 			cr.Column(aCol).SetL(aValue);

 			return;

 			}

 		}

 	Panic(EDbWrongType);

 	}

 /** Sets a TReal32 column value.

 @param aCol The column ordinal of the column to set.

 @param aValue The new column value. */

 EXPORT_C void RDbRowSet::SetColL(TDbColNo aCol,TReal32 aValue) __SOFTFP

 	{

 	Column(aCol,EDbColReal32).SetL(aValue);

 	}

 /** Sets a TReal64 column value.

 @param aCol The column ordinal of the column to set.

 @param aValue The new column value. */

 EXPORT_C void RDbRowSet::SetColL(TDbColNo aCol,TReal64 aValue) __SOFTFP

 	{

 	Column(aCol,EDbColReal64).SetL(aValue);

 	}

 /** Sets a TTime column value.

 TTime could be either local time or universal time. 

 DBMS doesn't interpret the value of TTime, it is left up to the user to decide which should be used.

 @param aCol The column ordinal of the column to set.

 @param aValue The new column value. */

 EXPORT_C void RDbRowSet::SetColL(TDbColNo aCol,TTime aValue)

 	{

 	Column(aCol,EDbColDateTime).SetL(aValue);

 	}

 /** Sets a column value from an 8 bit descriptor. This function can also set the 

 value of Long columns.

 Usually this is used to set a Text8 or LongText8 column from a non-Unicode 

 text descriptor, but can be used for any column type: the data content is 

 validated when the row is PutL().

 @param aCol The column ordinal of the column to set.

 @param aValue The new column value. */

 EXPORT_C void RDbRowSet::SetColL(TDbColNo aCol,const TDesC8 &aValue)

 	{

 	CDbCursor& c=*iCursor;

 	if (IsLong(c.ColumnType(aCol)))

 		{

 		RDbColWriteStream strm;

 		strm.OpenLC(*this,aCol);

 		strm.WriteL(aValue);

 		strm.CommitL();

 		CleanupStack::PopAndDestroy();

 		}

 	else

 		c.Column(aCol).SetL(aValue);

 	}

 /** Set a column value from Unicode text.

 @param aCol The column ordinal of the column to set.

 @param aValue The new column value. */

 EXPORT_C void RDbRowSet::SetColL(TDbColNo aCol,const TDesC16 &aValue)

 	{

 	CDbCursor& c=*iCursor;

 	if (c.ColumnType(aCol)==EDbColLongText16)

 		{

 		RDbColWriteStream strm;

 		strm.OpenLC(*this,aCol);

 		strm.WriteL(aValue);

 		strm.CommitL();

 		CleanupStack::PopAndDestroy();

 		}

 	else

 		Column(aCol,EDbColText16).SetL(aValue);

 	}

 /** Searches through a rowset for a row which fulfils an SQL search-condition. 

 The search begins from the current position (which must be a valid row) and 

 proceeds forwards or backwards through the available rows until it finds a 

 match or runs out of rows.

 The cursor is positioned to the matching row (or beginning/end of set) on 

 return.

 This is a brute-force approach to finding a row using an index for key-based 

 retrieval on a Table rowset is a much faster but less flexible way of finding 

 rows.

 @param aDirection Specifies which direction to search after testing the current 

 row.

 @param aCriteria A query object containing an SQL search-condition to match 

 against.

 @return If no match is found KErrNotFound is returned. Otherwise the number 

 of rows navigated while finding a match, which may be 0 if the current row 

 matches. 

 @capability Note For a secure shared database, the caller must satisfy the read

             access policy for the table.

 */

 EXPORT_C TInt RDbRowSet::FindL(TDirection aDirection,TDbQuery aCriteria)

 	{

 	return iCursor->FindL(aDirection,aCriteria);

 	}

 /** Tests whether the current row in the rowset matches a previously compiled row 

 constraint. The rowset must not currently be updating or inserting a row.

 @param aConstraint A row constraint object which must have been previously 

 opened on this rowset object.

 @return ETrue if the current row fulfils the constraint, otherwise EFalse. 

 @capability Note For a secure shared database, the caller must satisfy the read

             access policy for the table.

 */

 EXPORT_C TBool RDbRowSet::MatchL(const RDbRowConstraint& aConstraint)

 	{

 	return iCursor->MatchL(*aConstraint.iConstraint);

 	}

 // Class RDbRowConstraint

 /** Compiles the specified SQL search-condition for matching against rows in the 

 specified rowset. The text comparison supplied in aCriteria is used for all 

 text columns in the constraint.

 @param aView The rowset to which the constraint will apply.

 @param aCriteria The SQL string and the text comparison mode for the constraint.

 @return KErrNone, if successful, otherwise one of the system-wide error codes. 

 Specifically:KErrNotFound if a column name in the SQL query does not exist.KErrArgument 

 if Invalid or unrecognised SQL syntax was used.KErrGeneral for a column type 

 mismatch in a predicate in the SQL query or if a date-literal in the SQL query 

 was invalid.KErrOverflow if a number-literal in the SQL query for an integral 

 column was too large (did not fit in a 32-bit integral representation). This 

 can also be one of the DBMS database error codes. 

 @capability Note For a secure shared database, the caller must satisfy the read

             access policy for the table.

 */

 EXPORT_C TInt RDbRowConstraint::Open(const RDbRowSet& aView,TDbQuery aCriteria)

 	{

 	TRAPD(r,iConstraint=aView.iCursor->ConstraintL(aCriteria));

 	return r;

 	}

 /** Releases the resources used by the constraint before discarding the constraint 

 object. */

 EXPORT_C void RDbRowConstraint::Close()

 	{

 	iConstraint.Close();

 	}

 // Class RDbColReadStream

 /** Opens the column with the specified ordinal in the specified current row in 

 the rowset. The row must have previously been read into the rowset using RDbRowSet::GetL().

 @param aView The rowset which has the row and column to be read.

 @param aCol The column ordinal of the column to be read 

 @capability Note For a secure shared database, the caller must satisfy the read

             access policy for the table.

 */

 EXPORT_C void RDbColReadStream::OpenL(const RDbRowSet& aView,TDbColNo aCol)

 	{

 	Attach(aView.ColSourceL(aCol));

 	}

 /** Opens the column with the specified ordinal in the specified current row in 

 the rowset and puts a pointer to the column on the cleanup stack.

 The row must have previously been read into the rowset using RDbRowSet::GetL().

 @param aView The rowset which has the row and column to be read.

 @param aCol The column ordinal of the column to be read. 

 @capability Note For a secure shared database, the caller must satisfy the read

             access policy for the table.

 */

 EXPORT_C void RDbColReadStream::OpenLC(const RDbRowSet& aView,TDbColNo aCol)

 	{

 	OpenL(aView,aCol);

 	PushL();

 	}

 // Class RDbColWriteStream

 /** Opens the column with the specified ordinal in the current row, and in the 

 specified rowset, and prepares the column for being written or replaced. The 

 rowset must be updating or inserting a row.

 @param aView The rowset which has the row and column to be written.

 @param aCol The column ordinal of the column to be written. 

 @capability Note For a secure shared database, the caller must satisfy the write

             access policy for the table.

 */

 EXPORT_C void RDbColWriteStream::OpenL(RDbRowSet& aView,TDbColNo aCol)

 	{

 	Attach(aView.ColSinkL(aCol));

 	}

 /** Opens the column with the specified ordinal in the current row, and in the 

 specified rowset, and prepares the column for being written or replaced, putting 

 a cleanup item for this object onto the cleanup stack. The rowset must be 

 updating or inserting a row. 

 Placing the cleanup object on the cleanup stack allows allocated resources 

 to be cleaned up if a subsequent leave occurs.

 @param aView The rowset which has the row and column to be written.

 @param aCol The column ordinal of the column to be written. 

 @capability Note For a secure shared database, the caller must satisfy the write

             access policy for the table.

 */

 EXPORT_C void RDbColWriteStream::OpenLC(RDbRowSet& aView,TDbColNo aCol)

 	{

 	OpenL(aView,aCol);

 	PushL();

 	}

 // Class TDbWindow

 /** Constructs this object with the preferred shape. When fully evaluated, the 

 view will try to have aForeSlots rows immediately available for navigation 

 forwards, and aRearSlots rows immediately available for navigation backwards.

 @param aForeSlots The number of rows to evaluate ahead of the current row.

 @param aRearSlots The number of rows to evaluate behind the current row. */

 EXPORT_C TDbWindow::TDbWindow(TInt aForeSlots,TInt aRearSlots)

 	: iSize(aForeSlots+aRearSlots+1), iPreferredPos(aRearSlots)

 	{

 	__ASSERT_ALWAYS(aForeSlots>=0 && aRearSlots>=0,Panic(EDbInvalidViewWindowParameters));

 	}

 // Class RDbView

 /** Prepares the view object for evaluating an SQL select-statement.

 Following preparation, the rowset object can always provide schema information, 

 but the view may first require evaluation to generate the rowset for navigation.

 @param aDatabase The database on which to execute the query.

 @param aQuery The SQL query and the text comparison mode for the constraint.

 @param anAccess The access specification for the rowset. By default, updatable 

 access is given.

 @return KErrNone, if successful, otherwise one of the other system-wide error 

 codes. Specifically: KErrNotFound if The table does not exist in the database 

 or a column name in the SQL query does not exist.KErrNotSupported if a sort-specification 

 in the SQL query cannot be provided by an index.KErrArgument if an invalid 

 or unrecognised SQL syntax was used.KErrGeneral if there is a column type 

 mismatch in a predicate in the SQL query or if a date-literal in the SQL query 

 was invalid.KErrOverflow if a number-literal in the SQL query for an integral 

 column was too large (did not fit in a 32-bit integral representation). This 

 can also be one of the DBMS database error codes.. 

 @capability Note For a secure shared database, the caller must satisfy the read

             access policy for the table.

 */

 EXPORT_C TInt RDbView::Prepare(RDbDatabase& aDatabase,const TDbQuery& aQuery,TAccess anAccess)

 	{

 	return Prepare(aDatabase,aQuery,TDbWindow(),anAccess);

 	}

 /** Prepares the view object for evaluating an SQL select-statement and specifies 

 the evaluation window shape for the rowset.

 The function does not specify the access specification for the rowset

 updatable access is given.

 Following preparation, the rowset object can always provide schema information, 

 but the view may first require evaluation to generate the rowset for navigation.

 @param aDatabase The database on which to execute the query.

 @param aQuery The SQL query and the text comparison mode for the constraint.

 @param aWindow The desired evaluation window shape for the rowset. If this 

 parameter is omitted, an alternative overload is called e.g. no pre-evaluation 

 window is requested.

 @return KErrNone, if successful, otherwise one of the other system-wide error 

 codes. Specifically: KErrNotFound if The table does not exist in the database 

 or a column name in the SQL query does not exist.KErrNotSupported if a sort-specification 

 in the SQL query cannot be provided by an index.KErrArgument if an invalid 

 or unrecognised SQL syntax was used.KErrGeneral if there is a column type 

 mismatch in a predicate in the SQL query or if a date-literal in the SQL query 

 was invalid.KErrOverflow if a number-literal in the SQL query for an integral 

 column was too large (did not fit in a 32-bit integral representation). This 

 can also be one of the DBMS database error codes. 

 @capability Note For a secure shared database, the caller must satisfy the read

             access policy for the table.

 */

 EXPORT_C TInt RDbView::Prepare(RDbDatabase& aDatabase,const TDbQuery& aQuery,const TDbWindow& aWindow)

 	{

 	return Prepare(aDatabase,aQuery,aWindow,EUpdatable);

 	}

 /** Prepares the view object for evaluating an SQL select-statement, specifies 

 the evaluation window shape for the rowset, and sets the access specification 

 for the rowset.

 Following preparation, the rowset object can always provide schema information, 

 but the view may first require evaluation to generate the rowset for navigation.

 @param aDatabase The database on which to execute the query.

 @param aQuery The SQL query and the text comparison mode for the constraint.

 @param aWindow The desired evaluation window shape for the rowset. If this 

 parameter is omitted, an alternative overload is called e.g. no pre-evaluation 

 window is requested.

 @param anAccess The access specification for the rowset. If omitted, updatable 

 access is given.

 @return KErrNone, if successful, otherwise one of the other system-wide error 

 codes. Specifically:KErrNotFound if The table does not exist in the database 

 or a column name in the SQL query does not exist.KErrNotSupported if a sort-specification 

 in the SQL query cannot be provided by an index.KErrArgument if an invalid 

 or unrecognised SQL syntax was used.KErrGeneral if there is a column type 

 mismatch in a predicate in the SQL query or if a date-literal in the SQL query 

 was invalid.KErrOverflow if a number-literal in the SQL query for an integral 

 column was too large (did not fit in a 32-bit integral representation). This 

 can also be one of the DBMS database error codes. 

 @capability Note For a secure shared database, the caller must satisfy the read

             access policy for the table.

 */

 EXPORT_C TInt RDbView::Prepare(RDbDatabase& aDatabase,const TDbQuery& aQuery,const TDbWindow& aWindow,TAccess anAccess)

 	{

 	TRAPD(r,iCursor=aDatabase.iDatabase->ViewL(aQuery,aWindow,anAccess));

 	return r;

 	}

 /** Use this function to fully evaluate the view. It is equivalent to:

 while (Unevaluated()) { Evaluate(); }

 @return KErrNone, if successful, otherwise one of the system wide error codes. */

 EXPORT_C TInt RDbView::EvaluateAll()

 	{

 	TInt r;

 	do r=Evaluate(); while (r>0);

 	return r;

 	}

 /** Performs a single step of the view evaluation, and returns when the step is 

 complete. To completely evaluate a view in one go, EvaluateAll() should be 

 used.

 @return 0, evaluation is complete.> 0, more evaluation can be done. < 0, an 

 error code, see the class overview for more information. */

 EXPORT_C TInt RDbView::Evaluate()

 	{

 	return iCursor->Evaluate();

 	}

 /** Performs a single step of the view evaluation, returning immediately and signalling 

 when the step is complete.

 This function is most effectively used when the view evaluation is carried 

 out from an active object. 

 @param aStatus The request status used to contain completion information for 

 the function. On completion, the status value should be interpreted as follows: 

 0, evaluation is complete.> 0, more evaluation can be done. < 0, an error 

 code, see the class overview for more information. */

 EXPORT_C void RDbView::Evaluate(TRequestStatus& aStatus)

 	{

 	iCursor->Evaluate(aStatus);

 	}

 /** Tests whether any more evaluation can be done to a view.

 @return ETrue, if the view can be further evaluated; EFalse, if evaluation will 

 have no effect. */

 EXPORT_C TBool RDbView::Unevaluated() const

 	{

 	return iCursor->Unevaluated();

 	}

 // Class RDbTable

 /** Opens the named table object on a database with the specified access.

 If successful, the rowset is positioned to the beginning.

 @param aDatabase The database on which to open the table.

 @param aName The name of the table to open.

 @param anAccess The access specification for the rowset, the default is updatable 

 access.

 @return KErrNone, if successful, otherwise one of the system-wide error codes. 

 Specifically:KErrNotFound if the table does not exist in the database.KErrAccessDenied 

 if an incremental operation is in progress. This can also be one of the DBMS 

 database error codes. 

 @capability Note For a secure shared database, the caller must satisfy either the read

             or the write access policy for the table.

 */

 EXPORT_C TInt RDbTable::Open(RDbDatabase &aDatabase,const TDesC &aName,TAccess anAccess)

 	{

 	TRAPD(r,iCursor=aDatabase.iDatabase->TableL(aName,anAccess));

 	return r;

 	}

 /** Sets the specified index as the active index for this table. The rows will 

 be presented in index order, and this index key will be used for lookup by 

 the SeekL() function.

 If successful, the rowset is reset to the beginning.

 @param anIndex The name of the index to activate.

 @return KErrNone, if successful, otherwise one of the system-wide error codes. 

 Specifically:KErrWrite if the table was created with insert-only access.KErrNotFound 

 if the index does not exist on the table. This can also be one of the DBMS 

 database error codes. 

 @capability Note For a secure shared database, the caller must satisfy the read

             access policy for the table.

 */

 EXPORT_C TInt RDbTable::SetIndex(const TDesC* anIndex)

 	{

 	TRAPD(r,iCursor->SetIndexL(anIndex));

 	return r;

 	}

 /** Finds a row in a table based on a key in the active index.

 This function cannot be called while the rowset is currently updating or inserting 

 a row. The currently active index on the table must have a key definition 

 which matches the types in the key value.

 Less columns can be added to the key than are present in the index definition: 

 the keys will only be compared up to the columns present further columns 

 in the index are not considered.

 If successful the cursor is positioned to the row which was found, otherwise 

 the cursor is left on an invalid row.

 The underlying Store database can leave with KErrWrite, if the table was created 

 with insert-only access.

 The function can also leave with one of the DBMS database error codes.

 @param aKey The key value to lookup in the index.

 @param aComparison The comparison operation for the lookup, the default is 

 to look for an exact match (EEqualTo).

 @return ETrue if a row which compares correctly with the key exists, EFalse if 

 not. 

 @capability Note For a secure shared database, the caller must satisfy the read

             access policy for the table.

 */

 EXPORT_C TBool RDbTable::SeekL(const TDbSeekKey& aKey,TComparison aComparison)

 	{

 	__ASSERT_ALWAYS(aKey.iKey.Count()>0,Panic(EDbNoColumnsInSeekKey));

 	return iCursor->SeekL(aKey.iKey,aComparison);

 	}

 // Class CDbCursor

 //

 // Default implementation in terms of ColumnDef. Might be inefficient

 //

 EXPORT_C void CDbCursor::ColumnsL(CDbColSet& aColSet)

 	{

 	TDbCol col;

 	TDbColNo max=ColumnCount();

 	for (TDbColNo ii=0;++ii<=max;)

 		{

 		ColumnDef(col,ii);

 		aColSet.AddL(col);

 		}

 	}

 //

 // Default implementation in terms of navigation

 // Faster counting may be possible

 //

 EXPORT_C TInt CDbCursor::CountL(RDbRowSet::TAccuracy)

 	{

 	TDbBookmark::TMark mark;

 	Bookmark(mark);

 	GotoL(RDbRowSet::EBeginning);

 	TInt count=0;

 	while (GotoL(RDbRowSet::ENext))

 		++count;

 	GotoL(mark);

 	return count;

 	}

 //

 //  Default implementation in terms of constraints

 //

 EXPORT_C TInt CDbCursor::FindL(RDbRowSet::TDirection aDirection,const TDbQuery& aCriteria)

 	{

 	CDbRowConstraint* constraint=ConstraintL(aCriteria);

 	constraint->PushL();

 	RDbRowSet::TPosition next=aDirection==RDbRowSet::EForwards ? RDbRowSet::ENext : RDbRowSet::EPrevious;

 	TInt skip=0;

 	do

 		{

 		if (MatchL(*constraint))

 			{

 			CleanupStack::PopAndDestroy();	// constraint

 			return skip;

 			}

 		++skip;

 		} while (GotoL(next));

 	CleanupStack::PopAndDestroy();

 	return KErrNotFound;

 	}

 TInt CDbCursor::Evaluate()

 	{

 	TRAPD(r,r=EvaluateL());

 	return r;

 	}

 CDbRowConstraint* CDbCursor::ConstraintL(const TDbQuery& aQuery)

 	{

 	return AttachContext(this,OpenConstraintL(aQuery));

 	}

 //

 // Reserved for future development

 //

 EXPORT_C void CDbCursor::Reserved_1()

 	{

 	}

 //

 // Reserved for future development

 //

 EXPORT_C void CDbCursor::Reserved_2()

 	{

 	}