persistentstorage/sql/TEST/t_sqllang.cpp
changeset 0 08ec8eefde2f
child 55 44f437012c90
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/persistentstorage/sql/TEST/t_sqllang.cpp	Fri Jan 22 11:06:30 2010 +0200
@@ -0,0 +1,1069 @@
+// Copyright (c) 2005-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 <e32test.h>
+#include <e32math.h>
+#include <bautils.h>
+#include <sqldb.h>
+
+///////////////////////////////////////////////////////////////////////////////////////
+
+RTest TheTest(_L("t_sqllang test"));
+_LIT(KTestDir, "c:\\test\\");
+
+_LIT(KTestDbName, "c:\\test\\t_sqllang_1.db");
+_LIT(KTestDbName2, "c:\\test\\t_sqllang_2.db");
+
+RSqlDatabase TheDb;
+
+///////////////////////////////////////////////////////////////////////////////////////
+
+void DeleteTestFiles()
+	{
+	RSqlDatabase::Delete(KTestDbName2);
+	RSqlDatabase::Delete(KTestDbName);
+	}
+
+///////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////
+//Test macros and functions
+void Check(TInt aValue, TInt aLine)
+	{
+	if(!aValue)
+		{
+		DeleteTestFiles();
+		TheTest(EFalse, aLine);
+		}
+	}
+void Check(TInt aValue, TInt aExpected, TInt aLine)
+	{
+	if(aValue != aExpected)
+		{
+		DeleteTestFiles();
+		RDebug::Print(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);
+		TheTest(EFalse, aLine);
+		}
+	}
+void Check2(TInt64 aValue, TInt64 aExpected, TInt aLine)
+	{
+	if(aValue != aExpected)
+		{
+		DeleteTestFiles();
+		RDebug::Print(_L("*** Expected error: %ld, got: %ld\r\n"), aExpected, aValue);
+		TheTest(EFalse, aLine);
+		}
+	}
+#define TEST(arg) ::Check((arg), __LINE__)
+#define TEST2(aValue, aExpected) ::Check(aValue, aExpected, __LINE__)
+#define TEST3(aValue, aExpected) ::Check2(aValue, aExpected, __LINE__)
+
+///////////////////////////////////////////////////////////////////////////////////////
+
+void CreateTestDir()
+    {
+    RFs fs;
+	TInt err = fs.Connect();
+	TEST2(err, KErrNone);
+
+	err = fs.MkDir(KTestDir);
+	TEST(err == KErrNone || err == KErrAlreadyExists);
+	
+	fs.Close();
+	}
+	
+///////////////////////////////////////////////////////////////////////////////////////
+
+void PrintLastMsgIfError(TInt aErr)
+	{
+	if(aErr < 0 && SqlRetCodeClass(aErr) == ESqlDbError)
+		{
+		const TPtrC& msg = TheDb.LastErrorMessage();
+		RDebug::Print(_L("Last error msg: \"%S\"\r\n"), &msg);	
+		}
+	}
+
+/**
+@SYMTestCaseID			SYSLIB-SQL-CT-1611
+@SYMTestCaseDesc		Create a table with INTEGER, SMALLINT, REAl, DOUBLE PRECISION, FLOAT, DECIMAL,...
+						columns. Insert some records, retrieve the column values, verify the column values,
+						try some mathematical operations with the column values, executed in the SQL
+						statement.
+@SYMTestPriority		High
+@SYMTestActions			Testing SQL engine behaviour with different numerical types. 
+						Testing mathematical operations with numeric columns.
+@SYMTestExpectedResults Test must not fail
+@SYMREQ					REQ5792
+                        REQ5793
+*/	
+void NumericDataTypesTest()
+	{
+	TEST2(TheDb.Create(KTestDbName), KErrNone);
+	
+	//Create a table with all possible numeric field types
+	_LIT8(KSql1, "CREATE TABLE Tbl(A INTEGER, B SMALLINT, C REAL, D DOUBLE PRECISION, E FLOAT, \
+					                    F DECIMAL, G BIGINT, H TINYINT, I BIT, J NUMERIC, K MONEY, \
+					                    L SMALLMONEY)");
+	TInt err = TheDb.Exec(KSql1);
+	PrintLastMsgIfError(err);
+	TEST(err >= 0);
+	//Insert one record in to the created table
+	_LIT8(KSql2, "INSERT INTO Tbl(A,B,C,D,E,F,G,H,I,J,K,L) VALUES(2000000000, 30000, 123.45, 0.912E+55,\
+	                                    1.34E-14, 1234.5678, 32000000000, 100, 7, 23.123456, 2123678.56, 11.45)");
+	err = TheDb.Exec(KSql2);
+	PrintLastMsgIfError(err);
+	TEST2(err, 1);
+	//Get the inserted record data
+	RSqlStatement stmt;
+	err = stmt.Prepare(TheDb, _L("SELECT * FROM TBL"));
+	PrintLastMsgIfError(err);
+	TEST2(err, KErrNone);
+	err = stmt.Next();
+	PrintLastMsgIfError(err);
+	TEST2(err, KSqlAtRow);
+	//Check column values
+	TEST(stmt.ColumnInt(stmt.ColumnIndex(_L("a"))) == 2000000000);
+	TEST(stmt.ColumnInt(stmt.ColumnIndex(_L("b"))) == 30000);
+	TEST(Abs(stmt.ColumnReal(stmt.ColumnIndex(_L("c"))) - 123.45) < 0.000001);
+	//The next column value test is not working! The extracted column value is 0.9120000000000002E+55
+	//I guess the reason is that SQLITE uses manifest typing and "DOUBLE PRECISION" is not in its keyword
+	//list. Maybe it is interpreted and stored as 4-byte float value.
+	//TEST(Abs(stmt.ColumnReal(stmt.ColumnIndex(_L("d"))) - 0.912E+55) < 0.000001);
+	TEST(Abs(stmt.ColumnReal(stmt.ColumnIndex(_L("e"))) - 1.34E-14) < 0.000001);
+	TEST(stmt.ColumnReal(stmt.ColumnIndex(_L("f"))) == 1234.5678);
+	TEST(stmt.ColumnInt64(stmt.ColumnIndex(_L("g"))) == 32000000000LL);
+	TEST(stmt.ColumnInt(stmt.ColumnIndex(_L("h"))) == 100);
+	TEST(stmt.ColumnInt(stmt.ColumnIndex(_L("i"))) == 7);
+	TEST(Abs(stmt.ColumnReal(stmt.ColumnIndex(_L("j"))) - 23.123456) < 0.000001);
+	TEST(Abs(stmt.ColumnReal(stmt.ColumnIndex(_L("k"))) - 2123678.56) < 0.000001);
+	TEST(Abs(stmt.ColumnReal(stmt.ColumnIndex(_L("l"))) - 11.45) < 0.000001);
+	stmt.Close();
+	//The statement object has to be closed before TheDb.Exec() call, 
+	//otherwise the reported error is "database table is locked"
+	//Insert second record in to the created table but inverse the column types!
+	_LIT8(KSql3, "INSERT INTO Tbl(A,   B,  C, D, E, F,  G,  H,  I,  J,K,L) VALUES(\
+										-2.5,1.1,12,23,45,111,5.6,7.9,1.1,2,6,7)");
+	err = TheDb.Exec(KSql3);
+	PrintLastMsgIfError(err);
+	TEST2(err, 1);
+	//Get the inserted record data
+	err = stmt.Prepare(TheDb, _L("SELECT * FROM TBL"));
+	PrintLastMsgIfError(err);
+	TEST2(err, KErrNone);
+	TEST2(stmt.Next(), KSqlAtRow);
+	err = stmt.Next();
+	PrintLastMsgIfError(err);
+	TEST2(err, KSqlAtRow);
+	//No column value checking because SQLITE inverted the column types!
+	//Check column values
+	TEST(Abs(stmt.ColumnReal(stmt.ColumnIndex(_L("a"))) - (-2.5)) < 0.000001);
+	TEST(Abs(stmt.ColumnReal(stmt.ColumnIndex(_L("b"))) - 1.1) < 0.000001);
+	TEST(stmt.ColumnInt(stmt.ColumnIndex(_L("c"))) == 12);
+	TEST(stmt.ColumnInt(stmt.ColumnIndex(_L("d"))) == 23);
+	TEST(stmt.ColumnInt(stmt.ColumnIndex(_L("e"))) == 45);
+	TEST(stmt.ColumnInt(stmt.ColumnIndex(_L("f"))) == 111);
+	TEST(Abs(stmt.ColumnReal(stmt.ColumnIndex(_L("g"))) - 5.6) < 0.000001);
+	TEST(Abs(stmt.ColumnReal(stmt.ColumnIndex(_L("h"))) - 7.9) < 0.000001);
+	TEST(Abs(stmt.ColumnReal(stmt.ColumnIndex(_L("i"))) - 1.1) < 0.000001);
+	TEST(stmt.ColumnInt(stmt.ColumnIndex(_L("j"))) == 2);
+	TEST(stmt.ColumnInt(stmt.ColumnIndex(_L("k"))) == 6);
+	TEST(stmt.ColumnInt(stmt.ColumnIndex(_L("l"))) == 7);
+	
+	stmt.Close();
+	//Insert third record in to the created table
+	_LIT8(KSql4, "INSERT INTO Tbl(A,B,C,     D,  E,  F,   G,  H,  I,J,     K,     L) VALUES(\
+	                                    2,3,123.45,1.5,2.5,1.56,320,100,7,23.123,212.56,11.45)");
+	err = TheDb.Exec(KSql4);
+	PrintLastMsgIfError(err);
+	TEST2(err, 1);
+	//Issue a "SELECT" statement doing there some arithmetic operations and comparisons on the column values.
+	err = stmt.Prepare(TheDb, _L("SELECT A, A-C AS A2, K + L AS A3, H*I AS A4, E/D AS A5 FROM TBL WHERE A > 0 AND A < 10"));
+	PrintLastMsgIfError(err);
+	TEST2(err, KErrNone);
+	TEST2(stmt.Next(), KSqlAtRow);
+	//Check column values
+	TEST2(stmt.ColumnInt(stmt.ColumnIndex(_L("a"))), 2);
+	TEST(Abs(stmt.ColumnReal(stmt.ColumnIndex(_L("a2"))) - (2-123.45)) < 0.000001);
+	TEST(Abs(stmt.ColumnReal(stmt.ColumnIndex(_L("a3"))) - (212.56+11.45)) < 0.000001);
+	TEST(stmt.ColumnInt(stmt.ColumnIndex(_L("a4"))) == 700);
+	TEST(Abs(stmt.ColumnReal(stmt.ColumnIndex(_L("a5"))) - (2.5/1.5)) < 0.000001);
+	//There should be no more records
+	TEST2(stmt.Next(), KSqlAtEnd);
+	stmt.Close();
+
+	TheDb.Close();
+	(void)RSqlDatabase::Delete(KTestDbName);
+	}
+
+/**
+@SYMTestCaseID			SYSLIB-SQL-CT-1630
+@SYMTestCaseDesc		Built-in functions test.
+						abs(), coalesce(), ifnull(), last_insert_rowid(), length(), like(), lower(),
+						max(), min(), nullif(), quote(), random(), round(), sqlite_version(), substr(),
+						typeof(), upper(), avg(), count(), sun().
+@SYMTestPriority		High
+@SYMTestActions			Built-in functions test.
+@SYMTestExpectedResults Test must not fail
+@SYMREQ					REQ5792
+                        REQ5793
+*/	
+void BuiltInFunctionsTest()
+	{
+	(void)RSqlDatabase::Delete(KTestDbName);
+	TInt err = TheDb.Create(KTestDbName);
+	TEST2(err, KErrNone);
+
+	_LIT(KCreateSql, "CREATE TABLE A(Id Integer, \
+									 F1 Integer DEFAULT 0, \
+									 F2 Integer Default NULL, \
+									 F3 TEXT Default Null, \
+									 F4 TEXT Default Null)");
+	err = TheDb.Exec(KCreateSql);
+	TEST(err >= 0);
+
+	_LIT(KInsertSql1, "INSERT INTO A(Id, F1) VALUES(1, 100)");
+	err = TheDb.Exec(KInsertSql1);
+	TEST2(err, 1);
+	
+	_LIT(KInsertSql2, "INSERT INTO A(Id, F1) VALUES(2, 1)");
+	err = TheDb.Exec(KInsertSql2);
+	TEST2(err, 1);
+
+	_LIT(KInsertSql3, "INSERT INTO A(Id, F3) VALUES(3, 'ABCD')");
+	err = TheDb.Exec(KInsertSql3);
+	TEST2(err, 1);
+
+	_LIT(KInsertSql4, "INSERT INTO A(Id, F4) VALUES(4, 'DCBA')");
+	err = TheDb.Exec(KInsertSql4);
+	TEST2(err, 1);
+
+	RSqlStatement stmt;
+	
+	//abs() test --------------------------------------------------------
+	err = stmt.Prepare(TheDb, _L("SELECT * FROM A WHERE F1 > ABS(-10)"));
+	TEST2(err, KErrNone);
+	err = stmt.Next();
+	TEST2(err, KSqlAtRow);
+	TEST(stmt.ColumnInt(1) == 100);
+	stmt.Close();
+
+	//coalesce() test --------------------------------------------------------
+	err = stmt.Prepare(TheDb, _L("SELECT COALESCE(F3, F4) AS F FROM A"));
+	TEST2(err, KErrNone);
+	
+	err = stmt.Next();
+	TEST2(err, KSqlAtRow);
+	TEST(stmt.IsNull(0));
+	
+	err = stmt.Next();
+	TEST2(err, KSqlAtRow);
+	TEST(stmt.IsNull(0));
+	
+	_LIT(KTextVal1, "ABCD");
+	err = stmt.Next();
+	TEST2(err, KSqlAtRow);
+	TPtrC colVal;
+	err = stmt.ColumnText(0, colVal);
+	TEST2(err, KErrNone);
+	TEST(colVal == KTextVal1);
+	
+	_LIT(KTextVal2, "DCBA");
+	err = stmt.Next();
+	TEST2(err, KSqlAtRow);
+	err = stmt.ColumnText(0, colVal);
+	TEST2(err, KErrNone);
+	TEST(colVal == KTextVal2);
+
+	stmt.Close();
+
+	//ifnull() test --------------------------------------------------------
+	err = stmt.Prepare(TheDb, _L("SELECT IFNULL(F3, F4) AS F FROM A"));
+	TEST2(err, KErrNone);
+	
+	err = stmt.Next();
+	TEST2(err, KSqlAtRow);
+	TEST(stmt.IsNull(0));
+	
+	err = stmt.Next();
+	TEST2(err, KSqlAtRow);
+	TEST(stmt.IsNull(0));
+	
+	err = stmt.Next();
+	TEST2(err, KSqlAtRow);
+	err = stmt.ColumnText(0, colVal);
+	TEST2(err, KErrNone);
+	TEST(colVal == KTextVal1);
+	
+	err = stmt.Next();
+	TEST2(err, KSqlAtRow);
+	err = stmt.ColumnText(0, colVal);
+	TEST2(err, KErrNone);
+	TEST(colVal == KTextVal2);
+
+	stmt.Close();
+
+	//last_insert_rowid() test --------------------------------------------------------
+	err = stmt.Prepare(TheDb, _L("SELECT last_insert_rowid() AS F"));
+	TEST2(err, KErrNone);
+	err = stmt.Next();
+	TEST2(err, KSqlAtRow);
+	TInt64 colVal64 = stmt.ColumnInt64(0);
+	RDebug::Print(_L("Last insert row id=%d\r\n"), (TInt)colVal64);
+	stmt.Close();
+
+	//length() test --------------------------------------------------------
+	err = stmt.Prepare(TheDb, _L("SELECT length(F4) AS L FROM A WHERE ID >= 3"));
+	TEST2(err, KErrNone);
+	
+	err = stmt.Next();
+	TEST2(err, KSqlAtRow);
+	TEST(stmt.ColumnInt(0) == 0);
+	
+	err = stmt.Next();
+	TEST2(err, KSqlAtRow);
+	TEST(stmt.ColumnInt(0) == 4);
+	
+	stmt.Close();
+
+	//like() test --------------------------------------------------------
+	err = stmt.Prepare(TheDb, _L("SELECT Id FROM A WHERE F4 LIKE 'DC%'"));
+	TEST2(err, KErrNone);
+	err = stmt.Next();
+	TEST2(err, KSqlAtRow);
+	TEST(stmt.ColumnInt(0) == 4);
+	stmt.Close();
+
+	_LIT(KInsertSql5, "INSERT INTO A(Id, F4) VALUES(5, 'ab%cd')");
+	err = TheDb.Exec(KInsertSql5);
+	TEST2(err, 1);
+	
+	err = stmt.Prepare(TheDb, _L("SELECT Id FROM A WHERE F4 LIKE 'ab/%cd' ESCAPE '/'"));
+	TEST2(err, KErrNone);
+	err = stmt.Next();
+	TEST2(err, KSqlAtRow);
+	TEST(stmt.ColumnInt(0) == 5);
+	stmt.Close();
+
+	err = stmt.Prepare(TheDb, _L8("SELECT Id FROM A WHERE F4 LIKE 'ab/%cd' ESCAPE '/'"));
+	TEST2(err, KErrNone);
+	err = stmt.Next();
+	TEST2(err, KSqlAtRow);
+	TEST(stmt.ColumnInt(0) == 5);
+	stmt.Close();
+
+	//lower() test --------------------------------------------------------
+	err = stmt.Prepare(TheDb, _L("SELECT LOWER(F3) FROM A WHERE F3 = 'ABCD'"));
+	TEST2(err, KErrNone);
+	err = stmt.Next();
+	TEST2(err, KSqlAtRow);
+	err = stmt.ColumnText(0, colVal);
+	TEST2(err, KErrNone);
+	_LIT(KTextVal3, "abcd");
+	TEST(colVal == KTextVal3);
+	stmt.Close();
+
+	//max() test --------------------------------------------------------
+	err = stmt.Prepare(TheDb, _L("SELECT MAX(F1) AS M FROM A"));
+	TEST2(err, KErrNone);
+	err = stmt.Next();
+	TEST2(err, KSqlAtRow);
+	TEST(stmt.ColumnInt(0) == 100);
+	stmt.Close();
+	
+	//min() test --------------------------------------------------------
+	err = stmt.Prepare(TheDb, _L("SELECT MIN(F1) AS M FROM A"));
+	TEST2(err, KErrNone);
+	err = stmt.Next();
+	TEST2(err, KSqlAtRow);
+	TEST(stmt.ColumnInt(0) == 0);
+	stmt.Close();
+
+	//nullif() test --------------------------------------------------------
+	err = stmt.Prepare(TheDb, _L("SELECT NULLIF(3, 4) AS M"));
+	TEST2(err, KErrNone);
+	err = stmt.Next();
+	TEST2(err, KSqlAtRow);
+	TEST(stmt.ColumnInt(0) == 3);
+	stmt.Close();
+	
+	err = stmt.Prepare(TheDb, _L("SELECT NULLIF(4, 4) AS M"));
+	TEST2(err, KErrNone);
+	err = stmt.Next();
+	TEST2(err, KSqlAtRow);
+	TEST(stmt.IsNull(0));
+	stmt.Close();
+	
+	//quote() test --------------------------------------------------------
+	err = stmt.Prepare(TheDb, _L("SELECT QUOTE(F4) AS M FROM A WHERE Id = 5"));
+	TEST2(err, KErrNone);
+	err = stmt.Next();
+	TEST2(err, KSqlAtRow);
+	err = stmt.ColumnText(0, colVal);
+	TEST2(err, KErrNone);
+	_LIT(KTextVal4, "'ab%cd'");
+	TEST(colVal == KTextVal4);
+	stmt.Close();
+
+	//random() test --------------------------------------------------------
+	err = stmt.Prepare(TheDb, _L("SELECT * FROM A WHERE Id > RANDOM(*)"));
+	TEST2(err, KErrNone);
+	stmt.Close();
+
+	//round() test --------------------------------------------------------
+	err = stmt.Prepare(TheDb, _L("SELECT ROUND(5.4) AS D"));
+	TEST2(err, KErrNone);
+	err = stmt.Next();
+	TEST2(err, KSqlAtRow);
+	TEST(Abs(stmt.ColumnReal(0) - 5.0) < 0.000001);
+	stmt.Close();
+
+	err = stmt.Prepare(TheDb, _L("SELECT ROUND(5.4321, 2) AS D"));
+	TEST2(err, KErrNone);
+	err = stmt.Next();
+	TEST2(err, KSqlAtRow);
+	TEST(Abs(stmt.ColumnReal(0) - 5.43) < 0.000001);
+	stmt.Close();
+
+	//sqlite_version() test --------------------------------------------------------
+	err = stmt.Prepare(TheDb, _L("SELECT sqlite_version(*) AS V"));
+	TEST2(err, KErrNone);
+	err = stmt.Next();
+	TEST2(err, KSqlAtRow);
+	err = stmt.ColumnText(0, colVal);
+	TEST2(err, KErrNone);
+	RDebug::Print(_L("Database engine version: \"%S\"\r\n"), &colVal);
+	stmt.Close();
+
+	//substr() test --------------------------------------------------------
+	err = stmt.Prepare(TheDb, _L("SELECT SUBSTR('abcd', 2, 2) AS S"));
+	TEST2(err, KErrNone);
+	err = stmt.Next();
+	TEST2(err, KSqlAtRow);
+	err = stmt.ColumnText(0, colVal);
+	TEST2(err, KErrNone);
+	_LIT(KTextVal7, "bc");
+	TEST(colVal == KTextVal7);
+	stmt.Close();
+
+	err = stmt.Prepare(TheDb, _L("SELECT SUBSTR('abcd', -3, 2) AS S"));
+	TEST2(err, KErrNone);
+	err = stmt.Next();
+	TEST2(err, KSqlAtRow);
+	err = stmt.ColumnText(0, colVal);
+	TEST2(err, KErrNone);
+	TEST(colVal == KTextVal7);
+	stmt.Close();
+
+	//typeof() test --------------------------------------------------------
+	_LIT(KInsertSql6, "INSERT INTO A(Id, F2) VALUES(6, 2)");
+	err = TheDb.Exec(KInsertSql6);
+	TEST2(err, 1);
+
+	err = stmt.Prepare(TheDb, _L("SELECT TYPEOF(F1 + F2) AS T FROM A WHERE ID > 4"));
+	TEST2(err, KErrNone);
+
+	err = stmt.Next();
+	TEST2(err, KSqlAtRow);
+	err = stmt.ColumnText(0, colVal);
+	TEST2(err, KErrNone);
+	_LIT(KTextVal8, "null");
+	TEST(colVal == KTextVal8);
+
+	err = stmt.Next();
+	TEST2(err, KSqlAtRow);
+	err = stmt.ColumnText(0, colVal);
+	TEST2(err, KErrNone);
+	_LIT(KTextVal9, "integer");
+	TEST(colVal == KTextVal9);
+	
+	stmt.Close();
+
+	//upper() test --------------------------------------------------------
+	err = stmt.Prepare(TheDb, _L("SELECT UPPER('ghjk') AS U"));
+	TEST2(err, KErrNone);
+	err = stmt.Next();
+	TEST2(err, KSqlAtRow);
+	err = stmt.ColumnText(0, colVal);
+	TEST2(err, KErrNone);
+	_LIT(KTextVal10, "GHJK");
+	TEST(colVal == KTextVal10);
+	stmt.Close();
+
+	//avg() test --------------------------------------------------------
+	err = stmt.Prepare(TheDb, _L("SELECT AVG(F2) AS F FROM A"));
+	TEST2(err, KErrNone);
+	err = stmt.Next();
+	TEST2(err, KSqlAtRow);
+	TEST(Abs(stmt.ColumnReal(0) - 2) < 0.000001);
+	stmt.Close();
+
+	//count() test --------------------------------------------------------
+	err = stmt.Prepare(TheDb, _L("SELECT COUNT(F2) AS F FROM A"));
+	TEST2(err, KErrNone);
+	err = stmt.Next();
+	TEST2(err, KSqlAtRow);
+	TEST(stmt.ColumnInt(0) == 1);
+	stmt.Close();
+
+	err = stmt.Prepare(TheDb, _L("SELECT COUNT(*) AS F FROM A"));
+	TEST2(err, KErrNone);
+	err = stmt.Next();
+	TEST2(err, KSqlAtRow);
+	TEST(stmt.ColumnInt(0) == 6);
+	stmt.Close();
+
+	//sum() test --------------------------------------------------------
+	err = stmt.Prepare(TheDb, _L("SELECT SUM(F2) AS S FROM A"));
+	TEST2(err, KErrNone);
+	err = stmt.Next();
+	TEST2(err, KSqlAtRow);
+	TEST(Abs(stmt.ColumnReal(0) - 2) < 0.000001);
+	stmt.Close();
+
+	// ----------------------------------
+	TheDb.Close();
+	(void)RSqlDatabase::Delete(KTestDbName);
+	}
+
+/**
+@SYMTestCaseID			SYSLIB-SQL-CT-1632
+@SYMTestCaseDesc		"ATTACH DATABASE" test.
+						The test creates two databases. The main database has 
+						Account(Id Integer, PersonId Integer, Value Integer) table.
+						The attached database has Person(Id Integer, Name TEXT) table.
+						The test inserts some records with a valid relation between them in both tables.
+						Then the test opens tha main database and attaches the second database to the first one.
+						The test prepares and executes SQL statement which retrieves column values from both
+						Account and Person tables. The test checks the column values.
+@SYMTestPriority		High
+@SYMTestActions			"ATTACH DATABASE" test.
+@SYMTestExpectedResults Test must not fail
+@SYMREQ					REQ5792
+                        REQ5793
+*/	
+void AttachDatabaseTest()
+	{
+	// ------------------------------------------------------------
+	RSqlDatabase db2;
+	TInt err = db2.Create(KTestDbName2);
+	TEST2(err, KErrNone);
+	
+	err = db2.Exec(_L("CREATE TABLE Person(Id Integer, Name TEXT)"));
+	TEST(err >= 0);
+
+	err = db2.Exec(_L("INSERT INTO Person(Id, Name) VALUES(1, 'A')"));
+	TEST2(err, 1);
+
+	err = db2.Exec(_L("INSERT INTO Person(Id, Name) VALUES(2, 'B')"));
+	TEST2(err, 1);
+
+	err = db2.Exec(_L("INSERT INTO Person(Id, Name) VALUES(3, 'C')"));
+	TEST2(err, 1);
+	
+	db2.Close();
+
+	// ------------------------------------------------------------
+	(void)RSqlDatabase::Delete(KTestDbName);
+	err = TheDb.Create(KTestDbName);
+	TEST2(err, KErrNone);
+
+	err = TheDb.Exec(_L("CREATE TABLE Account(Id Integer, PersonId Integer, Value Integer)"));
+	TEST(err >= 0);
+
+	err = TheDb.Exec(_L("INSERT INTO ACCOUNT(Id, PersonId, Value) VALUES(1, 2, 20)"));
+	TEST2(err, 1);
+
+	err = TheDb.Exec(_L("INSERT INTO ACCOUNT(Id, PersonId, Value) VALUES(2, 1, 10)"));
+	TEST2(err, 1);
+
+	err = TheDb.Exec(_L("INSERT INTO ACCOUNT(Id, PersonId, Value) VALUES(3, 2, 25)"));
+	TEST2(err, 1);
+
+	err = TheDb.Exec(_L("INSERT INTO ACCOUNT(Id, PersonId, Value) VALUES(4, 3, 30)"));
+	TEST2(err, 1);
+
+	TheDb.Close();
+	
+	// ------------------------------------------------------------
+	err = TheDb.Open(KTestDbName);	
+	TEST2(err, KErrNone);
+	
+	TBuf<100> sql;
+	sql.Copy(_L("ATTACH DATABASE '"));
+	sql.Append(KTestDbName2);
+	sql.Append(_L("' AS DB2"));
+	err = TheDb.Exec(sql);
+	TEST(err >= 0);
+	
+	RSqlStatement stmt;
+	err = stmt.Prepare(TheDb, _L("SELECT Account.Value, DB2.Person.Name FROM Account, DB2.Person \
+						   		  WHERE Account.PersonId = DB2.Person.Id"));
+	TEST2(err, KErrNone);
+
+	TPtrC personName;
+	_LIT(KName1, "A");
+	_LIT(KName2, "B");
+	_LIT(KName3, "C");
+
+	err = stmt.Next();
+	TEST2(err, KSqlAtRow);
+	err = stmt.ColumnText(1, personName);
+	TEST2(err, KErrNone);
+	TEST(personName == KName2);
+	TEST(stmt.ColumnInt(0) == 20);
+	
+	err = stmt.Next();
+	TEST2(err, KSqlAtRow);
+	err = stmt.ColumnText(1, personName);
+	TEST2(err, KErrNone);
+	TEST(personName == KName1);
+	TEST(stmt.ColumnInt(0) == 10);
+		
+	err = stmt.Next();
+	TEST2(err, KSqlAtRow);
+	err = stmt.ColumnText(1, personName);
+	TEST2(err, KErrNone);
+	TEST(personName == KName2);
+	TEST(stmt.ColumnInt(0) == 25);
+
+	err = stmt.Next();
+	TEST2(err, KSqlAtRow);
+	err = stmt.ColumnText(1, personName);
+	TEST2(err, KErrNone);
+	TEST(personName == KName3);
+	TEST(stmt.ColumnInt(0) == 30);
+		
+	stmt.Close();
+	
+	err = TheDb.Exec(_L("DETACH DATABASE DB2"));
+	TEST(err >= 0);
+		
+	// ------------------------------------------------------------
+	TheDb.Close();
+	(void)RSqlDatabase::Delete(KTestDbName2);
+	(void)RSqlDatabase::Delete(KTestDbName);
+	}
+	
+/**
+@SYMTestCaseID			SYSLIB-SQL-UT-3502
+@SYMTestCaseDesc		Test for DEF109100: SQL, code coverage for TSqlBufRIterator is very low.
+						The test creates a test table with INT32, INT64, DOUBLE, TEXT, and BINARY columns
+						and inserts couple of records there. Then the test prepares a SELECT statement,
+						retrieves all table rows, and to retrieve each column value, calls RSqlStatement::ColumnInt().
+						The column values are carefully chosen, so some of the ColumnInt() calls have to round
+						or clamp the returned value. 
+						Summary: the test checks the ColumnInt() behaviour when the column value type is not INT32 and
+								 when the column value is too big or too small and cannot fit in 32 bits.
+@SYMTestPriority		High
+@SYMTestActions			Test for DEF109100: SQL, code coverage for TSqlBufRIterator is very low.
+@SYMTestExpectedResults Test must not fail
+@SYMDEF					DEF109100
+*/	
+void ColumnIntTest()
+	{
+	(void)RSqlDatabase::Delete(KTestDbName);
+	TInt err = TheDb.Create(KTestDbName);
+	TEST2(err, KErrNone);
+	err = TheDb.Exec(_L("CREATE TABLE A(I32 INTEGER,I64 INTEGER,D DOUBLE,T TEXT,B BINARY)"));
+	TEST(err >= 0);
+	
+	err = TheDb.Exec(_L("INSERT INTO A VALUES(-5,-5000000000,-10000000000.0,'AAA',x'1122FF')"));
+	TEST2(err, 1);
+	err = TheDb.Exec(_L("INSERT INTO A VALUES(5,5000000000,10000000000.0,NULL,NULL)"));
+	TEST2(err, 1);
+	err = TheDb.Exec(_L("INSERT INTO A VALUES(5,2000000000,1000000000.0,NULL,NULL)"));
+	TEST2(err, 1);
+	err = TheDb.Exec(_L("INSERT INTO A VALUES(NULL,NULL,1.1234567890123456E+317,NULL,NULL)"));
+	TEST2(err, 1);
+
+	RSqlStatement stmt;
+	err = stmt.Prepare(TheDb, _L("SELECT I32,I64,D,T,B FROM A"));
+	TEST2(err, KErrNone);
+	
+	err = stmt.Next();
+	TEST2(err, KSqlAtRow);
+	TInt val = stmt.ColumnInt(0);	
+	TEST2(val, -5);					//"-5" is a 32-bit integer value
+	val = stmt.ColumnInt(1);
+	TEST2(val, KMinTInt);			//"-5000000000" is a 64-bit integer, will be clamped to KMinTInt
+	val = stmt.ColumnInt(2);
+	TEST2(val, KMinTInt);			//"-10000000000.0" is a 64-bit double, will be rounded to the nearest 32-bit integer
+	val = stmt.ColumnInt(3);
+	TEST2(val, 0);					//"AAA" is a text string, cannot be converted to a 32-bit integer
+	val = stmt.ColumnInt(4);
+	TEST2(val, 0);					//"1122FF" is a hex binary, cannot be converted to a 32-bit integer
+
+	err = stmt.Next();
+	TEST2(err, KSqlAtRow);
+	val = stmt.ColumnInt(0);	
+	TEST2(val, 5);					//"5" is a 32-bit integer value
+	val = stmt.ColumnInt(1);
+	TEST2(val, KMaxTInt);			//"5000000000" is a 64-bit integer, will be clamped to KMaxTInt
+	val = stmt.ColumnInt(2);
+	TEST2(val, KMaxTInt);			//"10000000000.0" is a 64-bit double, will be rounded to the nearest 32-bit integer
+	val = stmt.ColumnInt(3);
+	TEST2(val, 0);					//NULL column value
+	val = stmt.ColumnInt(4);
+	TEST2(val, 0);					//NULL column value
+
+	err = stmt.Next();
+	TEST2(err, KSqlAtRow);
+	val = stmt.ColumnInt(0);	
+	TEST2(val, 5);					
+	val = stmt.ColumnInt(1);
+	TEST2(val, 2000000000);					
+	val = stmt.ColumnInt(2);
+	TEST2(val, 1000000000);					
+	
+	err = stmt.Next();
+	TEST2(err, KSqlAtRow);
+	val = stmt.ColumnInt(2);
+	TEST2(val, KMinTInt);			//"1.1234567890123456E+317" is too big and cannot fit in a 64-bit double
+	
+	stmt.Close();
+	
+	TheDb.Close();
+	err = RSqlDatabase::Delete(KTestDbName);
+	TEST2(err, KErrNone);
+	}
+
+/**
+@SYMTestCaseID			SYSLIB-SQL-UT-3503
+@SYMTestCaseDesc		Test for DEF109100: SQL, code coverage for TSqlBufRIterator is very low.
+						The test creates a test table with INT32, INT64, DOUBLE, TEXT, and BINARY columns
+						and inserts couple of records there. Then the test prepares a SELECT statement,
+						retrieves all table rows, and to retrieve each column value, calls RSqlStatement::ColumnInt64().
+						The column values are carefully chosen, so some of the ColumnInt64() calls have to round
+						or clamp the returned value. 
+						Summary: the test checks the ColumnInt64() behaviour when the column value type is not INT64 and
+								 when the column value is too big or too small and cannot be presented as 64-bits integer.
+@SYMTestPriority		High
+@SYMTestActions			Test for DEF109100: SQL, code coverage for TSqlBufRIterator is very low.
+@SYMTestExpectedResults Test must not fail
+@SYMDEF					DEF109100
+*/	
+void ColumnInt64Test()
+	{
+	(void)RSqlDatabase::Delete(KTestDbName);
+	TInt err = TheDb.Create(KTestDbName);
+	TEST2(err, KErrNone);
+	err = TheDb.Exec(_L("CREATE TABLE A(I32 INTEGER,I64 INTEGER,D DOUBLE,T TEXT,B BINARY)"));
+	TEST(err >= 0);
+	
+	err = TheDb.Exec(_L("INSERT INTO A VALUES(-5,-5000000000,-10000000000.0,'AAA',x'1122FF')"));
+	TEST2(err, 1);
+	err = TheDb.Exec(_L("INSERT INTO A VALUES(5,5000000000,10000000000.0,NULL,NULL)"));
+	TEST2(err, 1);
+	err = TheDb.Exec(_L("INSERT INTO A VALUES(5,2000000000,1000000000.0,NULL,NULL)"));
+	TEST2(err, 1);
+	err = TheDb.Exec(_L("INSERT INTO A VALUES(NULL,NULL,1.1234567890123456E+317,NULL,NULL)"));
+	TEST2(err, 1);
+
+	RSqlStatement stmt;
+	err = stmt.Prepare(TheDb, _L("SELECT I32,I64,D,T,B FROM A"));
+	TEST2(err, KErrNone);
+	
+	err = stmt.Next();
+	TEST2(err, KSqlAtRow);
+	TInt64 val = stmt.ColumnInt64(0);	
+	TEST3(val, -5);					//"-5" is a 32-bit integer value
+	val = stmt.ColumnInt64(1);
+	TEST3(val, -5000000000LL);		//"-5000000000" is a 64-bit integer
+	val = stmt.ColumnInt64(2);
+	TEST3(val, -10000000000LL);		//"-10000000000.0" is a 64-bit double, will be rounded to the nearest 64-bit integer
+	val = stmt.ColumnInt64(3);
+	TEST3(val, 0);					//"AAA" is a text string, cannot be converted to a 64-bit integer
+	val = stmt.ColumnInt64(4);
+	TEST3(val, 0);					//"1122FF" is a hex binary, cannot be converted to a 64-bit integer
+
+	err = stmt.Next();
+	TEST2(err, KSqlAtRow);
+	val = stmt.ColumnInt64(0);	
+	TEST3(val, 5);					//"5" is a 32-bit integer value
+	val = stmt.ColumnInt64(1);
+	TEST3(val, 5000000000LL);		//"5000000000" is a 64-bit integer
+	val = stmt.ColumnInt64(2);
+	TEST3(val, 10000000000LL);		//"10000000000.0" is a 64-bit double, will be rounded to the nearest 64-bit integer
+	val = stmt.ColumnInt64(3);
+	TEST3(val, 0);					//NULL column value
+	val = stmt.ColumnInt64(4);
+	TEST3(val, 0);					//NULL column value
+
+	err = stmt.Next();
+	TEST2(err, KSqlAtRow);
+	val = stmt.ColumnInt64(0);	
+	TEST3(val, 5);					
+	val = stmt.ColumnInt64(1);
+	TEST3(val, 2000000000);					
+	val = stmt.ColumnInt64(2);
+	TEST3(val, 1000000000);					
+	
+	err = stmt.Next();
+	TEST2(err, KSqlAtRow);
+	val = stmt.ColumnInt64(2);
+	TEST3(val, KMinTInt64);			//"1.1234567890123456E+317" is too big and cannot fit in a 64-bit double
+	
+	stmt.Close();
+	
+	TheDb.Close();
+	err = RSqlDatabase::Delete(KTestDbName);
+	TEST2(err, KErrNone);
+	}
+
+/**
+@SYMTestCaseID			SYSLIB-SQL-UT-3504
+@SYMTestCaseDesc		Test for DEF109100: SQL, code coverage for TSqlBufRIterator is very low.
+						The test creates a test table with INT32, INT64, DOUBLE, TEXT, and BINARY columns
+						and inserts couple of records there. Then the test prepares a SELECT statement,
+						retrieves all table rows, and to retrieve each column value, calls RSqlStatement::ColumnReal().
+						Summary: the test checks the ColumnReal() behaviour when the column value type is not DOUBLE and
+								 when the column value is too big or too small and cannot be presented as 64-bits double.
+@SYMTestPriority		High
+@SYMTestActions			Test for DEF109100: SQL, code coverage for TSqlBufRIterator is very low.
+@SYMTestExpectedResults Test must not fail
+@SYMDEF					DEF109100
+*/	
+void ColumnRealTest()
+	{
+	(void)RSqlDatabase::Delete(KTestDbName);
+	TInt err = TheDb.Create(KTestDbName);
+	TEST2(err, KErrNone);
+	err = TheDb.Exec(_L("CREATE TABLE A(I32 INTEGER,I64 INTEGER,D DOUBLE,T TEXT,B BINARY)"));
+	TEST(err >= 0);
+	
+	err = TheDb.Exec(_L("INSERT INTO A VALUES(-5,-5000000000,-10000000000.0,'AAA',x'1122FF')"));
+	TEST2(err, 1);
+	err = TheDb.Exec(_L("INSERT INTO A VALUES(5,5000000000,10000000000.0,NULL,NULL)"));
+	TEST2(err, 1);
+	err = TheDb.Exec(_L("INSERT INTO A VALUES(5,2000000000,1000000000.0,NULL,NULL)"));
+	TEST2(err, 1);
+	err = TheDb.Exec(_L("INSERT INTO A VALUES(NULL,NULL,1.1234567890123456E+317,NULL,NULL)"));
+	TEST2(err, 1);
+
+	const TReal KEpsilon = 0.000001;
+
+	RSqlStatement stmt;
+	err = stmt.Prepare(TheDb, _L("SELECT I32,I64,D,T,B FROM A"));
+	TEST2(err, KErrNone);
+	
+	err = stmt.Next();
+	TEST2(err, KSqlAtRow);
+	TReal val = stmt.ColumnReal(0);	
+	TEST(Abs(val - (-5)) < KEpsilon);		
+	val = stmt.ColumnReal(1);
+	TEST(Abs(val - (-5000000000LL)) < KEpsilon);
+	val = stmt.ColumnReal(2);
+	TEST(Abs(val - (-10000000000LL)) < KEpsilon);
+	val = stmt.ColumnReal(3);
+	TEST(Abs(val) < 0.0001);					//"AAA" is a text string, cannot be converted to a 64-bit double
+	val = stmt.ColumnReal(4);
+	TEST(Abs(val) < 0.0001);					//"1122FF" is a hex binary, cannot be converted to a 64-bit double
+
+	err = stmt.Next();
+	TEST2(err, KSqlAtRow);
+	val = stmt.ColumnReal(0);	
+	TEST(Abs(val - 5) < KEpsilon);
+	val = stmt.ColumnReal(1);
+	TEST(Abs(val - 5000000000LL) < KEpsilon);
+	val = stmt.ColumnReal(2);
+	TEST(Abs(val - 10000000000LL) < KEpsilon);
+	val = stmt.ColumnReal(3);
+	TEST(Abs(val) < KEpsilon);					//NULL column value
+	val = stmt.ColumnReal(4);
+	TEST(Abs(val) < KEpsilon);					//NULL column value
+
+	err = stmt.Next();
+	TEST2(err, KSqlAtRow);
+	val = stmt.ColumnReal(0);	
+	TEST(Abs(val - 5) < KEpsilon);		
+	val = stmt.ColumnReal(1);
+	TEST(Abs(val - 2000000000) < KEpsilon);
+	val = stmt.ColumnReal(2);
+	TEST(Abs(val - 1000000000) < KEpsilon);
+	
+	err = stmt.Next();
+	TEST2(err, KSqlAtRow);
+	val = stmt.ColumnReal(2);
+	TEST(Math::IsInfinite(val));				//"1.1234567890123456E+317" is too big and cannot fit in a 64-bit double
+	
+	stmt.Close();
+	
+	TheDb.Close();
+	err = RSqlDatabase::Delete(KTestDbName);
+	TEST2(err, KErrNone);
+	}
+
+/**
+@SYMTestCaseID			SYSLIB-SQL-UT-3505
+@SYMTestCaseDesc		Test for DEF109100: SQL, code coverage for TSqlBufRIterator is very low.
+						The test creates a test table with INT32, INT64, DOUBLE, TEXT, and BINARY columns
+						and inserts a record there. Then the test prepares a SELECT statement,
+						retrieves all table rows, and to retrieve each column value, calls RSqlStatement::ColumnText().
+						Summary: the test checks the ColumnText() behaviour when the column value type is not TEXT.
+								 (In all non-TEXT cases the ,ethod is expected to return KNullDesC8)
+@SYMTestPriority		High
+@SYMTestActions			Test for DEF109100: SQL, code coverage for TSqlBufRIterator is very low.
+@SYMTestExpectedResults Test must not fail
+@SYMDEF					DEF109100
+*/	
+void ColumnTextTest()
+	{
+	(void)RSqlDatabase::Delete(KTestDbName);
+	TInt err = TheDb.Create(KTestDbName);
+	TEST2(err, KErrNone);
+	err = TheDb.Exec(_L("CREATE TABLE A(I32 INTEGER,I64 INTEGER,D DOUBLE,T TEXT,B BINARY)"));
+	TEST(err >= 0);
+	
+	err = TheDb.Exec(_L("INSERT INTO A VALUES(-5,-5000000000,-10000000000.0,'AAA',x'1122FF')"));
+	TEST2(err, 1);
+
+	RSqlStatement stmt;
+	err = stmt.Prepare(TheDb, _L("SELECT I32,I64,D,T,B FROM A"));
+	TEST2(err, KErrNone);
+	
+	err = stmt.Next();
+	TEST2(err, KSqlAtRow);
+	TPtrC val;
+	err = stmt.ColumnText(0, val);	
+	TEST2(err, KErrNone);		
+	TEST(val == KNullDesC);
+	err = stmt.ColumnText(1, val);
+	TEST2(err, KErrNone);		
+	TEST(val == KNullDesC);
+	err = stmt.ColumnText(2, val);
+	TEST2(err, KErrNone);		
+	TEST(val == KNullDesC);
+	err = stmt.ColumnText(3, val);
+	TEST2(err, KErrNone);		
+	TEST2(val.Length(), 3);
+	TEST(val == _L("AAA"));
+	err = stmt.ColumnText(4, val);
+	TEST2(err, KErrNone);		
+	TEST(val == KNullDesC);
+	
+	stmt.Close();
+	
+	TheDb.Close();
+	err = RSqlDatabase::Delete(KTestDbName);
+	TEST2(err, KErrNone);
+	}
+	
+/**
+@SYMTestCaseID			SYSLIB-SQL-UT-3506
+@SYMTestCaseDesc		Test for DEF109100: SQL, code coverage for TSqlBufRIterator is very low.
+						The test creates a test table with INT32, INT64, DOUBLE, TEXT, and BINARY columns
+						and inserts a record there. Then the test prepares a SELECT statement,
+						retrieves all table rows, and to retrieve each column value, calls RSqlStatement::ColumnBinary().
+						Summary: the test checks the ColumnBinary() behaviour when the column value type is not BINARY.
+								 (In all non-BINARY cases the method is expected to return KNullDesC8)
+@SYMTestPriority		High
+@SYMTestActions			Test for DEF109100: SQL, code coverage for TSqlBufRIterator is very low.
+@SYMTestExpectedResults Test must not fail
+@SYMDEF					DEF109100
+*/	
+void ColumnBinaryTest()
+	{
+	(void)RSqlDatabase::Delete(KTestDbName);
+	TInt err = TheDb.Create(KTestDbName);
+	TEST2(err, KErrNone);
+	err = TheDb.Exec(_L("CREATE TABLE A(I32 INTEGER,I64 INTEGER,D DOUBLE,T TEXT,B BINARY)"));
+	TEST(err >= 0);
+	
+	err = TheDb.Exec(_L("INSERT INTO A VALUES(-5,-5000000000,-10000000000.0,'AAA',x'1122FF')"));
+	TEST2(err, 1);
+
+	RSqlStatement stmt;
+	err = stmt.Prepare(TheDb, _L("SELECT I32,I64,D,T,B FROM A"));
+	TEST2(err, KErrNone);
+	
+	err = stmt.Next();
+	TEST2(err, KSqlAtRow);
+	TPtrC8 val;
+	err = stmt.ColumnBinary(0, val);	
+	TEST2(err, KErrNone);		
+	TEST(val == KNullDesC8);
+	err = stmt.ColumnBinary(1, val);
+	TEST2(err, KErrNone);		
+	TEST(val == KNullDesC8);
+	err = stmt.ColumnBinary(2, val);
+	TEST2(err, KErrNone);		
+	TEST(val == KNullDesC8);
+	err = stmt.ColumnBinary(3, val);
+	TEST2(err, KErrNone);		
+	TEST(val == KNullDesC8);
+	err = stmt.ColumnBinary(4, val);
+	TEST2(err, KErrNone);		
+	TEST2(val.Length(), 3);
+	TEST(val[0] == 0x11);
+	TEST(val[1] == 0x22);
+	TEST(val[2] == 0xFF);
+	
+	stmt.Close();
+	
+	TheDb.Close();
+	err = RSqlDatabase::Delete(KTestDbName);
+	TEST2(err, KErrNone);
+	}
+	
+void DoTestsL()
+	{	
+	TheTest.Start(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1611 E011 numeric data types test "));		
+	NumericDataTypesTest();
+
+	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1630 Built-in functions test "));		
+	BuiltInFunctionsTest();
+
+	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1632 \"Attach database\" test "));		
+	AttachDatabaseTest();
+
+	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-3502 \"RSqlStatement::ColumnInt()\" test "));		
+	ColumnIntTest();
+
+	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-3503 \"RSqlStatement::ColumnInt64()\" test "));		
+	ColumnInt64Test();
+	
+	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-3504 \"RSqlStatement::ColumnReal()\" test "));		
+	ColumnRealTest();
+	
+	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-3505 \"RSqlStatement::ColumnText()\" test "));		
+	ColumnTextTest();
+
+	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-3506 \"RSqlStatement::ColumnBinary()\" test "));		
+	ColumnBinaryTest();
+	}
+	
+TInt E32Main()
+	{
+	TheTest.Title();
+	
+	CTrapCleanup* tc = CTrapCleanup::New();
+	
+	__UHEAP_MARK;
+	
+	CreateTestDir();
+	DeleteTestFiles();
+	TRAPD(err, DoTestsL());
+	DeleteTestFiles();
+	TEST2(err, KErrNone);
+
+	__UHEAP_MARKEND;
+	
+	TheTest.End();
+	TheTest.Close();
+	
+	delete tc;
+	
+	User::Heap().Check();
+	return KErrNone;
+	}