1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/sqlite3api/TEST/t_sqliteperf.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,852 @@
1.4 +// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
1.5 +// All rights reserved.
1.6 +// This component and the accompanying materials are made available
1.7 +// under the terms of "Eclipse Public License v1.0"
1.8 +// which accompanies this distribution, and is available
1.9 +// at the URL "http://www.eclipse.org/legal/epl-v10.html".
1.10 +//
1.11 +// Initial Contributors:
1.12 +// Nokia Corporation - initial contribution.
1.13 +//
1.14 +// Contributors:
1.15 +//
1.16 +// Description:
1.17 +//
1.18 +
1.19 +#include <e32test.h>
1.20 +#include <bautils.h>
1.21 +#include <e32math.h>
1.22 +#include <hal.h>
1.23 +#include <sqldb.h>
1.24 +#include "sqliteTestUtl.h"
1.25 +#include "t_sqliteperf.h"
1.26 +
1.27 +///////////////////////////////////////////////////////////////////////////////////////
1.28 +
1.29 +const char* const KTestName = "t_sqliteperf test";
1.30 +
1.31 +_LIT(KTestDir, "c:\\test\\");
1.32 +_LIT(KTestDbName, "c:\\test\\t_sqliteperf.db");
1.33 +_LIT8(KTestDbName8, "c:\\test\\t_sqliteperf.db\x0");
1.34 +
1.35 +_LIT(KSqlSrvName, "sqlsrv.exe");
1.36 +
1.37 +static RSqlDatabase TheDb;
1.38 +
1.39 +const TInt KInsertRecCnt = 1000;
1.40 +const TInt KUpdateRecCnt = KInsertRecCnt / 10;
1.41 +const TInt KDeleteRecCnt = KInsertRecCnt / 10;
1.42 +const TInt KSelectRecCnt = KInsertRecCnt / 10;
1.43 +
1.44 +static TInt TheUpdateRecIds[KUpdateRecCnt] = {0};
1.45 +static TInt TheDeleteRecIds[KDeleteRecCnt] = {0};
1.46 +static TInt TheSelectRecIds[KSelectRecCnt] = {0};
1.47 +
1.48 +static TInt TheInsertRecId = 0;
1.49 +static TInt TheUpdateRecId = 0;
1.50 +static TInt TheDeleteRecId = 0;
1.51 +static TInt TheSelectRecId = 0;
1.52 +
1.53 +const char KMultiInsertSql[] = "INSERT INTO Tbl VALUES(:Id, 9234567890, 99.998, 'TEXT VALUE', x'AABBCCDDEEFF')";
1.54 +const char KMultiUpdateSql[] = "UPDATE Tbl SET D=11.113 WHERE I IN";
1.55 +const char KMultiDeleteSql[] = "DELETE FROM Tbl WHERE I IN";
1.56 +const char KMultiSelectSql[] = "SELECT I64,D,T,B FROM Tbl WHERE I IN";
1.57 +
1.58 +const char KSingleInsertSql[] = "INSERT INTO Tbl VALUES(%d, 9234567890, 99.998, 'TEXT VALUE', x'AABBCCDDEEFF')";
1.59 +const char KSingleUpdateSql[] = "UPDATE Tbl SET D=11.113 WHERE I=";
1.60 +const char KSingleDeleteSql[] = "DELETE FROM Tbl WHERE I=";
1.61 +const char KSingleSelectSql[] = "SELECT I64,D,T,B FROM Tbl WHERE I=";
1.62 +
1.63 +//This buffer is used for SQL statement formatting. 2000 bytes should be enough as a buffer max length.
1.64 +static TBuf8<2000> TheSqlBuf;
1.65 +//This buffer is used for printf related formatting. 500 characters should be enough.
1.66 +static TBuf<500> ThePrintBuf;
1.67 +
1.68 +#define UNUSED_VAR(a) (a) = (a)
1.69 +#define UNUSED_PTR(a) a.Set(a)
1.70 +
1.71 +///////////////////////////////////////////////////////////////////////////////////////
1.72 +
1.73 +extern "C" const char* TestDbName(void)
1.74 + {
1.75 + return (const char*)KTestDbName8().Ptr();
1.76 + }
1.77 +
1.78 +static void DeleteTestFiles()
1.79 + {
1.80 + TheDb.Close();
1.81 + (void)RSqlDatabase::Delete(KTestDbName);
1.82 + }
1.83 +
1.84 +///////////////////////////////////////////////////////////////////////////////////////
1.85 +//Test macros and functions
1.86 +static void Check(TInt aValue, TInt aLine)
1.87 + {
1.88 + if(!aValue)
1.89 + {
1.90 + DeleteTestFiles();
1.91 + TestTestLine(EFalse, aLine);
1.92 + }
1.93 + }
1.94 +static void Check(TInt aValue, TInt aExpected, TInt aLine)
1.95 + {
1.96 + if(aValue != aExpected)
1.97 + {
1.98 + DeleteTestFiles();
1.99 + RDebug::Print(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);
1.100 + TestTestLine(EFalse, aLine);
1.101 + }
1.102 + }
1.103 +#define TEST(arg) ::Check((arg), __LINE__)
1.104 +#define TEST2(aValue, aExpected) ::Check(aValue, aExpected, __LINE__)
1.105 +
1.106 +///////////////////////////////////////////////////////////////////////////////////////
1.107 +
1.108 +static TInt KillProcess(const TDesC& aProcessName)
1.109 + {
1.110 + TFullName name;
1.111 + //RDebug::Print(_L("Find and kill \"%S\" process.\n"), &aProcessName);
1.112 + TBuf<64> pattern(aProcessName);
1.113 + TInt length = pattern.Length();
1.114 + pattern += _L("*");
1.115 + TFindProcess procFinder(pattern);
1.116 +
1.117 + while (procFinder.Next(name) == KErrNone)
1.118 + {
1.119 + if (name.Length() > length)
1.120 + {//If found name is a string containing aProcessName string.
1.121 + TChar c(name[length]);
1.122 + if (c.IsAlphaDigit() ||
1.123 + c == TChar('_') ||
1.124 + c == TChar('-'))
1.125 + {
1.126 + // If the found name is other valid application name
1.127 + // starting with aProcessName string.
1.128 + //RDebug::Print(_L(":: Process name: \"%S\".\n"), &name);
1.129 + continue;
1.130 + }
1.131 + }
1.132 + RProcess proc;
1.133 + if (proc.Open(name) == KErrNone)
1.134 + {
1.135 + proc.Kill(0);
1.136 + //RDebug::Print(_L("\"%S\" process killed.\n"), &name);
1.137 + }
1.138 + proc.Close();
1.139 + }
1.140 + return KErrNone;
1.141 + }
1.142 +
1.143 +static TInt TheCounterFreq = -10000000;
1.144 +const TInt KMicroSecIn1Sec = 1000000;
1.145 +
1.146 +//Prints aFastCount parameter (converted to us)
1.147 +static TInt FcDiff2Us(TUint32 aFastCount)
1.148 + {
1.149 + double v = ((double)aFastCount * KMicroSecIn1Sec) / (double)TheCounterFreq;
1.150 + TInt v2 = (TInt)v;
1.151 + return v2;
1.152 + }
1.153 +
1.154 +static void GetFastCounterFrequency()
1.155 + {
1.156 + TEST2(HAL::Get(HAL::EFastCounterFrequency, TheCounterFreq), KErrNone);
1.157 + TBuf8<32> printString;
1.158 + printString.Format(_L8("Counter frequency=%d\r\n"), TheCounterFreq);
1.159 + TestPrintf((const char*)printString.PtrZ());
1.160 + }
1.161 +
1.162 +extern "C" unsigned int FastCounterValue(void)
1.163 + {
1.164 + return User::FastCounter();
1.165 + }
1.166 +
1.167 +//The performance test case results are stored in the ThePerfTestResult array.
1.168 +static TUint32 ThePerfTestResult[EPerfTestModeCnt][EPerfTestTypeCnt];
1.169 +
1.170 +extern "C" void StorePerfTestResult(TPerfTestMode aMode, TPerfTestType aType, unsigned int aResult)
1.171 + {
1.172 + ThePerfTestResult[aMode][aType] = aResult;
1.173 + }
1.174 +
1.175 +static void PrintPerfTestResults()
1.176 + {
1.177 + TBuf8<256> printString;
1.178 + TInt r1 = FcDiff2Us(ThePerfTestResult[EPerfTestSqlMode] [EPerfTestMultiInsert]);
1.179 + TInt r2 = FcDiff2Us(ThePerfTestResult[EPerfTestSqliteSqlMode] [EPerfTestMultiInsert]);
1.180 + TInt r3 = FcDiff2Us(ThePerfTestResult[EPerfTestSqliteDefaultMode][EPerfTestMultiInsert]);
1.181 + TInt r4 = (TInt)((Abs(r2 - r1) * 100.0) / r1);
1.182 + TInt r5 = (TInt)((Abs(r3 - r1) * 100.0) / r1);
1.183 + TestPrintf("### SQL SQLITE-SQL SQLITE-DEFAULT\r\n");
1.184 + printString.Format(_L8("###Multi Insert: %8dus %8dus %8dus %8d%%%% %8d%%%%\r\n"), r1, r2, r3, r2 > r1 ? -r4 : +r4, r3 > r1 ? -r5 : +r5);
1.185 + TestPrintf((const char*)printString.PtrZ());
1.186 +
1.187 + r1 = FcDiff2Us(ThePerfTestResult[EPerfTestSqlMode] [EPerfTestMultiUpdate]);
1.188 + r2 = FcDiff2Us(ThePerfTestResult[EPerfTestSqliteSqlMode] [EPerfTestMultiUpdate]);
1.189 + r3 = FcDiff2Us(ThePerfTestResult[EPerfTestSqliteDefaultMode][EPerfTestMultiUpdate]);
1.190 + r4 = (TInt)((Abs(r2 - r1) * 100.0) / r1);
1.191 + r5 = (TInt)((Abs(r3 - r1) * 100.0) / r1);
1.192 + printString.Format(_L8("###Multi Update: %8dus %8dus %8dus %8d%%%% %8d%%%%\r\n"), r1, r2, r3, r2 > r1 ? -r4 : +r4, r3 > r1 ? -r5 : +r5);
1.193 + TestPrintf((const char*)printString.PtrZ());
1.194 +
1.195 + r1 = FcDiff2Us(ThePerfTestResult[EPerfTestSqlMode] [EPerfTestMultiDelete]);
1.196 + r2 = FcDiff2Us(ThePerfTestResult[EPerfTestSqliteSqlMode] [EPerfTestMultiDelete]);
1.197 + r3 = FcDiff2Us(ThePerfTestResult[EPerfTestSqliteDefaultMode][EPerfTestMultiDelete]);
1.198 + r4 = (TInt)((Abs(r2 - r1) * 100.0) / r1);
1.199 + r5 = (TInt)((Abs(r3 - r1) * 100.0) / r1);
1.200 + printString.Format(_L8("###Multi Delete: %8dus %8dus %8dus %8d%%%% %8d%%%%\r\n"), r1, r2, r3, r2 > r1 ? -r4 : +r4, r3 > r1 ? -r5 : +r5);
1.201 + TestPrintf((const char*)printString.PtrZ());
1.202 +
1.203 + r1 = FcDiff2Us(ThePerfTestResult[EPerfTestSqlMode] [EPerfTestMultiSelect]);
1.204 + r2 = FcDiff2Us(ThePerfTestResult[EPerfTestSqliteSqlMode] [EPerfTestMultiSelect]);
1.205 + r3 = FcDiff2Us(ThePerfTestResult[EPerfTestSqliteDefaultMode][EPerfTestMultiSelect]);
1.206 + r4 = (TInt)((Abs(r2 - r1) * 100.0) / r1);
1.207 + r5 = (TInt)((Abs(r3 - r1) * 100.0) / r1);
1.208 + printString.Format(_L8("###Multi Select: %8dus %8dus %8dus %8d%%%% %8d%%%%\r\n"), r1, r2, r3, r2 > r1 ? -r4 : +r4, r3 > r1 ? -r5 : +r5);
1.209 + TestPrintf((const char*)printString.PtrZ());
1.210 +
1.211 + r1 = FcDiff2Us(ThePerfTestResult[EPerfTestSqlMode] [EPerfTestSingleInsert]);
1.212 + r2 = FcDiff2Us(ThePerfTestResult[EPerfTestSqliteSqlMode] [EPerfTestSingleInsert]);
1.213 + r3 = FcDiff2Us(ThePerfTestResult[EPerfTestSqliteDefaultMode][EPerfTestSingleInsert]);
1.214 + r4 = (TInt)((Abs(r2 - r1) * 100.0) / r1);
1.215 + r5 = (TInt)((Abs(r3 - r1) * 100.0) / r1);
1.216 + printString.Format(_L8("##Single Insert: %8dus %8dus %8dus %8d%%%% %8d%%%%\r\n"), r1, r2, r3, r2 > r1 ? -r4 : +r4, r3 > r1 ? -r5 : +r5);
1.217 + TestPrintf((const char*)printString.PtrZ());
1.218 +
1.219 + r1 = FcDiff2Us(ThePerfTestResult[EPerfTestSqlMode] [EPerfTestSingleUpdate]);
1.220 + r2 = FcDiff2Us(ThePerfTestResult[EPerfTestSqliteSqlMode] [EPerfTestSingleUpdate]);
1.221 + r3 = FcDiff2Us(ThePerfTestResult[EPerfTestSqliteDefaultMode][EPerfTestSingleUpdate]);
1.222 + r4 = (TInt)((Abs(r2 - r1) * 100.0) / r1);
1.223 + r5 = (TInt)((Abs(r3 - r1) * 100.0) / r1);
1.224 + printString.Format(_L8("##Single Update: %8dus %8dus %8dus %8d%%%% %8d%%%%\r\n"), r1, r2, r3, r2 > r1 ? -r4 : +r4, r3 > r1 ? -r5 : +r5);
1.225 + TestPrintf((const char*)printString.PtrZ());
1.226 +
1.227 + r1 = FcDiff2Us(ThePerfTestResult[EPerfTestSqlMode] [EPerfTestSingleDelete]);
1.228 + r2 = FcDiff2Us(ThePerfTestResult[EPerfTestSqliteSqlMode] [EPerfTestSingleDelete]);
1.229 + r3 = FcDiff2Us(ThePerfTestResult[EPerfTestSqliteDefaultMode][EPerfTestSingleDelete]);
1.230 + r4 = (TInt)((Abs(r2 - r1) * 100.0) / r1);
1.231 + r5 = (TInt)((Abs(r3 - r1) * 100.0) / r1);
1.232 + printString.Format(_L8("##Single Delete: %8dus %8dus %8dus %8d%%%% %8d%%%%\r\n"), r1, r2, r3, r2 > r1 ? -r4 : +r4, r3 > r1 ? -r5 : +r5);
1.233 + TestPrintf((const char*)printString.PtrZ());
1.234 +
1.235 + r1 = FcDiff2Us(ThePerfTestResult[EPerfTestSqlMode] [EPerfTestSingleSelect]);
1.236 + r2 = FcDiff2Us(ThePerfTestResult[EPerfTestSqliteSqlMode] [EPerfTestSingleSelect]);
1.237 + r3 = FcDiff2Us(ThePerfTestResult[EPerfTestSqliteDefaultMode][EPerfTestSingleSelect]);
1.238 + r4 = (TInt)((Abs(r2 - r1) * 100.0) / r1);
1.239 + r5 = (TInt)((Abs(r3 - r1) * 100.0) / r1);
1.240 + printString.Format(_L8("##Single Select: %8dus %8dus %8dus %8d%%%% %8d%%%%\r\n"), r1, r2, r3, r2 > r1 ? -r4 : +r4, r3 > r1 ? -r5 : +r5);
1.241 + TestPrintf((const char*)printString.PtrZ());
1.242 + }
1.243 +
1.244 +///////////////////////////////////////////////////////////////////////////////////////
1.245 +
1.246 +static void CreateTestDir()
1.247 + {
1.248 + RFs fs;
1.249 + TInt err = fs.Connect();
1.250 + TEST2(err, KErrNone);
1.251 +
1.252 + err = fs.MkDir(KTestDir);
1.253 + TEST(err == KErrNone || err == KErrAlreadyExists);
1.254 +
1.255 + err = fs.CreatePrivatePath(EDriveC);
1.256 + TEST(err == KErrNone || err == KErrAlreadyExists);
1.257 +
1.258 + fs.Close();
1.259 + }
1.260 +
1.261 +///////////////////////////////////////////////////////////////////////////////////////
1.262 +
1.263 +static void CreateTestDatabase()
1.264 + {
1.265 + RSqlDatabase::Delete(KTestDbName);
1.266 +
1.267 + _LIT8(KConfigStr, "encoding=\"UTF-8\"");
1.268 + TInt err = TheDb.Create(KTestDbName, &KConfigStr);
1.269 + TEST2(err, KErrNone);
1.270 +
1.271 + err = TheDb.Exec(_L8("CREATE TABLE Tbl(I INTEGER PRIMARY KEY, I64 BIGINT, D DOUBLE, T TEXT, B BINARY)"));
1.272 + TEST2(err, 1);
1.273 +
1.274 + TheDb.Close();
1.275 + }
1.276 +
1.277 +///////////////////////////////////////////////////////////////////////////////////////
1.278 +//////////////////// SQL server tests ///////////////////////////
1.279 +///////////////////////////////////////////////////////////////////////////////////////
1.280 +
1.281 +/**
1.282 +@SYMTestCaseID SYSLIB-SQLITE3-UT-4010
1.283 +@SYMTestCaseDesc SQL server multi-insert performance test.
1.284 + The test inserts 1000 records in a single transaction and stores
1.285 + the execution time for later use (comparison and printing).
1.286 +@SYMTestPriority High
1.287 +@SYMTestActions SQL server multi-insert performance test.
1.288 +@SYMTestExpectedResults Test must not fail
1.289 +@SYMREQ REQ8782
1.290 +*/
1.291 +static void SqlServerMultiInsertTest(const char aInsertSql[], TInt aInsertRecCnt)
1.292 + {
1.293 + TestNext(" @SYMTestCaseID:SYSLIB-SQLITE3-UT-4010 ");
1.294 + (void)KillProcess(KSqlSrvName);
1.295 +
1.296 + TInt err = TheDb.Open(KTestDbName);
1.297 + TEST2(err, KErrNone);
1.298 +
1.299 + RSqlStatement stmt;
1.300 + err = stmt.Prepare(TheDb, TPtrC8((const TUint8*)aInsertSql));
1.301 + TEST2(err, KErrNone);
1.302 +
1.303 + TUint32 fc = FastCounterValue();
1.304 + err = TheDb.Exec(_L8("BEGIN"));
1.305 + TEST(err >= 0);
1.306 +
1.307 + for(TInt i=0;i<aInsertRecCnt;++i)
1.308 + {
1.309 + err = stmt.BindInt(0, i + 1);
1.310 + TEST2(err, KErrNone);
1.311 + err = stmt.Exec();
1.312 + TEST2(err, 1);
1.313 + err = stmt.Reset();
1.314 + TEST2(err, KErrNone);
1.315 + }
1.316 +
1.317 + err = TheDb.Exec(_L8("COMMIT"));
1.318 + TEST(err >= 0);
1.319 + StorePerfTestResult(EPerfTestSqlMode, EPerfTestMultiInsert, FastCounterValue() - fc);
1.320 +
1.321 + stmt.Close();
1.322 + TheDb.Close();
1.323 + }
1.324 +
1.325 +static void FormatSqlStmt(TDes8& aSqlBuf, const char aSql[], TInt aRecIds[], TInt aRecCnt)
1.326 + {
1.327 + aSqlBuf.Copy(TPtrC8((const TUint8*)aSql));
1.328 + aSqlBuf.Append(_L8("("));
1.329 + for(TInt i=0;i<aRecCnt;++i)
1.330 + {
1.331 + aSqlBuf.AppendNum((TInt64)aRecIds[i]);
1.332 + aSqlBuf.Append(_L8(","));
1.333 + }
1.334 + aSqlBuf.SetLength(aSqlBuf.Length() - 1);
1.335 + aSqlBuf.Append(_L8(")"));
1.336 + }
1.337 +
1.338 +/**
1.339 +@SYMTestCaseID SYSLIB-SQLITE3-UT-4011
1.340 +@SYMTestCaseDesc SQL server multi-update performance test.
1.341 + The test updates 100 randomly chosen records and stores
1.342 + the execution time for later use (comparison and printing).
1.343 +@SYMTestPriority High
1.344 +@SYMTestActions SQL server multi-update performance test.
1.345 +@SYMTestExpectedResults Test must not fail
1.346 +@SYMREQ REQ8782
1.347 +*/
1.348 +static void SqlServerMultiUpdateTest(const char aUpdateSql[], TInt aUpdateRecIds[], TInt aUpdateRecCnt)
1.349 + {
1.350 + TestNext(" @SYMTestCaseID:SYSLIB-SQLITE3-UT-4011 ");
1.351 + (void)KillProcess(KSqlSrvName);
1.352 +
1.353 + TInt err = TheDb.Open(KTestDbName);
1.354 + TEST2(err, KErrNone);
1.355 +
1.356 + FormatSqlStmt(TheSqlBuf, aUpdateSql, aUpdateRecIds, aUpdateRecCnt);
1.357 +
1.358 + TUint32 fc = FastCounterValue();
1.359 + err = TheDb.Exec(TheSqlBuf);
1.360 + StorePerfTestResult(EPerfTestSqlMode, EPerfTestMultiUpdate, FastCounterValue() - fc);
1.361 + TEST2(err, aUpdateRecCnt);
1.362 +
1.363 + TheDb.Close();
1.364 + }
1.365 +
1.366 +/**
1.367 +@SYMTestCaseID SYSLIB-SQLITE3-UT-4012
1.368 +@SYMTestCaseDesc SQL server multi-delete performance test.
1.369 + The test deletes 100 randomly chosen records and stores
1.370 + the execution time for later use (comparison and printing).
1.371 +@SYMTestPriority High
1.372 +@SYMTestActions SQL server multi-delete performance test.
1.373 +@SYMTestExpectedResults Test must not fail
1.374 +@SYMREQ REQ8782
1.375 +*/
1.376 +static void SqlServerMultiDeleteTest(const char aDeleteSql[], TInt aDeleteRecIds[], TInt aDeleteRecCnt)
1.377 + {
1.378 + TestNext(" @SYMTestCaseID:SYSLIB-SQLITE3-UT-4012 ");
1.379 + (void)KillProcess(KSqlSrvName);
1.380 +
1.381 + TInt err = TheDb.Open(KTestDbName);
1.382 + TEST2(err, KErrNone);
1.383 +
1.384 + FormatSqlStmt(TheSqlBuf, aDeleteSql, aDeleteRecIds, aDeleteRecCnt);
1.385 +
1.386 + TUint32 fc = FastCounterValue();
1.387 + err = TheDb.Exec(TheSqlBuf);
1.388 + StorePerfTestResult(EPerfTestSqlMode, EPerfTestMultiDelete, FastCounterValue() - fc);
1.389 + TEST2(err, aDeleteRecCnt);
1.390 +
1.391 + TheDb.Close();
1.392 + }
1.393 +
1.394 +/**
1.395 +@SYMTestCaseID SYSLIB-SQLITE3-UT-4013
1.396 +@SYMTestCaseDesc SQL server multi-select performance test.
1.397 + The test selects 100 randomly chosen records and stores
1.398 + the execution time for later use (comparison and printing).
1.399 +@SYMTestPriority High
1.400 +@SYMTestActions SQL server multi-select performance test.
1.401 +@SYMTestExpectedResults Test must not fail
1.402 +@SYMREQ REQ8782
1.403 +*/
1.404 +static void SqlServerMultiSelectTest(const char aSelectSql[], TInt aSelectRecIds[], TInt aSelectRecCnt)
1.405 + {
1.406 + TestNext(" @SYMTestCaseID:SYSLIB-SQLITE3-UT-4013 ");
1.407 + (void)KillProcess(KSqlSrvName);
1.408 +
1.409 + TInt err = TheDb.Open(KTestDbName);
1.410 + TEST2(err, KErrNone);
1.411 +
1.412 + FormatSqlStmt(TheSqlBuf, aSelectSql, aSelectRecIds, aSelectRecCnt);
1.413 +
1.414 + RSqlStatement stmt;
1.415 + err = stmt.Prepare(TheDb, TheSqlBuf);
1.416 + TEST2(err, KErrNone);
1.417 + TInt recCnt = 0;
1.418 + TUint32 fc = FastCounterValue();
1.419 + while((err = stmt.Next()) == KSqlAtRow)
1.420 + {
1.421 + TInt64 i64 = stmt.ColumnInt64(0);
1.422 + UNUSED_VAR(i64);
1.423 + TReal d = stmt.ColumnReal(1);
1.424 + UNUSED_VAR(d);
1.425 + TPtrC t;
1.426 + err = stmt.ColumnText(2, t);
1.427 + TEST2(err, KErrNone);
1.428 + UNUSED_PTR(t);
1.429 + TPtrC8 b;
1.430 + err = stmt.ColumnBinary(3, b);
1.431 + TEST2(err, KErrNone);
1.432 + UNUSED_PTR(b);
1.433 + ++recCnt;
1.434 + }
1.435 + StorePerfTestResult(EPerfTestSqlMode, EPerfTestMultiSelect, FastCounterValue() - fc);
1.436 + TEST2(err, KSqlAtEnd);
1.437 + TEST2(recCnt, aSelectRecCnt);
1.438 +
1.439 + stmt.Close();
1.440 + TheDb.Close();
1.441 + }
1.442 +
1.443 +/**
1.444 +@SYMTestCaseID SYSLIB-SQLITE3-UT-4014
1.445 +@SYMTestCaseDesc SQL server single-insert performance test.
1.446 + The test inserts one record and stores
1.447 + the execution time for later use (comparison and printing).
1.448 +@SYMTestPriority High
1.449 +@SYMTestActions SQL server single-insert performance test.
1.450 +@SYMTestExpectedResults Test must not fail
1.451 +@SYMREQ REQ8782
1.452 +*/
1.453 +static void SqlServerSingleInsertTest(const char aSingleInsertSql[], TInt aInsertRecId)
1.454 + {
1.455 + TestNext(" @SYMTestCaseID:SYSLIB-SQLITE3-UT-4014 ");
1.456 + (void)KillProcess(KSqlSrvName);
1.457 +
1.458 + TInt err = TheDb.Open(KTestDbName);
1.459 + TEST2(err, KErrNone);
1.460 +
1.461 + TheSqlBuf.Format(TPtrC8((const TUint8*)aSingleInsertSql), aInsertRecId);
1.462 + TUint32 fc = FastCounterValue();
1.463 + err = TheDb.Exec(TheSqlBuf);
1.464 + StorePerfTestResult(EPerfTestSqlMode, EPerfTestSingleInsert, FastCounterValue() - fc);
1.465 + TEST2(err, 1);
1.466 +
1.467 + TheDb.Close();
1.468 + }
1.469 +
1.470 +/**
1.471 +@SYMTestCaseID SYSLIB-SQLITE3-UT-4015
1.472 +@SYMTestCaseDesc SQL server single-update performance test.
1.473 + The test updates one randomly chosen record and stores
1.474 + the execution time for later use (comparison and printing).
1.475 +@SYMTestPriority High
1.476 +@SYMTestActions SQL server single-update performance test.
1.477 +@SYMTestExpectedResults Test must not fail
1.478 +@SYMREQ REQ8782
1.479 +*/
1.480 +static void SqlServerSingleUpdateTest(const char aSingleUpdateSql[], TInt aUpdateRecId)
1.481 + {
1.482 + TestNext(" @SYMTestCaseID:SYSLIB-SQLITE3-UT-4015 ");
1.483 + (void)KillProcess(KSqlSrvName);
1.484 +
1.485 + TInt err = TheDb.Open(KTestDbName);
1.486 + TEST2(err, KErrNone);
1.487 +
1.488 + TheSqlBuf.Copy(TPtrC8((const TUint8*)aSingleUpdateSql));
1.489 + TheSqlBuf.AppendNum((TInt64)aUpdateRecId);
1.490 + TUint32 fc = FastCounterValue();
1.491 + err = TheDb.Exec(TheSqlBuf);
1.492 + StorePerfTestResult(EPerfTestSqlMode, EPerfTestSingleUpdate, FastCounterValue() - fc);
1.493 + TEST2(err, 1);
1.494 +
1.495 + TheDb.Close();
1.496 + }
1.497 +
1.498 +/**
1.499 +@SYMTestCaseID SYSLIB-SQLITE3-UT-4016
1.500 +@SYMTestCaseDesc SQL server single-delete performance test.
1.501 + The test deletes one randomly chosen record and stores
1.502 + the execution time for later use (comparison and printing).
1.503 +@SYMTestPriority High
1.504 +@SYMTestActions SQL server single-delete performance test.
1.505 +@SYMTestExpectedResults Test must not fail
1.506 +@SYMREQ REQ8782
1.507 +*/
1.508 +static void SqlServerSingleDeleteTest(const char aSingleDeleteSql[], TInt aDeleteRecId)
1.509 + {
1.510 + TestNext(" @SYMTestCaseID:SYSLIB-SQLITE3-UT-4016 ");
1.511 + (void)KillProcess(KSqlSrvName);
1.512 +
1.513 + TInt err = TheDb.Open(KTestDbName);
1.514 + TEST2(err, KErrNone);
1.515 +
1.516 + TheSqlBuf.Copy(TPtrC8((const TUint8*)aSingleDeleteSql));
1.517 + TheSqlBuf.AppendNum((TInt64)aDeleteRecId);
1.518 + TUint32 fc = FastCounterValue();
1.519 + err = TheDb.Exec(TheSqlBuf);
1.520 + StorePerfTestResult(EPerfTestSqlMode, EPerfTestSingleDelete, FastCounterValue() - fc);
1.521 + TEST2(err, 1);
1.522 +
1.523 + TheDb.Close();
1.524 + }
1.525 +
1.526 +/**
1.527 +@SYMTestCaseID SYSLIB-SQLITE3-UT-4017
1.528 +@SYMTestCaseDesc SQL server single-select performance test.
1.529 + The test selects one randomly chosen record and stores
1.530 + the execution time for later use (comparison and printing).
1.531 +@SYMTestPriority High
1.532 +@SYMTestActions SQL server single-select performance test.
1.533 +@SYMTestExpectedResults Test must not fail
1.534 +@SYMREQ REQ8782
1.535 +*/
1.536 +static void SqlServerSingleSelectTest(const char aSingleSelectSql[], TInt aSelectRecId)
1.537 + {
1.538 + TestNext(" @SYMTestCaseID:SYSLIB-SQLITE3-UT-4017 ");
1.539 + (void)KillProcess(KSqlSrvName);
1.540 +
1.541 + TInt err = TheDb.Open(KTestDbName);
1.542 + TEST2(err, KErrNone);
1.543 +
1.544 + TheSqlBuf.Copy(TPtrC8((const TUint8*)aSingleSelectSql));
1.545 + TheSqlBuf.AppendNum((TInt64)aSelectRecId);
1.546 +
1.547 + RSqlStatement stmt;
1.548 + err = stmt.Prepare(TheDb, TheSqlBuf);
1.549 + TEST2(err, KErrNone);
1.550 + TInt recCnt = 0;
1.551 + TUint32 fc = FastCounterValue();
1.552 + while((err = stmt.Next()) == KSqlAtRow)
1.553 + {
1.554 + TInt64 i64 = stmt.ColumnInt64(0);
1.555 + UNUSED_VAR(i64);
1.556 + TReal d = stmt.ColumnReal(1);
1.557 + UNUSED_VAR(d);
1.558 + TPtrC t;
1.559 + err = stmt.ColumnText(2, t);
1.560 + TEST2(err, KErrNone);
1.561 + UNUSED_PTR(t);
1.562 + TPtrC8 b;
1.563 + err = stmt.ColumnBinary(3, b);
1.564 + TEST2(err, KErrNone);
1.565 + UNUSED_PTR(b);
1.566 + ++recCnt;
1.567 + }
1.568 + StorePerfTestResult(EPerfTestSqlMode, EPerfTestSingleSelect, FastCounterValue() - fc);
1.569 + TEST2(err, KSqlAtEnd);
1.570 + TEST2(recCnt, 1);
1.571 +
1.572 + stmt.Close();
1.573 + TheDb.Close();
1.574 + }
1.575 +
1.576 +///////////////////////////////////////////////////////////////////////////////////////
1.577 +///////////////////////////////////////////////////////////////////////////////////////
1.578 +///////////////////////////////////////////////////////////////////////////////////////
1.579 +
1.580 +static void DoSqlServerTests()
1.581 + {
1.582 + TestNext("SQL: Create the test database");
1.583 + CreateTestDatabase();
1.584 +
1.585 + TBuf8<100> msgbuf;
1.586 +
1.587 + msgbuf.Format(_L8("SQL: insert %d records in a single transaction"), KInsertRecCnt);
1.588 + TestNext((const char*)msgbuf.PtrZ());
1.589 + SqlServerMultiInsertTest(KMultiInsertSql, KInsertRecCnt);
1.590 +
1.591 + msgbuf.Format(_L8("SQL: update %d records in a single transaction"), KUpdateRecCnt);
1.592 + TestNext((const char*)msgbuf.PtrZ());
1.593 + SqlServerMultiUpdateTest(KMultiUpdateSql, TheUpdateRecIds, KUpdateRecCnt);
1.594 +
1.595 + msgbuf.Format(_L8("SQL: delete %d records in a single transaction"), KDeleteRecCnt);
1.596 + TestNext((const char*)msgbuf.PtrZ());
1.597 + SqlServerMultiDeleteTest(KMultiDeleteSql, TheDeleteRecIds, KDeleteRecCnt);
1.598 +
1.599 + msgbuf.Format(_L8("SQL: select %d records"), KSelectRecCnt);
1.600 + msgbuf.Copy(msgbuf);
1.601 + TestNext((const char*)msgbuf.PtrZ());
1.602 + SqlServerMultiSelectTest(KMultiSelectSql, TheSelectRecIds, KSelectRecCnt);
1.603 +
1.604 + TestNext("SQL: insert a single record");
1.605 + SqlServerSingleInsertTest(KSingleInsertSql, TheInsertRecId);
1.606 +
1.607 + TestNext("SQL: update a single record");
1.608 + SqlServerSingleUpdateTest(KSingleUpdateSql, TheUpdateRecId);
1.609 +
1.610 + TestNext("SQL: delete a single record");
1.611 + SqlServerSingleDeleteTest(KSingleDeleteSql, TheDeleteRecId);
1.612 +
1.613 + TestNext("SQL: select a single record");
1.614 + SqlServerSingleSelectTest(KSingleSelectSql, TheSelectRecId);
1.615 +
1.616 + (void)RSqlDatabase::Delete(KTestDbName);
1.617 + }
1.618 +
1.619 +static void DoSqliteLibraryTests(TPerfTestMode aPerfTestMode)
1.620 + {
1.621 + TEST(aPerfTestMode > EPerfTestSqlMode && aPerfTestMode < EPerfTestModeCnt);
1.622 +
1.623 + SqliteInitialize(aPerfTestMode);
1.624 +
1.625 + TestNext("SQLite: Create the test database");
1.626 + CreateTestDatabase();
1.627 +
1.628 + TBuf8<200> msgbuf;
1.629 + _LIT8(KSqliteConfigSql, "\"SQL\"");
1.630 + _LIT8(KSqliteConfigDefault, "\"Default\"");
1.631 +
1.632 + msgbuf.Format(_L8("@SYMTestCaseID:SYSLIB-SQLITE3-UT-4018: SQLite, configuration: %S: insert %d records in a single transaction"),
1.633 + aPerfTestMode == EPerfTestSqliteSqlMode ? &KSqliteConfigSql : &KSqliteConfigDefault, KInsertRecCnt);
1.634 + TestNext((const char*)msgbuf.PtrZ());
1.635 + SqliteMultiInsertTest(aPerfTestMode, KMultiInsertSql, KInsertRecCnt);
1.636 +
1.637 + msgbuf.Format(_L8("@SYMTestCaseID:SYSLIB-SQLITE3-UT-4019: SQLite, configuration: %S: update %d records in a single transaction"),
1.638 + aPerfTestMode == EPerfTestSqliteSqlMode ? &KSqliteConfigSql : &KSqliteConfigDefault, KUpdateRecCnt);
1.639 + TestNext((const char*)msgbuf.PtrZ());
1.640 + SqliteMultiUpdateTest(aPerfTestMode, KMultiUpdateSql, TheUpdateRecIds, KUpdateRecCnt);
1.641 +
1.642 + msgbuf.Format(_L8("@SYMTestCaseID:SYSLIB-SQLITE3-UT-4020: SQLite, configuration: %S: delete %d records in a single transaction"),
1.643 + aPerfTestMode == EPerfTestSqliteSqlMode ? &KSqliteConfigSql : &KSqliteConfigDefault, KDeleteRecCnt);
1.644 + TestNext((const char*)msgbuf.PtrZ());
1.645 + SqliteMultiDeleteTest(aPerfTestMode, KMultiDeleteSql, TheDeleteRecIds, KDeleteRecCnt);
1.646 +
1.647 + msgbuf.Format(_L8("@SYMTestCaseID:SYSLIB-SQLITE3-UT-4021: SQLite, configuration: %S: select %d records"),
1.648 + aPerfTestMode == EPerfTestSqliteSqlMode ? &KSqliteConfigSql : &KSqliteConfigDefault, KSelectRecCnt);
1.649 + TestNext((const char*)msgbuf.PtrZ());
1.650 + SqliteMultiSelectTest(aPerfTestMode, KMultiSelectSql, TheSelectRecIds, KSelectRecCnt);
1.651 +
1.652 + msgbuf.Format(_L8("@SYMTestCaseID:SYSLIB-SQLITE3-UT-4022: SQLite, configuration: %S: insert a single record"),
1.653 + aPerfTestMode == EPerfTestSqliteSqlMode ? &KSqliteConfigSql : &KSqliteConfigDefault);
1.654 + TestNext((const char*)msgbuf.PtrZ());
1.655 + SqliteSingleInsertTest(aPerfTestMode, KSingleInsertSql, TheInsertRecId);
1.656 +
1.657 + msgbuf.Format(_L8("@SYMTestCaseID:SYSLIB-SQLITE3-UT-4023: SQLite, configuration: %S: update a single record"),
1.658 + aPerfTestMode == EPerfTestSqliteSqlMode ? &KSqliteConfigSql : &KSqliteConfigDefault);
1.659 + TestNext((const char*)msgbuf.PtrZ());
1.660 + SqliteSingleUpdateTest(aPerfTestMode, KSingleUpdateSql, TheUpdateRecId);
1.661 +
1.662 + msgbuf.Format(_L8("@SYMTestCaseID:SYSLIB-SQLITE3-UT-4024: SQLite, configuration: %S: delete a single record"),
1.663 + aPerfTestMode == EPerfTestSqliteSqlMode ? &KSqliteConfigSql : &KSqliteConfigDefault);
1.664 + TestNext((const char*)msgbuf.PtrZ());
1.665 + SqliteSingleDeleteTest(aPerfTestMode, KSingleDeleteSql, TheDeleteRecId);
1.666 +
1.667 + msgbuf.Format(_L8("@SYMTestCaseID:SYSLIB-SQLITE3-UT-4025: SQLite, configuration: %S: select a single record"),
1.668 + aPerfTestMode == EPerfTestSqliteSqlMode ? &KSqliteConfigSql : &KSqliteConfigDefault);
1.669 + TestNext((const char*)msgbuf.PtrZ());
1.670 + SqliteSingleSelectTest(aPerfTestMode, KSingleSelectSql, TheSelectRecId);
1.671 +
1.672 + (void)RSqlDatabase::Delete(KTestDbName);
1.673 +
1.674 + SqliteFinalize(aPerfTestMode);
1.675 + }
1.676 +
1.677 +static TBool IdIn(TInt aId, const TInt aData[], TInt aDataSize)
1.678 + {
1.679 + TEST(aId > 0);
1.680 + TEST(aDataSize >= 0);
1.681 + for(TInt i=0;i<aDataSize;++i)
1.682 + {
1.683 + TEST(aData[i] > 0);
1.684 + if(aData[i] == aId)
1.685 + {
1.686 + return ETrue;
1.687 + }
1.688 + }
1.689 + return EFalse;
1.690 + }
1.691 +
1.692 +static void VerifyGeneratedRecIds()
1.693 + {
1.694 + TInt i;
1.695 +
1.696 + for(i=0;i<KUpdateRecCnt;++i)
1.697 + {
1.698 + TEST(TheUpdateRecIds[i] > 0 && TheUpdateRecIds[i] <= KInsertRecCnt);
1.699 + TEST(!IdIn(TheUpdateRecIds[i], TheUpdateRecIds, i));
1.700 + TEST(!IdIn(TheUpdateRecIds[i], TheDeleteRecIds, KDeleteRecCnt));
1.701 + TEST(!IdIn(TheUpdateRecIds[i], TheSelectRecIds, KSelectRecCnt));
1.702 + }
1.703 +
1.704 + for(i=0;i<KDeleteRecCnt;++i)
1.705 + {
1.706 + TEST(TheDeleteRecIds[i] > 0 && TheDeleteRecIds[i] <= KInsertRecCnt);
1.707 + TEST(!IdIn(TheDeleteRecIds[i], TheDeleteRecIds, i));
1.708 + TEST(!IdIn(TheDeleteRecIds[i], TheUpdateRecIds, KUpdateRecCnt));
1.709 + TEST(!IdIn(TheDeleteRecIds[i], TheSelectRecIds, KSelectRecCnt));
1.710 + }
1.711 +
1.712 + for(i=0;i<KSelectRecCnt;++i)
1.713 + {
1.714 + TEST(TheSelectRecIds[i] > 0 && TheSelectRecIds[i] <= KInsertRecCnt);
1.715 + TEST(!IdIn(TheSelectRecIds[i], TheSelectRecIds, i));
1.716 + TEST(!IdIn(TheSelectRecIds[i], TheUpdateRecIds, KUpdateRecCnt));
1.717 + TEST(!IdIn(TheSelectRecIds[i], TheDeleteRecIds, KDeleteRecCnt));
1.718 + }
1.719 +
1.720 + TEST(TheInsertRecId > 0);
1.721 +
1.722 + TEST(TheUpdateRecId > 0 && TheUpdateRecId <= KInsertRecCnt);
1.723 + TEST(!IdIn(TheUpdateRecId, TheUpdateRecIds, KUpdateRecCnt));
1.724 + TEST(!IdIn(TheUpdateRecId, TheDeleteRecIds, KDeleteRecCnt));
1.725 + TEST(!IdIn(TheUpdateRecId, TheSelectRecIds, KSelectRecCnt));
1.726 +
1.727 + TEST(TheDeleteRecId > 0 && TheDeleteRecId <= KInsertRecCnt);
1.728 + TEST(!IdIn(TheDeleteRecId, TheUpdateRecIds, KUpdateRecCnt));
1.729 + TEST(!IdIn(TheDeleteRecId, TheDeleteRecIds, KDeleteRecCnt));
1.730 + TEST(!IdIn(TheDeleteRecId, TheSelectRecIds, KSelectRecCnt));
1.731 +
1.732 + TEST(TheSelectRecId > 0 && TheSelectRecId <= KInsertRecCnt);
1.733 + TEST(!IdIn(TheSelectRecId, TheUpdateRecIds, KUpdateRecCnt));
1.734 + TEST(!IdIn(TheSelectRecId, TheDeleteRecIds, KDeleteRecCnt));
1.735 + TEST(!IdIn(TheSelectRecId, TheSelectRecIds, KSelectRecCnt));
1.736 + }
1.737 +
1.738 +static void GenerateTestRecIds()
1.739 + {
1.740 + TTime now;
1.741 + now.UniversalTime();
1.742 + TInt64 seed = now.Int64();
1.743 + TInt i;
1.744 +
1.745 + //Update multi
1.746 + for(i=0;i<KUpdateRecCnt;)
1.747 + {
1.748 + TInt id = Math::Rand(seed) % KInsertRecCnt;
1.749 + if(id > 0 && !IdIn(id, TheUpdateRecIds, i))
1.750 + {
1.751 + TheUpdateRecIds[i++] = id;
1.752 + }
1.753 + }
1.754 + //Delete multi
1.755 + for(i=0;i<KDeleteRecCnt;)
1.756 + {
1.757 + TInt id = Math::Rand(seed) % KInsertRecCnt;
1.758 + if(id > 0 && !IdIn(id, TheDeleteRecIds, i) && !IdIn(id, TheUpdateRecIds, KUpdateRecCnt))
1.759 + {
1.760 + TheDeleteRecIds[i++] = id;
1.761 + }
1.762 + }
1.763 + //Select multi
1.764 + for(i=0;i<KSelectRecCnt;)
1.765 + {
1.766 + TInt id = Math::Rand(seed) % KInsertRecCnt;
1.767 + if(id > 0 && !IdIn(id, TheSelectRecIds, i) && !IdIn(id, TheUpdateRecIds, KUpdateRecCnt) &&
1.768 + !IdIn(id, TheDeleteRecIds, KDeleteRecCnt))
1.769 + {
1.770 + TheSelectRecIds[i++] = id;
1.771 + }
1.772 + }
1.773 + //Insert one
1.774 + TheInsertRecId = KInsertRecCnt + 1;
1.775 + //Update one
1.776 + for(;;)
1.777 + {
1.778 + TInt id = Math::Rand(seed) % KInsertRecCnt;
1.779 + if(id > 0 && !IdIn(id, TheUpdateRecIds, KUpdateRecCnt) && !IdIn(id, TheDeleteRecIds, KDeleteRecCnt) &&
1.780 + !IdIn(id, TheSelectRecIds, KSelectRecCnt))
1.781 + {
1.782 + TheUpdateRecId = id;
1.783 + break;
1.784 + }
1.785 + }
1.786 + //Delete one
1.787 + for(;;)
1.788 + {
1.789 + TInt id = Math::Rand(seed) % KInsertRecCnt;
1.790 + if(id > 0 && id != TheUpdateRecId && !IdIn(id, TheUpdateRecIds, KUpdateRecCnt) &&
1.791 + !IdIn(id, TheDeleteRecIds, KDeleteRecCnt) && !IdIn(id, TheSelectRecIds, KSelectRecCnt))
1.792 + {
1.793 + TheDeleteRecId = id;
1.794 + break;
1.795 + }
1.796 + }
1.797 + //Select one
1.798 + for(;;)
1.799 + {
1.800 + TInt id = Math::Rand(seed) % KInsertRecCnt;
1.801 + if(id > 0 && id != TheUpdateRecId && id != TheDeleteRecId && !IdIn(id, TheUpdateRecIds, KUpdateRecCnt) &&
1.802 + !IdIn(id, TheDeleteRecIds, KDeleteRecCnt) &&
1.803 + !IdIn(id, TheSelectRecIds, KSelectRecCnt))
1.804 + {
1.805 + TheSelectRecId = id;
1.806 + break;
1.807 + }
1.808 + }
1.809 + }
1.810 +
1.811 +static void DoTests()
1.812 + {
1.813 + TestStart("Get fast counter frequency");
1.814 + GetFastCounterFrequency();
1.815 +
1.816 + TestNext("Generate test record ids");
1.817 + GenerateTestRecIds();
1.818 +
1.819 + TestNext("Verify generated test record ids");
1.820 + VerifyGeneratedRecIds();
1.821 +
1.822 + DoSqlServerTests();
1.823 + (void)KillProcess(KSqlSrvName);
1.824 +
1.825 + DoSqliteLibraryTests(EPerfTestSqliteDefaultMode);
1.826 +
1.827 + DoSqliteLibraryTests(EPerfTestSqliteSqlMode);
1.828 +
1.829 + PrintPerfTestResults();
1.830 + }
1.831 +
1.832 +TInt E32Main()
1.833 + {
1.834 + TestOpen(KTestName);
1.835 + TestTitle();
1.836 +
1.837 + CTrapCleanup* tc = CTrapCleanup::New();
1.838 +
1.839 + __UHEAP_MARK;
1.840 +
1.841 + CreateTestDir();
1.842 + DeleteTestFiles();
1.843 + DoTests();
1.844 + DeleteTestFiles();
1.845 +
1.846 + __UHEAP_MARKEND;
1.847 +
1.848 + TestEnd();
1.849 + TestClose();
1.850 +
1.851 + delete tc;
1.852 +
1.853 + User::Heap().Check();
1.854 + return KErrNone;
1.855 + }