// 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