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