diff -r 000000000000 -r bde4ae8d615e os/persistentdata/persistentstorage/dbms/tdbms/t_dbperf1.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/persistentdata/persistentstorage/dbms/tdbms/t_dbperf1.cpp Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,751 @@ +// Copyright (c) 2006-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 +#include +#include +#include +#include + +/////////////////////////////////////////////////////////////////////////////////////// + +RTest TheTest(_L("t_dbperf1")); +RFs TheFs; +RDbs TheDbs; + +TFileName TheNonSecureDbName; +TFileName TheNonSecureDbName2; +_LIT(KFillDbScript, "z:\\test\\t_dbperf1.sql"); +_LIT(KUpdateSql, "UPDATE IDENTITYTABLE SET CM_FIRSTNAME='%S%d',CM_LASTNAME='%S%d',CM_COMPANYNAME='%S%d' WHERE PARENT_CMID=%d"); +_LIT(KSelectSql, "SELECT CM_FIRSTNAME, CM_LASTNAME, CM_COMPANYNAME FROM IDENTITYTABLE WHERE PARENT_CMID > 50"); +_LIT(KDeleteSql, "DELETE FROM IDENTITYTABLE WHERE PARENT_CMID > 50"); +_LIT(KFirstName, "FirstName-"); +_LIT(KLastName, "LastName-"); +_LIT(KCompanyName, "CompanyName-"); + +const TInt KTestTecordCount = 1000; + +enum TTestType + { + EClientDbTest, + EServerDbTest + }; + +enum TCompactDbOption + { + ENoCompaction, + ECompactAfterCommit, + ECompactAfterEvery10Rec, + ECompactAfterEveryUpd, + ECompactAtEnd + }; + +/////////////////////////////////////////////////////////////////////////////////////// + +void TestEnvDestroy() + { + TheDbs.Close(); + TheFs.Delete(TheNonSecureDbName2); + TheFs.Delete(TheNonSecureDbName); + TheFs.Close(); + } + +/////////////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////////////// +//Test macros and functions +void Check1(TInt aValue, TInt aLine) + { + if(!aValue) + { + TestEnvDestroy(); + TheTest.Printf(_L("*** Line %d\r\n"), aLine); + TheTest(EFalse, aLine); + } + } +void Check2(TInt aValue, TInt aExpected, TInt aLine) + { + if(aValue != aExpected) + { + TestEnvDestroy(); + TheTest.Printf(_L("*** Line %d, Expected error: %d, got: %d\r\n"), aLine, aExpected, aValue); + TheTest(EFalse, aLine); + } + } +#define TEST(arg) ::Check1((arg), __LINE__) +#define TEST2(aValue, aExpected) ::Check2(aValue, aExpected, __LINE__) + +/////////////////////////////////////////////////////////////////////////////////////// + +void TestEnvInit() + { + TInt err = TheFs.Connect(); + TEST2(err, KErrNone); + + err = TheFs.MkDir(TheNonSecureDbName); + TEST(err == KErrNone || err == KErrAlreadyExists); + + err = TheDbs.Connect(); + TEST2(err, KErrNone); + } + +//Reads a SQL file and returns the file content as HBUFC string. +//The caller is responsible for destroying the returned HBufC object. +HBufC* ReadSqlScript(const TDesC& aSqlFileName) + { + RFile file; + TEST2(file.Open(TheFs, aSqlFileName, EFileRead), KErrNone); + + TInt size = 0; + TEST2(file.Size(size), KErrNone); + + HBufC8* sql = HBufC8::New(size); + TEST(sql != NULL); + + TPtr8 ptr = sql->Des(); + TEST2(file.Read(ptr, size), KErrNone); + + file.Close(); + + HBufC* sql2 = HBufC::New(size); + TEST(sql2 != NULL); + sql2->Des().Copy(sql->Des()); + delete sql; + + return sql2; + } + +//Searches for the next ';' appearance in aSqlScript string and returns a TPtrC object holding +//the SQL statement, terminated with that ';'. +TPtrC GetNextStmt(TPtrC& aSqlScript) + { + _LIT(KTerminator, ";\xD"); + TPtrC res(NULL, 0); + TInt pos = aSqlScript.FindF(KTerminator()); + if(pos >= 0) + { + res.Set(aSqlScript.Left(pos)); + pos += 1; + aSqlScript.Set(aSqlScript.Mid(pos)); + } + return res; + } + +//Prints aTime parameter (converted to ms) +void PrintStats(TUint32 aStartTicks, TUint32 aEndTicks) + { + static TInt freq = 0; + if(freq == 0) + { + TEST2(HAL::Get(HAL::EFastCounterFrequency, freq), KErrNone); + } + TInt64 diffTicks = (TInt64)aEndTicks - (TInt64)aStartTicks; + if(diffTicks < 0) + { + diffTicks = KMaxTUint32 + diffTicks + 1; + } + const TInt KMicroSecIn1Sec = 1000000; + TInt32 us = (diffTicks * KMicroSecIn1Sec) / freq; + TheTest.Printf(_L("####Execution time: %d ms\r\n"), us / 1000); + } + +void PrintFileSize(const TDesC& aFileName) + { + RFile file; + TInt err = file.Open(TheFs, aFileName, EFileRead); + TEST2(err, KErrNone); + TInt size = 0; + err = file.Size(size); + TEST2(err, KErrNone); + TheTest.Printf(_L("####FileSize: %d\r\n"), size); + file.Close(); + } + +void PrintString(const TDesC& aStr) + { + TheTest.Printf(_L("Str begin~~~~~~~~~~~~~~~~~~~~~~~~~~\r\n")); + TPtrC ptr(aStr); + while(ptr.Length() > 0) + { + TPtrC ptr2; + TInt len = Min(ptr.Length(), 60); + ptr2.Set(ptr.Left(len)); + TheTest.Printf(_L("%S\r\n"), &ptr2); + ptr.Set(ptr.Mid(len)); + } + TheTest.Printf(_L("Str end~~~~~~~~~~~~~~~~~~~~~~~~~~\r\n")); + } + +////////////////////////////////////////////////////////////////////////////////////////////////////////////// +/////// DBMS SERVER performance tests +////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +//Creates aDb database schema. +void CreateDbSchemaL(RDbDatabase& aDb) + { + //"Contacts" table + CDbColSet* colSet = CDbColSet::NewLC(); + colSet->AddL(TDbCol(_L("cm_id"), EDbColInt32, TDbCol::ENotNull)); + colSet->AddL(TDbCol(_L("cm_type"), EDbColInt32, TDbCol::ENotNull)); + colSet->AddL(TDbCol(_L("cm_preftemplaterefid"), EDbColInt32)); + colSet->AddL(TDbCol(_L("cm_uidstring"), EDbColText, 244)); + colSet->AddL(TDbCol(_L("cm_last_modified"), EDbColDateTime)); + colSet->AddL(TDbCol(_L("cm_contactcreationdate"), EDbColDateTime)); + colSet->AddL(TDbCol(_L("cm_attributes"), EDbColInt32, TDbCol::ENotNull)); + colSet->AddL(TDbCol(_L("cm_replicationcount"), EDbColInt32, TDbCol::ENotNull)); + colSet->AddL(TDbCol(_L("cm_header"), EDbColLongText)); + colSet->AddL(TDbCol(_L("cm_textblob"), EDbColLongText)); + colSet->AddL(TDbCol(_L("cm_searchabletext"), EDbColLongText)); + TInt err = aDb.CreateTable(_L("contacts"), *colSet); + TEST2(err, KErrNone); + CleanupStack::PopAndDestroy(); colSet = NULL; + //"identitytable" table + colSet = CDbColSet::NewLC(); + colSet->AddL(TDbCol(_L("parent_cmid"), EDbColInt32, TDbCol::ENotNull)); + colSet->AddL(TDbCol(_L("cm_firstname"), EDbColText, 255)); + colSet->AddL(TDbCol(_L("cm_lastname"), EDbColText, 255)); + colSet->AddL(TDbCol(_L("cm_companyname"), EDbColText, 255)); + colSet->AddL(TDbCol(_L("cm_type"), EDbColInt32)); + colSet->AddL(TDbCol(_L("cm_attributes"), EDbColInt32)); + colSet->AddL(TDbCol(_L("cm_hintfield"), EDbColUint8)); + colSet->AddL(TDbCol(_L("cm_exthintfield"), EDbColUint16)); + colSet->AddL(TDbCol(_L("cm_firstnmprn"), EDbColText, 255)); + colSet->AddL(TDbCol(_L("cm_lastnmprn"), EDbColText, 255)); + colSet->AddL(TDbCol(_L("cm_companynmprn"), EDbColText, 255)); + err = aDb.CreateTable(_L("identitytable"), *colSet); + TEST2(err, KErrNone); + CleanupStack::PopAndDestroy(); colSet = NULL; + //"emailtable" table + colSet = CDbColSet::NewLC(); + colSet->AddL(TDbCol(_L("emailparent_cmid"), EDbColInt32, TDbCol::ENotNull)); + colSet->AddL(TDbCol(_L("email_fieldid"), EDbColInt32, TDbCol::ENotNull)); + colSet->AddL(TDbCol(_L("emailaddress"), EDbColText, 255)); + err = aDb.CreateTable(_L("emailtable"), *colSet); + TEST2(err, KErrNone); + CleanupStack::PopAndDestroy(); colSet = NULL; + //"phone" table + colSet = CDbColSet::NewLC(); + colSet->AddL(TDbCol(_L("cm_id"), EDbColInt32, TDbCol::ENotNull)); + colSet->AddL(TDbCol(_L("cm_phonematching"), EDbColInt32, TDbCol::ENotNull)); + colSet->AddL(TDbCol(_L("cm_extendedphonematching"), EDbColInt32, TDbCol::ENotNull)); + err = aDb.CreateTable(_L("phone"), *colSet); + TEST2(err, KErrNone); + CleanupStack::PopAndDestroy(); colSet = NULL; + //"groups" table + colSet = CDbColSet::NewLC(); + colSet->AddL(TDbCol(_L("cm_id"), EDbColInt32, TDbCol::ENotNull)); + colSet->AddL(TDbCol(_L("cm_members"), EDbColInt32, TDbCol::ENotNull)); + err = aDb.CreateTable(_L("groups"), *colSet); + TEST2(err, KErrNone); + CleanupStack::PopAndDestroy(); colSet = NULL; + //"groups2" table + colSet = CDbColSet::NewLC(); + colSet->AddL(TDbCol(_L("cm_id"), EDbColInt32, TDbCol::ENotNull)); + colSet->AddL(TDbCol(_L("cm_groupmembers"), EDbColLongText)); + err = aDb.CreateTable(_L("groups2"), *colSet); + TEST2(err, KErrNone); + CleanupStack::PopAndDestroy(); colSet = NULL; + //"sync" table + colSet = CDbColSet::NewLC(); + colSet->AddL(TDbCol(_L("cm_id"), EDbColInt32, TDbCol::ENotNull)); + colSet->AddL(TDbCol(_L("cm_lastsyncdate"), EDbColDateTime)); + err = aDb.CreateTable(_L("sync"), *colSet); + TEST2(err, KErrNone); + CleanupStack::PopAndDestroy(); colSet = NULL; + //"preferences" table + colSet = CDbColSet::NewLC(); + colSet->AddL(TDbCol(_L("cm_preffileid"), EDbColInt16)); + colSet->AddL(TDbCol(_L("cm_preftemplateid"), EDbColInt32, TDbCol::ENotNull)); + colSet->AddL(TDbCol(_L("cm_prefowncardid"), EDbColInt32)); + colSet->AddL(TDbCol(_L("cm_prefcardtemplateprefid"), EDbColInt32)); + colSet->AddL(TDbCol(_L("cm_preffilever"), EDbColInt32, TDbCol::ENotNull)); + colSet->AddL(TDbCol(_L("cm_prefcardtemplateid"), EDbColLongText)); + colSet->AddL(TDbCol(_L("cm_prefgroupidlist"), EDbColLongText)); + colSet->AddL(TDbCol(_L("cm_creationdate"), EDbColDateTime)); + colSet->AddL(TDbCol(_L("cm_machineuid"), EDbColInt64)); + colSet->AddL(TDbCol(_L("cm_prefsortorder"), EDbColLongText)); + err = aDb.CreateTable(_L("preferences"), *colSet); + TEST2(err, KErrNone); + CleanupStack::PopAndDestroy(); colSet = NULL; + ////////////////////////////////////////////////////////////////////////////////////////////////////////// + ////////////////////////////////////////////////////////////////////////////////////////////////////////// + //"Contacts" table keys + CDbKey* key = CDbKey::NewLC(); + key->AddL(_L("cm_id")); + key->MakeUnique(); + err = aDb.CreateIndex(_L("contacts"), _L("contacts"), *key); + TEST2(err, KErrNone); + CleanupStack::PopAndDestroy(); key = NULL; + key = CDbKey::NewLC(); + key->AddL(_L("cm_preftemplaterefid")); + err = aDb.CreateIndex(_L("cm_preftemplaterefid"), _L("contacts"), *key); + TEST2(err, KErrNone); + CleanupStack::PopAndDestroy(); key = NULL; + //"identitytable" table keys + key = CDbKey::NewLC(); + key->AddL(_L("parent_cmid")); + key->MakeUnique(); + err = aDb.CreateIndex(_L("identitytable"), _L("identitytable"), *key); + TEST2(err, KErrNone); + CleanupStack::PopAndDestroy(); key = NULL; + //"emailtable" table keys + key = CDbKey::NewLC(); + key->AddL(_L("email_fieldid")); + key->AddL(_L("emailparent_cmid")); + key->MakeUnique(); + err = aDb.CreateIndex(_L("emailtable"), _L("emailtable"), *key); + TEST2(err, KErrNone); + CleanupStack::PopAndDestroy(); key = NULL; + key = CDbKey::NewLC(); + key->AddL(_L("emailparent_cmid")); + err = aDb.CreateIndex(_L("emailparent_cmid"), _L("emailtable"), *key); + TEST2(err, KErrNone); + CleanupStack::PopAndDestroy(); key = NULL; + //"phone" table keys + key = CDbKey::NewLC(); + key->AddL(_L("cm_phonematching")); + key->AddL(_L("cm_id")); + key->MakeUnique(); + err = aDb.CreateIndex(_L("phone"), _L("phone"), *key); + TEST2(err, KErrNone); + CleanupStack::PopAndDestroy(); key = NULL; + key = CDbKey::NewLC(); + key->AddL(_L("cm_id")); + err = aDb.CreateIndex(_L("cm_id"), _L("phone"), *key); + TEST2(err, KErrNone); + CleanupStack::PopAndDestroy(); key = NULL; + //"groups" table keys + key = CDbKey::NewLC(); + key->AddL(_L("cm_members")); + key->AddL(_L("cm_id")); + key->MakeUnique(); + err = aDb.CreateIndex(_L("groups"), _L("groups"), *key); + TEST2(err, KErrNone); + CleanupStack::PopAndDestroy(); key = NULL; + key = CDbKey::NewLC(); + key->AddL(_L("cm_id")); + err = aDb.CreateIndex(_L("cm_id"), _L("groups"), *key); + TEST2(err, KErrNone); + CleanupStack::PopAndDestroy(); key = NULL; + key = CDbKey::NewLC(); + key->AddL(_L("cm_members")); + err = aDb.CreateIndex(_L("cm_members"), _L("groups"), *key); + TEST2(err, KErrNone); + CleanupStack::PopAndDestroy(); key = NULL; + //"groups2" table keys + key = CDbKey::NewLC(); + key->AddL(_L("cm_id")); + key->MakeUnique(); + err = aDb.CreateIndex(_L("groups2"), _L("groups2"), *key); + TEST2(err, KErrNone); + CleanupStack::PopAndDestroy(); key = NULL; + //"sync" table keys + key = CDbKey::NewLC(); + key->AddL(_L("cm_id")); + key->MakeUnique(); + err = aDb.CreateIndex(_L("sync"), _L("sync"), *key); + TEST2(err, KErrNone); + CleanupStack::PopAndDestroy(); key = NULL; + //"preferences" table keys + key = CDbKey::NewLC(); + key->AddL(_L("cm_preftemplateid")); + err = aDb.CreateIndex(_L("cm_preftemplateid"), _L("preferences"), *key); + TEST2(err, KErrNone); + CleanupStack::PopAndDestroy(); key = NULL; + key = CDbKey::NewLC(); + key->AddL(_L("cm_prefowncardid")); + err = aDb.CreateIndex(_L("cm_prefowncardid"), _L("preferences"), *key); + TEST2(err, KErrNone); + CleanupStack::PopAndDestroy(); key = NULL; + key = CDbKey::NewLC(); + key->AddL(_L("cm_prefcardtemplateprefid")); + err = aDb.CreateIndex(_L("cm_prefcardtemplateprefid"), _L("preferences"), *key); + TEST2(err, KErrNone); + CleanupStack::PopAndDestroy(); key = NULL; + } + +class TDbHelper + { +public: + static void CreateL(const TDesC& aDbName) + { + RDbNamedDatabase db; + TInt err = db.Replace(TheFs, aDbName); + TEST2(err, KErrNone); + CreateDbSchemaL(db); + db.Close(); + } + static RDbDatabase Open(TTestType aTestType, const TDesC& aDbName) + { + RDbNamedDatabase db; + TInt err = aTestType == EClientDbTest ? db.Open(TheFs, aDbName) : db.Open(TheDbs, aDbName); + TEST2(err, KErrNone); + return db; + } + }; + +//Executes SQL script +void ExecuteSqlScript(RDbDatabase& aDb, const TDesC& aScriptFileName, TCompactDbOption aCompactDbOpt) + { + if(aCompactDbOpt == ECompactAfterCommit) + { + TheTest.Printf(_L("===Execute DB script: Compact after COMMIT\r\n")); + } + else if(aCompactDbOpt == ECompactAtEnd) + { + TheTest.Printf(_L("===Execute DB script: Compact at end\r\n")); + } + else + { + TheTest.Printf(_L("===Execute DB script: No compaction\r\n")); + } + HBufC* fullDbScript = ReadSqlScript(aScriptFileName); + TUint32 start = User::FastCounter(); + TPtrC ptr(fullDbScript->Des()); + TInt stmtCnt = 0; + TInt err = aDb.Begin(); + TEST2(err, KErrNone); + TPtrC sql(GetNextStmt(ptr)); + while(sql.Length() > 0) + { + ++stmtCnt; + TInt rc = aDb.Execute(sql); + if(rc == KErrNoMemory) + { + TheTest.Printf(_L("###ERROR 'Out of memory'! The test cannot be completed!\r\n")); + return; + } + if(rc != 1) + { + PrintString(sql); + } + TEST2(rc, 1); + if((stmtCnt % 200) == 0) //~16 transactions (~3270 statements total) + { + err = aDb.Commit(); + TEST2(err, KErrNone); + if(aCompactDbOpt == ECompactAfterCommit) + { + err = aDb.Compact(); + TEST2(err, KErrNone); + } + err = aDb.Begin(); + TEST2(err, KErrNone); + } + sql.Set(GetNextStmt(ptr)); + } + err = aDb.Commit(); + TEST2(err, KErrNone); + if(aCompactDbOpt == ECompactAfterCommit || aCompactDbOpt == ECompactAtEnd) + { + err = aDb.Compact(); + TEST2(err, KErrNone); + } + TUint32 end = User::FastCounter(); + PrintStats(start, end); + delete fullDbScript; + TheTest.Printf(_L("###Processed records: %d\r\n"), stmtCnt); + } + +/////////////////////////////////////////////////////////////////////////////////////// + +//"INSERT" test function +void InsertTest(TTestType aTestType, const TDesC& aDbFileName, TCompactDbOption aCompactDbOpt) + { + TheTest.Printf(_L("\"Insert\" test\r\n")); + RDbDatabase db = TDbHelper::Open(aTestType, aDbFileName); + ExecuteSqlScript(db, KFillDbScript, aCompactDbOpt); + RDbTable tbl; + TInt err = tbl.Open(db, _L("CONTACTS")); + TEST2(err, KErrNone); + TInt recCnt = 0; + TRAP(err, recCnt = tbl.CountL()); + TEST2(err, KErrNone); + TEST2(recCnt, 1001); + tbl.Close(); + db.Close(); + } + +//"UPDATE" test function +void UpdateTest(TTestType aTestType, const TDesC& aDbFileName, const TDesC& aUpdateSql, TCompactDbOption aCompactDbOpt) + { + if(aCompactDbOpt == ECompactAfterEvery10Rec) + { + TheTest.Printf(_L("===Update: Compact after every 10 records\r\n")); + } + else if(aCompactDbOpt == ECompactAfterEveryUpd) + { + TheTest.Printf(_L("===Update: Compact after every update\r\n")); + } + else if(aCompactDbOpt == ECompactAtEnd) + { + TheTest.Printf(_L("===Update: Compact at end\r\n")); + } + else + { + TheTest.Printf(_L("===Update: No compaction\r\n")); + } + TheTest.Printf(_L("\"Update\" test\r\n")); + RDbDatabase db = TDbHelper::Open(aTestType, aDbFileName); + + TUint32 start = User::FastCounter(); + for(TInt id=1,updateOpCnt=0;id<=KTestTecordCount;++id,++updateOpCnt) + { + TBuf<200> sql; + sql.Format(aUpdateSql, &KFirstName, id, &KLastName, id, &KCompanyName, id, id); + TInt rc = db.Execute(sql); + if(rc != 1) + { + PrintString(sql); + } + TEST2(rc, 1); + if(aCompactDbOpt == ECompactAfterEveryUpd || (aCompactDbOpt == ECompactAfterEvery10Rec && (updateOpCnt % 10) == 0)) + { + TInt err = db.Compact(); + TEST2(err, KErrNone); + } + } + if(aCompactDbOpt == ECompactAfterEvery10Rec || aCompactDbOpt == ECompactAtEnd) + { + TInt err = db.Compact(); + TEST2(err, KErrNone); + } + TUint32 end = User::FastCounter(); + PrintStats(start, end); + db.Close(); + } + +//"SELECT" test function +void SelectTestL(TTestType aTestType, const TDesC& aDbFileName, const TDesC& aSelectSql) + { + TheTest.Printf(_L("\"Select\" test\r\n")); + RDbDatabase db = TDbHelper::Open(aTestType, aDbFileName); + TDbQuery query(aSelectSql); + RDbView view; + TInt err = view.Prepare(db, query, RDbRowSet::EReadOnly); + TEST2(err, KErrNone); + + TUint32 start = User::FastCounter(); + err = view.EvaluateAll(); + TEST2(err, KErrNone); + while(view.NextL()) + { + view.GetL(); + TPtrC colVal; + TBuf<20> res; + colVal.Set(view.ColDes(1)); + res.Copy(colVal); + TEST(colVal.Length() > 0); + colVal.Set(view.ColDes(2)); + TEST(colVal.Length() > 0); + res.Copy(colVal); + colVal.Set(view.ColDes(3)); + TEST(colVal.Length() > 0); + res.Copy(colVal); + } + TEST(view.AtEnd()); + view.Close(); + TUint32 end = User::FastCounter(); + PrintStats(start, end); + db.Close(); + } + +//"DELETE" test function +void DeleteTest(TTestType aTestType, const TDesC& aDbFileName, const TDesC& aDeleteSql, TCompactDbOption aCompactDbOpt) + { + if(aCompactDbOpt == ECompactAtEnd) + { + TheTest.Printf(_L("===Delete: Compact at end\r\n")); + } + else + { + TheTest.Printf(_L("===Delete: No compaction\r\n")); + } + TheTest.Printf(_L("\"Delete\" test\r\n")); + RDbDatabase db = TDbHelper::Open(aTestType, aDbFileName); + TUint32 start = User::FastCounter(); + TInt rc = db.Execute(aDeleteSql); + TEST(rc > 900); + if(aCompactDbOpt == ECompactAtEnd) + { + TInt err = db.Compact(); + TEST2(err, KErrNone); + } + TUint32 end = User::FastCounter(); + PrintStats(start, end); + db.Close(); + } + +/** +@SYMTestCaseID PDS-DBMS-CT-4008 +@SYMTestCaseDesc DBMS server performance tests. + Three test types used: "insert records", "update records" and "select records". + The tests are executed on non-secure databases. + Each test executed using UTF16 encoded SQl statements. + The test results are used for a comparison against the SQL server test results + (T_SqlPerformance test). +@SYMTestPriority High +@SYMTestActions DBMS server performance tests. +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ5792 + REQ5793 +*/ +void DoTestsL() + { + TheTest.Start(_L(" @SYMTestCaseID:PDS-DBMS-CT-4008 DBMS performance tests")); + + CFileMan* fm = CFileMan::NewL(TheFs); + CleanupStack::PushL(fm); + + //==================================== CLIENT ========================================================== + TheTest.Printf(_L("DBMS, insert, UTF16 SQL strings, non-secure db, client, no db compaction\r\n")); + TDbHelper::CreateL(TheNonSecureDbName); + InsertTest(EClientDbTest, TheNonSecureDbName, ENoCompaction); + PrintFileSize(TheNonSecureDbName); + + TheTest.Printf(_L("DBMS, insert, UTF16 SQL strings, non-secure db, client, db compaction at end\r\n")); + TDbHelper::CreateL(TheNonSecureDbName); + InsertTest(EClientDbTest, TheNonSecureDbName, ECompactAtEnd); + PrintFileSize(TheNonSecureDbName); + + TheTest.Printf(_L("DBMS, insert, UTF16 SQL strings, non-secure db, client, db compaction after commit\r\n")); + TDbHelper::CreateL(TheNonSecureDbName); + InsertTest(EClientDbTest, TheNonSecureDbName, ECompactAfterCommit); + PrintFileSize(TheNonSecureDbName); + + TInt err = fm->Copy(TheNonSecureDbName, TheNonSecureDbName2); + TEST2(err, KErrNone); + + TheTest.Printf(_L("DBMS, update, UTF16 SQL strings, non-secure db, client, no db compaction\r\n")); + UpdateTest(EClientDbTest, TheNonSecureDbName, KUpdateSql(), ENoCompaction); + PrintFileSize(TheNonSecureDbName); + err = fm->Copy(TheNonSecureDbName2, TheNonSecureDbName); + TEST2(err, KErrNone); + + TheTest.Printf(_L("DBMS, update, UTF16 SQL strings, non-secure db, client, db compaction at end\r\n")); + UpdateTest(EClientDbTest, TheNonSecureDbName, KUpdateSql(), ECompactAtEnd); + PrintFileSize(TheNonSecureDbName); + err = fm->Copy(TheNonSecureDbName2, TheNonSecureDbName); + TEST2(err, KErrNone); + + TheTest.Printf(_L("DBMS, update, UTF16 SQL strings, non-secure db, client, db compaction after every 10 records\r\n")); + UpdateTest(EClientDbTest, TheNonSecureDbName, KUpdateSql(), ECompactAfterEvery10Rec); + PrintFileSize(TheNonSecureDbName); +//L err = fm->Copy(TheNonSecureDbName2, TheNonSecureDbName); +//L TEST2(err, KErrNone); + +//L TheTest.Printf(_L("DBMS, update, UTF16 SQL strings, non-secure db, client, db compaction after every update\r\n")); +//L UpdateTest(EClientDbTest, TheNonSecureDbName, KUpdateSql(), ECompactAfterEveryUpd); +//L PrintFileSize(TheNonSecureDbName); + + TheTest.Printf(_L("DBMS, select, UTF16 SQL strings, non-secure db, client\r\n")); + SelectTestL(EClientDbTest, TheNonSecureDbName, KSelectSql()); + + TheTest.Printf(_L("DBMS, delete, UTF16 SQL strings, non-secure db, client\r\n")); + DeleteTest(EClientDbTest, TheNonSecureDbName, KDeleteSql(), ECompactAtEnd); + PrintFileSize(TheNonSecureDbName); + + //==================================== SERVER ========================================================== + + TheTest.Printf(_L("DBMS, insert, UTF16 SQL strings, non-secure db, server, no db compaction\r\n")); + TDbHelper::CreateL(TheNonSecureDbName); + InsertTest(EServerDbTest, TheNonSecureDbName, ENoCompaction); + PrintFileSize(TheNonSecureDbName); + + TheTest.Printf(_L("DBMS, insert, UTF16 SQL strings, non-secure db, server, db compaction at end\r\n")); + TDbHelper::CreateL(TheNonSecureDbName); + InsertTest(EServerDbTest, TheNonSecureDbName, ECompactAtEnd); + PrintFileSize(TheNonSecureDbName); + + TheTest.Printf(_L("DBMS, insert, UTF16 SQL strings, non-secure db, server, db compaction after commit\r\n")); + TDbHelper::CreateL(TheNonSecureDbName); + InsertTest(EServerDbTest, TheNonSecureDbName, ECompactAfterCommit); + PrintFileSize(TheNonSecureDbName); + + err = fm->Copy(TheNonSecureDbName, TheNonSecureDbName2); + TEST2(err, KErrNone); + + TheTest.Printf(_L("DBMS, update, UTF16 SQL strings, non-secure db, server, no db compaction\r\n")); + UpdateTest(EServerDbTest, TheNonSecureDbName, KUpdateSql(), ENoCompaction); + PrintFileSize(TheNonSecureDbName); + err = fm->Copy(TheNonSecureDbName2, TheNonSecureDbName); + TEST2(err, KErrNone); + + TheTest.Printf(_L("DBMS, update, UTF16 SQL strings, non-secure db, server, db compaction at end\r\n")); + UpdateTest(EServerDbTest, TheNonSecureDbName, KUpdateSql(), ECompactAtEnd); + PrintFileSize(TheNonSecureDbName); + err = fm->Copy(TheNonSecureDbName2, TheNonSecureDbName); + TEST2(err, KErrNone); + + TheTest.Printf(_L("DBMS, update, UTF16 SQL strings, non-secure db, server, db compaction after every 10 records\r\n")); + UpdateTest(EServerDbTest, TheNonSecureDbName, KUpdateSql(), ECompactAfterEvery10Rec); + PrintFileSize(TheNonSecureDbName); +//L err = fm->Copy(TheNonSecureDbName2, TheNonSecureDbName); +//L TEST2(err, KErrNone); + +//L TheTest.Printf(_L("DBMS, update, UTF16 SQL strings, non-secure db, server, db compaction after every update\r\n")); +//L UpdateTest(EServerDbTest, TheNonSecureDbName, KUpdateSql(), ECompactAfterEveryUpd); +//L PrintFileSize(TheNonSecureDbName); + + TheTest.Printf(_L("DBMS, select, UTF16 SQL strings, non-secure db, server\r\n")); + SelectTestL(EServerDbTest, TheNonSecureDbName, KSelectSql()); + + TheTest.Printf(_L("DBMS, delete, UTF16 SQL strings, non-secure db, server\r\n")); + DeleteTest(EServerDbTest, TheNonSecureDbName, KDeleteSql(), ECompactAtEnd); + PrintFileSize(TheNonSecureDbName); + + //====================================================================================================== + CleanupStack::PopAndDestroy(fm); + } + +//Usage: "t_dbperf1 [:]" + +TInt E32Main() + { + TheTest.Title(); + + CTrapCleanup* tc = CTrapCleanup::New(); + + //Construct test database file names, using the passed as an optional argument drive letter + TFileName fname; + TParse parse; + User::CommandLine(fname); + + _LIT(KNonSecureDbName, "c:\\test\\t_dbperf1_1.db"); + parse.Set(fname, &KNonSecureDbName, 0); + const TDesC& dbFilePath1 = parse.FullName(); + TheNonSecureDbName.Copy(dbFilePath1); + + _LIT(KNonSecureDbName2, "c:\\test\\t_dbperf1_2.db"); + parse.Set(fname, &KNonSecureDbName2, 0); + const TDesC& dbFilePath2 = parse.FullName(); + TheNonSecureDbName2.Copy(dbFilePath2); + + __UHEAP_MARK; + + TestEnvInit(); + TRAPD(err, DoTestsL()); + TestEnvDestroy(); + TEST2(err, KErrNone); + + __UHEAP_MARKEND; + + TheTest.End(); + TheTest.Close(); + + delete tc; + + User::Heap().Check(); + return KErrNone; + }