1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/sql/TEST/t_sqlperformance2.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,1194 @@
1.4 +// Copyright (c) 2008-2010 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 <sqldb.h>
1.22 +#include "t_sqlcmdlineutil.h"
1.23 +
1.24 +///////////////////////////////////////////////////////////////////////////////////////
1.25 +
1.26 +RTest TheTest(_L("t_sqlperformance2 test"));
1.27 +RSqlDatabase TheDb;
1.28 +TFileName TheDbFileName;
1.29 +RFs TheFs;
1.30 +
1.31 +TBuf<200> TheTestTitle;
1.32 +TCmdLineParams TheCmdLineParams;
1.33 +TBuf8<200> TheSqlConfigString;
1.34 +
1.35 +_LIT(KUtf8, "UTF8 ");
1.36 +_LIT(KUtf16, "UTF16");
1.37 +
1.38 +TInt TheBlobSize = 1024 * 256;
1.39 +
1.40 +///////////////////////////////////////////////////////////////////////////////////////
1.41 +
1.42 +void TestEnvDestroy()
1.43 + {
1.44 + TheDb.Close();
1.45 + (void)RSqlDatabase::Delete(TheDbFileName);
1.46 + TheFs.Close();
1.47 + }
1.48 +
1.49 +///////////////////////////////////////////////////////////////////////////////////////
1.50 +///////////////////////////////////////////////////////////////////////////////////////
1.51 +//Test macros and functions
1.52 +void Check1(TInt aValue, TInt aLine)
1.53 + {
1.54 + if(!aValue)
1.55 + {
1.56 + TestEnvDestroy();
1.57 + TheTest.Printf(_L("*** Line %d\r\n"), aLine);
1.58 + TheTest(EFalse, aLine);
1.59 + }
1.60 + }
1.61 +void Check2(TInt aValue, TInt aExpected, TInt aLine)
1.62 + {
1.63 + if(aValue != aExpected)
1.64 + {
1.65 + TestEnvDestroy();
1.66 + TheTest.Printf(_L("*** Line %d, Expected error: %d, got: %d\r\n"), aLine, aExpected, aValue);
1.67 + TheTest(EFalse, aLine);
1.68 + }
1.69 + }
1.70 +#define TEST(arg) ::Check1((arg), __LINE__)
1.71 +#define TEST2(aValue, aExpected) ::Check2(aValue, aExpected, __LINE__)
1.72 +
1.73 +///////////////////////////////////////////////////////////////////////////////////////
1.74 +
1.75 +void TestEnvInit()
1.76 + {
1.77 + TInt err = TheFs.Connect();
1.78 + TEST2(err, KErrNone);
1.79 + //
1.80 + TInt driveNumber = -1;
1.81 + err = RFs::CharToDrive(TheCmdLineParams.iDriveName[0], driveNumber);
1.82 + TEST2(err, KErrNone);
1.83 + TDriveNumber driveNo = static_cast <TDriveNumber> (driveNumber);
1.84 + TDriveInfo driveInfo;
1.85 + err = TheFs.Drive(driveInfo, driveNo);
1.86 + TEST2(err, KErrNone);
1.87 + //Create the test directory
1.88 + err = TheFs.MkDirAll(TheDbFileName);
1.89 + TEST(err == KErrNone || err == KErrAlreadyExists);
1.90 + //Print drive info and the database name
1.91 + _LIT(KType1, "Not present");
1.92 + _LIT(KType2, "Unknown");
1.93 + _LIT(KType3, "Floppy");
1.94 + _LIT(KType4, "Hard disk");
1.95 + _LIT(KType5, "CD ROM");
1.96 + _LIT(KType6, "RAM disk");
1.97 + _LIT(KType7, "Flash");
1.98 + _LIT(KType8, "ROM drive");
1.99 + _LIT(KType9, "Remote drive");
1.100 + _LIT(KType10,"NAND flash");
1.101 + _LIT(KType11,"Rotating media");
1.102 + TPtrC KMediaTypeNames[] = {KType1(), KType2(), KType3(), KType4(), KType5(), KType6(), KType7(), KType8(), KType9(), KType10(), KType11()};
1.103 + TheTest.Printf(_L("Drive %C: %S. File: \"%S\"\r\n"), 'A' + driveNo, &KMediaTypeNames[driveInfo.iType], &TheDbFileName);
1.104 + }
1.105 +
1.106 +void PrintWriteTime(TTimeIntervalMicroSeconds aTime, TTimeIntervalMicroSeconds aWriteTime, TTimeIntervalMicroSeconds aCommitTime)
1.107 + {
1.108 + TheTest.Printf(_L("####Execution time: %d ms, Write: %d ms, Commit: %d ms\r\n"),
1.109 + (TInt)(aTime.Int64() / 1000), (TInt)(aWriteTime.Int64() / 1000), (TInt)(aCommitTime.Int64() / 1000));
1.110 + }
1.111 +
1.112 +void PrintReadTime(TTimeIntervalMicroSeconds aPrepareTime, TTimeIntervalMicroSeconds aNextTime, TTimeIntervalMicroSeconds aReadTime)
1.113 + {
1.114 + TInt executionTime = (TInt)(aPrepareTime.Int64() / 1000) + (TInt)(aNextTime.Int64() / 1000) + (TInt)(aReadTime.Int64() / 1000);
1.115 + TheTest.Printf(_L("####Execution time: %d ms, Prepare: %d ms, Next: %d ms, Read: %d ms\r\n"),
1.116 + executionTime, (TInt)(aPrepareTime.Int64() / 1000), (TInt)(aNextTime.Int64() / 1000), (TInt)(aReadTime.Int64() / 1000));
1.117 + }
1.118 +
1.119 +void PrintReadTime(TTimeIntervalMicroSeconds aOpenTime, TTimeIntervalMicroSeconds aReadTime)
1.120 + {
1.121 + TInt executionTime = (TInt)(aOpenTime.Int64() / 1000) + (TInt)(aReadTime.Int64() / 1000);
1.122 + TheTest.Printf(_L("####Execution time: %d ms, Open: %d ms, Read: %d ms\r\n"),
1.123 + executionTime, (TInt)(aOpenTime.Int64() / 1000), (TInt)(aReadTime.Int64() / 1000));
1.124 + }
1.125 +
1.126 +void PrintFileSize(RSqlDatabase& aDb)
1.127 + {
1.128 + TheTest.Printf(_L("####FileSize: %d\r\n"), aDb.Size());
1.129 + }
1.130 +
1.131 +///////////////////////////////////////////////////////////////////////////////////////
1.132 +
1.133 +void CreateTestDb()
1.134 + {
1.135 + (void)RSqlDatabase::Delete(TheDbFileName);
1.136 + TInt err = TheDb.Create(TheDbFileName, &TheSqlConfigString);
1.137 + TEST2(err, KErrNone);
1.138 + err = TheDb.Exec(_L8("CREATE TABLE A(B BLOB)"));
1.139 + TEST2(err, 1);
1.140 + }
1.141 +
1.142 +void DoWriteBlobIncrL(const TDesC8& aData,
1.143 + TTime& aT1,
1.144 + TTime& aT2,
1.145 + TTime& aT3,
1.146 + TTime& aT4)
1.147 + {
1.148 +
1.149 + RSqlBlobWriteStream strm;
1.150 + CleanupClosePushL(strm);
1.151 +
1.152 + aT1.HomeTime();
1.153 + strm.OpenL(TheDb, _L("A"), _L("B"));
1.154 + strm.WriteL(aData);
1.155 + aT2.HomeTime();
1.156 +
1.157 + aT3.HomeTime();
1.158 + strm.CommitL();
1.159 + aT4.HomeTime();
1.160 +
1.161 + CleanupStack::PopAndDestroy(&strm);
1.162 + }
1.163 +
1.164 +void InsertZeroBlob(TBool aDoPrintTime = EFalse)
1.165 + {
1.166 + TBuf<100> sql;
1.167 + sql.Format(_L("INSERT INTO A VALUES(zeroblob(%d))"), TheBlobSize);
1.168 +
1.169 + TTime t1, t2;
1.170 + t1.HomeTime();
1.171 + TInt err = TheDb.Exec(sql);
1.172 + t2.HomeTime();
1.173 + TEST2(err, 1);
1.174 + TTimeIntervalMicroSeconds insertTime = t2.MicroSecondsFrom(t1);
1.175 +
1.176 + if(aDoPrintTime)
1.177 + {
1.178 + PrintWriteTime(insertTime, TTimeIntervalMicroSeconds(0), TTimeIntervalMicroSeconds(0));
1.179 + }
1.180 + }
1.181 +
1.182 +void InsertRealBlob()
1.183 + {
1.184 + HBufC8* data = HBufC8::New(TheBlobSize);
1.185 + TEST(data != NULL);
1.186 + TPtr8 dataptr = data->Des();
1.187 + dataptr.SetLength(TheBlobSize);
1.188 + dataptr.Fill(TChar('A'));
1.189 +
1.190 + RSqlStatement stmt;
1.191 + TInt err = stmt.Prepare(TheDb, _L8("INSERT INTO A VALUES(:Prm)"));
1.192 + TEST2(err, KErrNone);
1.193 +
1.194 + RSqlParamWriteStream strm;
1.195 + err = strm.BindBinary(stmt, 0);
1.196 + TEST2(err, KErrNone);
1.197 +
1.198 + TRAP(err, strm.WriteL(dataptr));
1.199 + TEST2(err, KErrNone);
1.200 + TRAP(err, strm.CommitL());
1.201 + TEST2(err, KErrNone);
1.202 + strm.Close();
1.203 +
1.204 + err = stmt.Exec();
1.205 + TEST2(err, 1);
1.206 + stmt.Close();
1.207 +
1.208 + delete data;
1.209 + }
1.210 +
1.211 +void InsertBlobIncr()
1.212 + {
1.213 + HBufC8* data = HBufC8::New(TheBlobSize);
1.214 + TEST(data != NULL);
1.215 + TPtr8 dataptr = data->Des();
1.216 + dataptr.SetLength(TheBlobSize);
1.217 + dataptr.Fill(TChar('B'));
1.218 +
1.219 + TTimeIntervalMicroSeconds totalTime, writeTime, commitTime;
1.220 +
1.221 + TBuf<100> sql;
1.222 + sql.Format(_L("INSERT INTO A VALUES(zeroblob(%d))"), TheBlobSize);
1.223 +
1.224 + TTime t1, t2, subt1, subt2, subt3, subt4;
1.225 + t1.HomeTime();
1.226 +
1.227 + TInt err = TheDb.Exec(_L8("BEGIN"));
1.228 + TEST(err >= 0);
1.229 +
1.230 + err = TheDb.Exec(sql);
1.231 + TEST2(err, 1);
1.232 +
1.233 + TRAP(err, DoWriteBlobIncrL(dataptr, subt1, subt2, subt3, subt4));
1.234 + TEST2(err, KErrNone);
1.235 +
1.236 + err = TheDb.Exec(_L8("COMMIT"));
1.237 + TEST(err >= 0);
1.238 +
1.239 + t2.HomeTime();
1.240 + totalTime = t2.MicroSecondsFrom(t1);
1.241 +
1.242 + writeTime = subt2.MicroSecondsFrom(subt1);
1.243 + commitTime = subt4.MicroSecondsFrom(subt3);
1.244 +
1.245 + PrintWriteTime(totalTime, writeTime, commitTime);
1.246 +
1.247 + delete data;
1.248 + }
1.249 +
1.250 +void InsertBlobExec()
1.251 + {
1.252 + HBufC8* buf = HBufC8::New(TheBlobSize * 2 + 100);
1.253 + TEST(buf != NULL);
1.254 + TPtr8 sql = buf->Des();
1.255 + _LIT8(KStr, "INSERT INTO A VALUES(x'");
1.256 + sql.SetLength(TheBlobSize * 2 + KStr().Length());
1.257 + sql.Fill(TChar('A'));
1.258 + sql.Replace(0, KStr().Length(), KStr);
1.259 + sql.Append(_L8("')"));
1.260 +
1.261 + TTime t1, t2;
1.262 +
1.263 + t1.HomeTime();
1.264 + TInt err = TheDb.Exec(sql);
1.265 + t2.HomeTime();
1.266 + TEST2(err, 1);
1.267 +
1.268 + TTimeIntervalMicroSeconds totalTime = t2.MicroSecondsFrom(t1);
1.269 +
1.270 + PrintWriteTime(totalTime, TTimeIntervalMicroSeconds(0), TTimeIntervalMicroSeconds(0));
1.271 +
1.272 + delete buf;
1.273 + }
1.274 +
1.275 +void InsertBlobBindStreamPrm()
1.276 + {
1.277 + HBufC8* data = HBufC8::New(TheBlobSize);
1.278 + TEST(data != NULL);
1.279 + TPtr8 dataptr = data->Des();
1.280 + dataptr.SetLength(TheBlobSize);
1.281 + dataptr.Fill(TChar('A'));
1.282 +
1.283 + TTimeIntervalMicroSeconds totalTime, writeTime, commitTime;
1.284 +
1.285 + TTime t1, t2, t3, t4, t5, t6;
1.286 + t1.HomeTime();
1.287 +
1.288 + RSqlStatement stmt;
1.289 + TInt err = stmt.Prepare(TheDb, _L8("INSERT INTO A VALUES(:Prm)"));
1.290 + TEST2(err, KErrNone);
1.291 +
1.292 + RSqlParamWriteStream strm;
1.293 + err = strm.BindBinary(stmt, 0);
1.294 + TEST2(err, KErrNone);
1.295 +
1.296 + t3.HomeTime();
1.297 + TRAP(err, strm.WriteL(dataptr));
1.298 + t4.HomeTime();
1.299 + TEST2(err, KErrNone);
1.300 +
1.301 + t5.HomeTime();
1.302 + TRAP(err, strm.CommitL());
1.303 + t6.HomeTime();
1.304 + TEST2(err, KErrNone);
1.305 +
1.306 + err = stmt.Exec();
1.307 +
1.308 + strm.Close();
1.309 + stmt.Close();
1.310 +
1.311 + t2.HomeTime();
1.312 + TEST2(err, 1);
1.313 +
1.314 + totalTime = t2.MicroSecondsFrom(t1);
1.315 +
1.316 + writeTime = t4.MicroSecondsFrom(t3);
1.317 + commitTime = t6.MicroSecondsFrom(t5);
1.318 +
1.319 + PrintWriteTime(totalTime, writeTime, commitTime);
1.320 +
1.321 + delete data;
1.322 + }
1.323 +
1.324 +void UpdateBlobIncr()
1.325 + {
1.326 + HBufC8* data = HBufC8::New(TheBlobSize);
1.327 + TEST(data != NULL);
1.328 + TPtr8 dataptr = data->Des();
1.329 + dataptr.SetLength(TheBlobSize);
1.330 + dataptr.Fill(TChar('A'));
1.331 +
1.332 + TTimeIntervalMicroSeconds totalTime, writeTime, commitTime;
1.333 +
1.334 + TTime t1, t2, subt1, subt2, subt3, subt4;
1.335 + t1.HomeTime();
1.336 +
1.337 + TInt err = TheDb.Exec(_L8("BEGIN"));
1.338 + TEST(err >= 0);
1.339 +
1.340 + TRAP(err, DoWriteBlobIncrL(dataptr, subt1, subt2, subt3, subt4));
1.341 + TEST2(err, KErrNone);
1.342 +
1.343 + err = TheDb.Exec(_L8("COMMIT"));
1.344 + TEST(err >= 0);
1.345 +
1.346 + t2.HomeTime();
1.347 + totalTime = t2.MicroSecondsFrom(t1);
1.348 +
1.349 + writeTime = subt2.MicroSecondsFrom(subt1);
1.350 + commitTime = subt4.MicroSecondsFrom(subt3);
1.351 +
1.352 + PrintWriteTime(totalTime, writeTime, commitTime);
1.353 +
1.354 + delete data;
1.355 + }
1.356 +
1.357 +void UpdateBlobExec()
1.358 + {
1.359 + HBufC8* buf = HBufC8::New(TheBlobSize * 2 + 100);
1.360 + TEST(buf != NULL);
1.361 + TPtr8 sql = buf->Des();
1.362 + _LIT8(KStr, "UPDATE A SET B=x'");
1.363 + sql.SetLength(TheBlobSize * 2 + KStr().Length());
1.364 + sql.Fill(TChar('B'));
1.365 + sql.Replace(0, KStr().Length(), KStr);
1.366 + sql.Append(_L8("'"));
1.367 +
1.368 + TTime t1, t2;
1.369 + t1.HomeTime();
1.370 + TInt err = TheDb.Exec(sql);
1.371 + t2.HomeTime();
1.372 + TEST2(err, 1);
1.373 +
1.374 + TTimeIntervalMicroSeconds totalTime = t2.MicroSecondsFrom(t1);
1.375 +
1.376 + PrintWriteTime(totalTime, TTimeIntervalMicroSeconds(0), TTimeIntervalMicroSeconds(0));
1.377 +
1.378 + delete buf;
1.379 + }
1.380 +
1.381 +void UpdateBlobBindStreamPrm()
1.382 + {
1.383 + HBufC8* data = HBufC8::New(TheBlobSize);
1.384 + TEST(data != NULL);
1.385 + TPtr8 dataptr = data->Des();
1.386 + dataptr.SetLength(TheBlobSize);
1.387 + dataptr.Fill(TChar('B'));
1.388 +
1.389 + TTimeIntervalMicroSeconds totalTime, writeTime, commitTime;
1.390 +
1.391 + TTime t1, t2, t3, t4, t5, t6;
1.392 + t1.HomeTime();
1.393 +
1.394 + RSqlStatement stmt;
1.395 + TInt err = stmt.Prepare(TheDb, _L8("UPDATE A SET B=(:Prm)"));
1.396 + TEST2(err, KErrNone);
1.397 +
1.398 + RSqlParamWriteStream strm;
1.399 + err = strm.BindBinary(stmt, 0);
1.400 + TEST2(err, KErrNone);
1.401 +
1.402 + t3.HomeTime();;
1.403 + TRAP(err, strm.WriteL(dataptr));
1.404 + t4.HomeTime();
1.405 + TEST2(err, KErrNone);
1.406 +
1.407 + t5.HomeTime();
1.408 + TRAP(err, strm.CommitL());
1.409 + t6.HomeTime();
1.410 + TEST2(err, KErrNone);
1.411 +
1.412 + err = stmt.Exec();
1.413 +
1.414 + strm.Close();
1.415 + stmt.Close();
1.416 +
1.417 + t2.HomeTime();
1.418 + TEST2(err, 1);
1.419 +
1.420 + totalTime = t2.MicroSecondsFrom(t1);
1.421 +
1.422 + writeTime = t4.MicroSecondsFrom(t3);
1.423 + commitTime = t6.MicroSecondsFrom(t5);
1.424 +
1.425 + PrintWriteTime(totalTime, writeTime, commitTime);
1.426 +
1.427 + delete data;
1.428 + }
1.429 +
1.430 +/**
1.431 +@SYMTestCaseID SYSLIB-SQL-UT-4084
1.432 +@SYMTestCaseDesc SQL, BLOB write, performance tests.
1.433 + Tests insertion and updates of BLOBs using the old
1.434 + APIs and the new RSqlBlobWriteStream APIs.
1.435 +@SYMTestPriority Medium
1.436 +@SYMTestActions Insertion and updates of blobs using the old and new APIs.
1.437 +@SYMTestExpectedResults Test must not fail
1.438 +@SYMREQ REQ5912
1.439 +*/
1.440 +void BlobWriteTest()
1.441 + {
1.442 + TheTest.Printf(_L("Blob size=%d Kb\r\n"), TheBlobSize / 1024);
1.443 +
1.444 + //Insert a blob
1.445 + TheTest.Printf(_L("==================================================================\r\n"));
1.446 +
1.447 + CreateTestDb();
1.448 + TheTest.Printf(_L("INSERT zeroblob - RSqlDatabase::Exec()\r\n"));
1.449 + PrintFileSize(TheDb);
1.450 + InsertZeroBlob(ETrue);
1.451 + PrintFileSize(TheDb);
1.452 + TheDb.Close();
1.453 + (void)RSqlDatabase::Delete(TheDbFileName);
1.454 +
1.455 + CreateTestDb();
1.456 + TheTest.Printf(_L("INSERT blob - RSqlParamWriteStream\r\n"));
1.457 + PrintFileSize(TheDb);
1.458 + InsertBlobBindStreamPrm();
1.459 + PrintFileSize(TheDb);
1.460 + TheDb.Close();
1.461 + (void)RSqlDatabase::Delete(TheDbFileName);
1.462 +
1.463 + CreateTestDb();
1.464 + TheTest.Printf(_L("INSERT blob - RSqlDatabase::Exec()\r\n"));
1.465 + PrintFileSize(TheDb);
1.466 + InsertBlobExec();
1.467 + PrintFileSize(TheDb);
1.468 + TheDb.Close();
1.469 + (void)RSqlDatabase::Delete(TheDbFileName);
1.470 +
1.471 + CreateTestDb();
1.472 + TheTest.Printf(_L("INSERT blob - RSqlBlobWriteStream + transaction\r\n"));
1.473 + PrintFileSize(TheDb);
1.474 + InsertBlobIncr();
1.475 + PrintFileSize(TheDb);
1.476 + TheDb.Close();
1.477 + (void)RSqlDatabase::Delete(TheDbFileName);
1.478 +
1.479 + // Update a blob
1.480 + TheTest.Printf(_L("==================================================================\r\n"));
1.481 +
1.482 + CreateTestDb();
1.483 + TheTest.Printf(_L("UPDATE zeroblob - RSqlParamWriteStream\r\n"));
1.484 + PrintFileSize(TheDb);
1.485 + InsertZeroBlob();
1.486 + UpdateBlobBindStreamPrm();
1.487 + PrintFileSize(TheDb);
1.488 + TheDb.Close();
1.489 + (void)RSqlDatabase::Delete(TheDbFileName);
1.490 +
1.491 + CreateTestDb();
1.492 + TheTest.Printf(_L("UPDATE blob - RSqlParamWriteStream\r\n"));
1.493 + PrintFileSize(TheDb);
1.494 + InsertRealBlob();
1.495 + UpdateBlobBindStreamPrm();
1.496 + PrintFileSize(TheDb);
1.497 + TheDb.Close();
1.498 + (void)RSqlDatabase::Delete(TheDbFileName);
1.499 +
1.500 + CreateTestDb();
1.501 + TheTest.Printf(_L("UPDATE zeroblob - RSqlDatabase::Exec()\r\n"));
1.502 + PrintFileSize(TheDb);
1.503 + InsertZeroBlob();
1.504 + UpdateBlobExec();
1.505 + PrintFileSize(TheDb);
1.506 + TheDb.Close();
1.507 + (void)RSqlDatabase::Delete(TheDbFileName);
1.508 +
1.509 + CreateTestDb();
1.510 + TheTest.Printf(_L("UPDATE blob - RSqlDatabase::Exec()\r\n"));
1.511 + PrintFileSize(TheDb);
1.512 + InsertRealBlob();
1.513 + UpdateBlobExec();
1.514 + PrintFileSize(TheDb);
1.515 + TheDb.Close();
1.516 + (void)RSqlDatabase::Delete(TheDbFileName);
1.517 +
1.518 + CreateTestDb();
1.519 + TheTest.Printf(_L("UPDATE zeroblob - RSqlBlobWriteStream + transaction\r\n"));
1.520 + PrintFileSize(TheDb);
1.521 + InsertZeroBlob();
1.522 + UpdateBlobIncr();
1.523 + PrintFileSize(TheDb);
1.524 + TheDb.Close();
1.525 + (void)RSqlDatabase::Delete(TheDbFileName);
1.526 +
1.527 + CreateTestDb();
1.528 + TheTest.Printf(_L("UPDATE blob - RSqlBlobWriteStream + transaction\r\n"));
1.529 + PrintFileSize(TheDb);
1.530 + InsertRealBlob();
1.531 + UpdateBlobIncr();
1.532 + PrintFileSize(TheDb);
1.533 + TheDb.Close();
1.534 + (void)RSqlDatabase::Delete(TheDbFileName);
1.535 + }
1.536 +
1.537 +void DoReadBlobIncrL(TDes8& aDes, TInt aMaxLength)
1.538 + {
1.539 + TTime t1, t2, t3, t4;
1.540 +
1.541 + TTimeIntervalMicroSeconds openTime, readTime;
1.542 +
1.543 + RSqlBlobReadStream strm;
1.544 + CleanupClosePushL(strm);
1.545 +
1.546 + t1.HomeTime();
1.547 + strm.OpenL(TheDb, _L("A"), _L("B"), 1);
1.548 + t2.HomeTime();
1.549 +
1.550 + openTime = t2.MicroSecondsFrom(t1);
1.551 +
1.552 + t3.HomeTime();
1.553 + strm.ReadL(aDes, aMaxLength);
1.554 + t4.HomeTime();
1.555 +
1.556 + readTime = t4.MicroSecondsFrom(t3);
1.557 +
1.558 + PrintReadTime(openTime, readTime);
1.559 +
1.560 + CleanupStack::PopAndDestroy(&strm);
1.561 + }
1.562 +
1.563 +void ReadBlobIncr()
1.564 + {
1.565 + HBufC8* data = HBufC8::New(TheBlobSize);
1.566 + TEST(data != NULL);
1.567 + TPtr8 dataptr = data->Des();
1.568 +
1.569 + TRAPD(err, DoReadBlobIncrL(dataptr, TheBlobSize));
1.570 + TEST2(err, KErrNone);
1.571 + TEST2(dataptr.Length(), TheBlobSize);
1.572 +
1.573 + delete data;
1.574 + }
1.575 +
1.576 +void ReadBlobColDes()
1.577 + {
1.578 + HBufC8* data = HBufC8::New(TheBlobSize);
1.579 + TEST(data != NULL);
1.580 + TPtr8 dataptr = data->Des();
1.581 +
1.582 + TTime t1, t2, t3, t4, t5, t6;
1.583 + TTimeIntervalMicroSeconds prepareTime, nextTime, readTime;
1.584 +
1.585 + RSqlStatement stmt;
1.586 + t1.HomeTime();
1.587 + TInt err = stmt.Prepare(TheDb, _L8("SELECT B FROM A WHERE ROWID=1"));
1.588 + t2.HomeTime();
1.589 + TEST2(err, KErrNone);
1.590 + prepareTime = t2.MicroSecondsFrom(t1);
1.591 +
1.592 + t3.HomeTime();
1.593 + err = stmt.Next();
1.594 + t4.HomeTime();
1.595 + TEST2(err, KSqlAtRow);
1.596 + nextTime = t4.MicroSecondsFrom(t3);
1.597 +
1.598 + t5.HomeTime();
1.599 + err = stmt.ColumnBinary(0, dataptr);
1.600 + t6.HomeTime();
1.601 + TEST2(err, KErrNone);
1.602 + TEST2(dataptr.Length(), TheBlobSize);
1.603 + readTime = t6.MicroSecondsFrom(t5);
1.604 +
1.605 + PrintReadTime(prepareTime, nextTime, readTime);
1.606 + stmt.Close();
1.607 +
1.608 + delete data;
1.609 + }
1.610 +
1.611 +void ReadBlobColPtr()
1.612 + {
1.613 + TTime t1, t2, t3, t4, t5, t6;
1.614 + TTimeIntervalMicroSeconds prepareTime, nextTime, readTime;
1.615 +
1.616 + RSqlStatement stmt;
1.617 + t1.HomeTime();
1.618 + TInt err = stmt.Prepare(TheDb, _L8("SELECT B FROM A WHERE ROWID=1"));
1.619 + t2.HomeTime();
1.620 + TEST2(err, KErrNone);
1.621 + prepareTime = t2.MicroSecondsFrom(t1);
1.622 +
1.623 + t3.HomeTime();
1.624 + err = stmt.Next();
1.625 + t4.HomeTime();
1.626 + TEST2(err, KSqlAtRow);
1.627 + nextTime = t4.MicroSecondsFrom(t3);
1.628 +
1.629 + TPtrC8 data;
1.630 + t5.HomeTime();
1.631 + err = stmt.ColumnBinary(0, data);
1.632 + t6.HomeTime();
1.633 + TEST2(err, KErrNone);
1.634 + TEST2(data.Length(), TheBlobSize);
1.635 + readTime = t6.MicroSecondsFrom(t5);
1.636 +
1.637 + PrintReadTime(prepareTime, nextTime, readTime);
1.638 + stmt.Close();
1.639 + }
1.640 +
1.641 +void ReadBlobStreamCol()
1.642 + {
1.643 + HBufC8* data = HBufC8::New(TheBlobSize);
1.644 + TEST(data != NULL);
1.645 + TPtr8 dataptr = data->Des();
1.646 +
1.647 + TTime t1, t2, t3, t4, t5, t6;
1.648 + TTimeIntervalMicroSeconds prepareTime, nextTime, readTime;
1.649 +
1.650 + RSqlStatement stmt;
1.651 + t1.HomeTime();
1.652 + TInt err = stmt.Prepare(TheDb, _L8("SELECT B FROM A WHERE ROWID=1"));
1.653 + t2.HomeTime();
1.654 + TEST2(err, KErrNone);
1.655 + prepareTime = t2.MicroSecondsFrom(t1);
1.656 +
1.657 + t3.HomeTime();
1.658 + err = stmt.Next();
1.659 + t4.HomeTime();
1.660 + TEST2(err, KSqlAtRow);
1.661 + nextTime = t4.MicroSecondsFrom(t3);
1.662 +
1.663 + RSqlColumnReadStream strm;
1.664 + t5.HomeTime();
1.665 + err = strm.ColumnBinary(stmt, 0);
1.666 + TEST2(err, KErrNone);
1.667 + TRAP(err, strm.ReadL(dataptr, TheBlobSize));
1.668 + t6.HomeTime();
1.669 + TEST2(err, KErrNone);
1.670 + TEST2(dataptr.Length(), TheBlobSize);
1.671 + readTime = t6.MicroSecondsFrom(t5);
1.672 +
1.673 + strm.Close();
1.674 + stmt.Close();
1.675 +
1.676 + PrintReadTime(prepareTime, nextTime, readTime);
1.677 +
1.678 + delete data;
1.679 + }
1.680 +
1.681 +/**
1.682 +@SYMTestCaseID SYSLIB-SQL-UT-4085
1.683 +@SYMTestCaseDesc SQL, BLOB read, performance tests.
1.684 + Tests retrieval of BLOBs using the old
1.685 + APIs and the new RSqlBlobReadStream APIs.
1.686 +@SYMTestPriority Medium
1.687 +@SYMTestActions Retrieval of blobs using the old and new APIs.
1.688 +@SYMTestExpectedResults Test must not fail
1.689 +@SYMREQ REQ5912
1.690 +*/
1.691 +void BlobReadTest()
1.692 + {
1.693 + TheTest.Printf(_L("Blob size=%d Kb\r\n"), TheBlobSize / 1024);
1.694 +
1.695 + // Insert a blob
1.696 + TheTest.Printf(_L("==================================================================\r\n"));
1.697 + TheTest.Printf(_L("Insert blob\r\n"));
1.698 +
1.699 + CreateTestDb();
1.700 + PrintFileSize(TheDb);
1.701 + InsertBlobExec();
1.702 + PrintFileSize(TheDb);
1.703 + TheDb.Close();
1.704 +
1.705 + // Read the blob
1.706 + TheTest.Printf(_L("==================================================================\r\n"));
1.707 +
1.708 + TheTest.Printf(_L("Read blob - RSqlBlobReadStream\r\n"));
1.709 + TInt err = TheDb.Open(TheDbFileName);
1.710 + TEST2(err, KErrNone);
1.711 + ReadBlobIncr();
1.712 + TheDb.Close();
1.713 +
1.714 + TheTest.Printf(_L("Read blob - RSqlStatement::ColumnBinary(TInt, TDes8&)\r\n"));
1.715 + err = TheDb.Open(TheDbFileName);
1.716 + TEST2(err, KErrNone);
1.717 + ReadBlobColDes();
1.718 + TheDb.Close();
1.719 +
1.720 + TheTest.Printf(_L("Read blob - RSqlStatement::ColumnBinary(TInt, TPtrC8&)\r\n"));
1.721 + err = TheDb.Open(TheDbFileName);
1.722 + TEST2(err, KErrNone);
1.723 + ReadBlobColPtr();
1.724 + TheDb.Close();
1.725 +
1.726 + TheTest.Printf(_L("Read blob - RSqlColumnReadStream\r\n"));
1.727 + err = TheDb.Open(TheDbFileName);
1.728 + TEST2(err, KErrNone);
1.729 + ReadBlobStreamCol();
1.730 + TheDb.Close();
1.731 +
1.732 + (void)RSqlDatabase::Delete(TheDbFileName);
1.733 + }
1.734 +
1.735 +/**
1.736 +@SYMTestCaseID SYSLIB-SQL-UT-4115
1.737 +@SYMTestCaseDesc SQL, sequential BLOB writes, performance tests.
1.738 + Tests sequentially writing 32Kb blocks to a 1.125Mb blob
1.739 + using the new RSqlBlobWriteStream APIs to examine
1.740 + the write performance at different stages in the
1.741 + sequence.
1.742 +@SYMTestPriority Medium
1.743 +@SYMTestActions Sequential writing of a blob using the new RSqlBlobWriteStream APIs.
1.744 +@SYMTestExpectedResults Test must not fail
1.745 +@SYMREQ REQ5912
1.746 +*/
1.747 +void SequentialWriteTestL()
1.748 + {
1.749 + const TInt KBufLen = 32768; // 32Kb
1.750 + HBufC8* buf = HBufC8::NewL(KBufLen);
1.751 + TPtr8 dataPtr = buf->Des();
1.752 + dataPtr.SetLength(KBufLen);
1.753 + dataPtr.Fill('A', KBufLen);
1.754 +
1.755 + CreateTestDb();
1.756 + InsertZeroBlob(); // insert zeroblob of "TheBlobSize" size
1.757 +
1.758 + RSqlBlobWriteStream strm;
1.759 + strm.OpenL(TheDb, _L("A"), _L("B"));
1.760 +
1.761 + // Sequentially write 32Kb blocks of data to the
1.762 + // blob until the 1Mb cache is full and writes to the disk begin.
1.763 + // 32 * 32Kb = 1Mb = soft heap limit
1.764 + const TInt KItCount = TheBlobSize / KBufLen - 1;
1.765 + for(TInt i = 1; i <= KItCount; ++i)
1.766 + {
1.767 + TheTest.Printf(_L("***Iteration %d\r\n"), i);
1.768 +
1.769 + PrintFileSize(TheDb);
1.770 +
1.771 + TTimeIntervalMicroSeconds writeTime;
1.772 + TTime t1, t2;
1.773 +
1.774 + t1.HomeTime();
1.775 + strm.WriteL(dataPtr);
1.776 + t2.HomeTime();
1.777 +
1.778 + writeTime = t2.MicroSecondsFrom(t1);
1.779 +
1.780 + PrintWriteTime(TTimeIntervalMicroSeconds(0), writeTime, TTimeIntervalMicroSeconds(0));
1.781 + PrintFileSize(TheDb);
1.782 + }
1.783 +
1.784 + TTimeIntervalMicroSeconds commitTime;
1.785 + TTime t3, t4;
1.786 + t3.HomeTime();
1.787 + strm.CommitL();
1.788 + t4.HomeTime();
1.789 + commitTime = t4.MicroSecondsFrom(t3);
1.790 +
1.791 + PrintWriteTime(TTimeIntervalMicroSeconds(0), TTimeIntervalMicroSeconds(0), commitTime);
1.792 + PrintFileSize(TheDb);
1.793 +
1.794 + strm.Close();
1.795 + TheDb.Close();
1.796 + (void)RSqlDatabase::Delete(TheDbFileName);
1.797 +
1.798 + delete buf;
1.799 + }
1.800 +
1.801 +/**
1.802 +@SYMTestCaseID SYSLIB-SQL-UT-4116
1.803 +@SYMTestCaseDesc SQL, transaction sequential BLOB writes, performance tests.
1.804 + Tests sequentially writing 32Kb blocks to a 1.125Mb blob
1.805 + within a transaction, using the new RSqlBlobWriteStream APIs,
1.806 + to examine the write performance at different stages in the
1.807 + sequence.
1.808 +@SYMTestPriority Medium
1.809 +@SYMTestActions Sequential writing of a blob within a transactions, using the
1.810 + new RSqlBlobWriteStream APIs.
1.811 +@SYMTestExpectedResults Test must not fail
1.812 +@SYMREQ REQ5912
1.813 +*/
1.814 +void TransSequentialWriteTestL()
1.815 + {
1.816 + const TInt KBufLen = 32768; // 32Kb
1.817 + HBufC8* buf = HBufC8::NewL(KBufLen);
1.818 + TPtr8 dataPtr = buf->Des();
1.819 + dataPtr.SetLength(KBufLen);
1.820 + dataPtr.Fill('A', KBufLen);
1.821 +
1.822 + CreateTestDb();
1.823 + InsertZeroBlob(); // insert zeroblob of "TheBlobSize" size
1.824 +
1.825 + RSqlBlobWriteStream strm;
1.826 + strm.OpenL(TheDb, _L("A"), _L("B"));
1.827 +
1.828 + TInt err = TheDb.Exec(_L8("BEGIN"));
1.829 + TEST(err >= 0);
1.830 +
1.831 + // Sequentially write 32Kb blocks of data to the
1.832 + // blob until the 1Mb cache is full and writes to the disk begin.
1.833 + // 32 * 32Kb = 1Mb = soft heap limit
1.834 + const TInt KItCount = TheBlobSize / KBufLen - 1;
1.835 + for(TInt i = 1; i <= KItCount; ++i)
1.836 + {
1.837 + TheTest.Printf(_L("***Iteration %d\r\n"), i);
1.838 +
1.839 + PrintFileSize(TheDb);
1.840 +
1.841 + TTimeIntervalMicroSeconds writeTime;
1.842 + TTime t1, t2;
1.843 +
1.844 + t1.HomeTime();
1.845 + strm.WriteL(dataPtr);
1.846 + t2.HomeTime();
1.847 +
1.848 + writeTime = t2.MicroSecondsFrom(t1);
1.849 +
1.850 + PrintWriteTime(TTimeIntervalMicroSeconds(0), writeTime, TTimeIntervalMicroSeconds(0));
1.851 + PrintFileSize(TheDb);
1.852 + }
1.853 +
1.854 + TTimeIntervalMicroSeconds commitTime;
1.855 + TTime t3, t4;
1.856 +
1.857 + t3.HomeTime();
1.858 + strm.CommitL();
1.859 + t4.HomeTime();
1.860 + commitTime = t4.MicroSecondsFrom(t3);
1.861 +
1.862 + PrintWriteTime(TTimeIntervalMicroSeconds(0), TTimeIntervalMicroSeconds(0), commitTime);
1.863 + PrintFileSize(TheDb);
1.864 +
1.865 + TTime t5, t6;
1.866 + t5.HomeTime();
1.867 + err = TheDb.Exec(_L8("COMMIT"));
1.868 + t6.HomeTime();
1.869 + TEST(err >= 0);
1.870 +
1.871 + TTimeIntervalMicroSeconds transCommitTime = t6.MicroSecondsFrom(t5);
1.872 + PrintWriteTime(TTimeIntervalMicroSeconds(0), TTimeIntervalMicroSeconds(0), transCommitTime);
1.873 + PrintFileSize(TheDb);
1.874 +
1.875 + strm.Close();
1.876 + TheDb.Close();
1.877 + (void)RSqlDatabase::Delete(TheDbFileName);
1.878 +
1.879 + delete buf;
1.880 + }
1.881 +
1.882 +/**
1.883 +@SYMTestCaseID SYSLIB-SQL-UT-4117
1.884 +@SYMTestCaseDesc SQL, whole BLOB write, performance tests.
1.885 + Tests writing a 256Kb data block to a 256Kb blob to examine the
1.886 + relative performance of the TSqlBlob and RSqlBlobWriteStream APIs.
1.887 +@SYMTestPriority Medium
1.888 +@SYMTestActions Whole update of a blob using the new TSqlBlob and RSqlBlobWriteStream APIs.
1.889 +@SYMTestExpectedResults Test must not fail
1.890 +@SYMREQ REQ5912
1.891 +*/
1.892 +void WholeWriteTestL()
1.893 + {
1.894 + TInt bufLen = TheBlobSize;
1.895 + HBufC8* buf = HBufC8::NewL(bufLen);
1.896 + TPtr8 dataPtr = buf->Des();
1.897 + dataPtr.SetLength(bufLen);
1.898 + dataPtr.Fill('Z', bufLen);
1.899 +
1.900 + CreateTestDb();
1.901 + InsertRealBlob(); // insert blob of "TheBlobSize" size
1.902 +
1.903 + TheTest.Printf(_L("***WholeWriteTestL - %dKb blob \r\n"), TheBlobSize / 1024);
1.904 + PrintFileSize(TheDb);
1.905 +
1.906 + // TSqlBlob::Set
1.907 + TTimeIntervalMicroSeconds writeTime;
1.908 + TTime t1, t2, t3, t4;
1.909 +
1.910 + t1.HomeTime();
1.911 + TSqlBlob::SetL(TheDb, _L("A"), _L("B"), dataPtr);
1.912 + t2.HomeTime();
1.913 +
1.914 + writeTime = t2.MicroSecondsFrom(t1);
1.915 +
1.916 + PrintWriteTime(TTimeIntervalMicroSeconds(0), writeTime, TTimeIntervalMicroSeconds(0));
1.917 + PrintFileSize(TheDb);
1.918 +
1.919 + // to avoid caching issues, close and re-create the database for the next part
1.920 + TheDb.Close();
1.921 + (void)RSqlDatabase::Delete(TheDbFileName);
1.922 + CreateTestDb();
1.923 + InsertRealBlob(); // insert blob of "TheBlobSize" size
1.924 + PrintFileSize(TheDb);
1.925 +
1.926 + // RSqlBlobWriteStream::WriteL
1.927 + t3.HomeTime();
1.928 + RSqlBlobWriteStream strm;
1.929 + CleanupClosePushL(strm);
1.930 + strm.OpenL(TheDb, _L("A"), _L("B"));
1.931 + strm.WriteL(dataPtr);
1.932 + CleanupStack::PopAndDestroy(&strm);
1.933 + t4.HomeTime();
1.934 +
1.935 + writeTime = t4.MicroSecondsFrom(t3);
1.936 +
1.937 + PrintWriteTime(TTimeIntervalMicroSeconds(0), writeTime, TTimeIntervalMicroSeconds(0));
1.938 + PrintFileSize(TheDb);
1.939 +
1.940 + TheDb.Close();
1.941 + (void)RSqlDatabase::Delete(TheDbFileName);
1.942 +
1.943 + delete buf;
1.944 + }
1.945 +
1.946 +/**
1.947 +@SYMTestCaseID SYSLIB-SQL-UT-4118
1.948 +@SYMTestCaseDesc SQL, transaction whole BLOB write, performance tests.
1.949 + Tests writing a 256Kb data block to a 256Kb blob, within a transaction,
1.950 + to examine the relative performance of the TSqlBlob and RSqlBlobWriteStream APIs.
1.951 +@SYMTestPriority Medium
1.952 +@SYMTestActions Whole update of a blob, within a transaction, using the new TSqlBlob and
1.953 + RSqlBlobWriteStream APIs.
1.954 +@SYMTestExpectedResults Test must not fail
1.955 +@SYMREQ REQ5912
1.956 +*/
1.957 +void TransWholeWriteTestL()
1.958 + {
1.959 + TInt bufLen = TheBlobSize;
1.960 + HBufC8* buf = HBufC8::NewL(bufLen);
1.961 + TPtr8 dataPtr = buf->Des();
1.962 + dataPtr.SetLength(bufLen);
1.963 + dataPtr.Fill('Z', bufLen);
1.964 +
1.965 + CreateTestDb();
1.966 + InsertRealBlob(); // insert blob of "TheBlobSize" size
1.967 +
1.968 + TheTest.Printf(_L("***TransWholeWriteTestL - %dKb blob\r\n"), TheBlobSize / 1024);
1.969 + PrintFileSize(TheDb);
1.970 +
1.971 + // TSqlBlob::Set
1.972 + TTimeIntervalMicroSeconds writeTime;
1.973 + TTime t1, t2, t3, t4;
1.974 +
1.975 + t1.HomeTime();
1.976 + TInt err = TheDb.Exec(_L8("BEGIN"));
1.977 + TEST(err >= 0);
1.978 + TSqlBlob::SetL(TheDb, _L("A"), _L("B"), dataPtr);
1.979 + err = TheDb.Exec(_L8("COMMIT"));
1.980 + t2.HomeTime();
1.981 + TEST(err >= 0);
1.982 +
1.983 + writeTime = t2.MicroSecondsFrom(t1);
1.984 +
1.985 + PrintWriteTime(TTimeIntervalMicroSeconds(0), writeTime, TTimeIntervalMicroSeconds(0));
1.986 + PrintFileSize(TheDb);
1.987 +
1.988 + // to avoid caching issues, close and re-create the database for the next part
1.989 + TheDb.Close();
1.990 + (void)RSqlDatabase::Delete(TheDbFileName);
1.991 + CreateTestDb();
1.992 + InsertRealBlob(); // insert blob of "TheBlobSize" size
1.993 + PrintFileSize(TheDb);
1.994 +
1.995 + // RSqlBlobWriteStream::WriteL
1.996 + t3.HomeTime();
1.997 + err = TheDb.Exec(_L8("BEGIN"));
1.998 + TEST(err >= 0);
1.999 + RSqlBlobWriteStream strm;
1.1000 + CleanupClosePushL(strm);
1.1001 + strm.OpenL(TheDb, _L("A"), _L("B"));
1.1002 + strm.WriteL(dataPtr);
1.1003 + CleanupStack::PopAndDestroy(&strm);
1.1004 + err = TheDb.Exec(_L8("COMMIT"));
1.1005 + t4.HomeTime();
1.1006 + TEST(err >= 0);
1.1007 +
1.1008 + writeTime = t4.MicroSecondsFrom(t3);
1.1009 +
1.1010 + PrintWriteTime(TTimeIntervalMicroSeconds(0), writeTime, TTimeIntervalMicroSeconds(0));
1.1011 + PrintFileSize(TheDb);
1.1012 +
1.1013 + TheDb.Close();
1.1014 + (void)RSqlDatabase::Delete(TheDbFileName);
1.1015 +
1.1016 + delete buf;
1.1017 + }
1.1018 +
1.1019 +/**
1.1020 +@SYMTestCaseID SYSLIB-SQL-UT-4119
1.1021 +@SYMTestCaseDesc SQL, whole BLOB read, performance tests.
1.1022 + Tests reading a 256Kb blob in one block to examine the
1.1023 + relative performance of the TSqlBlob and RSqlBlobReadStream APIs.
1.1024 +@SYMTestPriority Medium
1.1025 +@SYMTestActions Whole retrieval of a blob using the new TSqlBlob and RSqlBlobReadStream APIs.
1.1026 +@SYMTestExpectedResults Test must not fail
1.1027 +@SYMREQ REQ5912
1.1028 +*/
1.1029 +void WholeReadTestL()
1.1030 + {
1.1031 + TInt bufLen = TheBlobSize;
1.1032 + HBufC8* buf = HBufC8::NewL(bufLen);
1.1033 + TPtr8 dataPtr = buf->Des();
1.1034 + dataPtr.SetLength(bufLen);
1.1035 + dataPtr.Fill('A', bufLen);
1.1036 +
1.1037 + CreateTestDb();
1.1038 + InsertRealBlob(); // insert blob of "TheBlobSize" size
1.1039 +
1.1040 + TheTest.Printf(_L("***WholeReadTestL - %dKb blob \r\n"), TheBlobSize / 1024);
1.1041 + PrintFileSize(TheDb);
1.1042 +
1.1043 + // TSqlBlob::GetLC
1.1044 + TTimeIntervalMicroSeconds readTime;
1.1045 + TTime t1, t2, t3, t4, t5, t6;
1.1046 +
1.1047 + t1.HomeTime();
1.1048 + HBufC8* readBuf = TSqlBlob::GetLC(TheDb, _L("A"), _L("B"));
1.1049 + t2.HomeTime();
1.1050 + TEST(readBuf->Des().Compare(buf->Des()) == 0);
1.1051 +
1.1052 + readTime = t2.MicroSecondsFrom(t1);
1.1053 +
1.1054 + PrintReadTime(TTimeIntervalMicroSeconds(0), readTime);
1.1055 + PrintFileSize(TheDb);
1.1056 + CleanupStack::PopAndDestroy(readBuf);
1.1057 +
1.1058 + // to avoid caching issues, close and re-create the database for the next part
1.1059 + TheDb.Close();
1.1060 + (void)RSqlDatabase::Delete(TheDbFileName);
1.1061 + CreateTestDb();
1.1062 + InsertRealBlob(); // insert blob of "TheBlobSize" size
1.1063 + PrintFileSize(TheDb);
1.1064 +
1.1065 + // TSqlBlob::Get
1.1066 + HBufC8* preBuf = HBufC8::NewLC(bufLen);
1.1067 + TPtr8 preBufPtr(preBuf->Des());
1.1068 + t3.HomeTime();
1.1069 + TInt err = TSqlBlob::Get(TheDb, _L("A"), _L("B"), preBufPtr);
1.1070 + t4.HomeTime();
1.1071 + TEST2(err, KErrNone);
1.1072 + TEST(preBufPtr.Compare(buf->Des()) == 0);
1.1073 +
1.1074 + readTime = t4.MicroSecondsFrom(t3);
1.1075 +
1.1076 + PrintReadTime(TTimeIntervalMicroSeconds(0), readTime);
1.1077 + PrintFileSize(TheDb);
1.1078 + CleanupStack::PopAndDestroy(preBuf);
1.1079 +
1.1080 + // to avoid caching issues, close and re-create the database for the next part
1.1081 + TheDb.Close();
1.1082 + (void)RSqlDatabase::Delete(TheDbFileName);
1.1083 + CreateTestDb();
1.1084 + InsertRealBlob(); // insert blob of "TheBlobSize" size
1.1085 + PrintFileSize(TheDb);
1.1086 +
1.1087 + // RSqlBlobReadStream::ReadL
1.1088 + preBuf = HBufC8::NewLC(bufLen);
1.1089 + TPtr8 preBufP(preBuf->Des());
1.1090 + t5.HomeTime();
1.1091 + RSqlBlobReadStream strm;
1.1092 + CleanupClosePushL(strm);
1.1093 + strm.OpenL(TheDb, _L("A"), _L("B"));
1.1094 + strm.ReadL(preBufP, bufLen);
1.1095 + CleanupStack::PopAndDestroy(&strm);
1.1096 + t6.HomeTime();
1.1097 + TEST(preBufP.Compare(buf->Des()) == 0);
1.1098 +
1.1099 + readTime = t6.MicroSecondsFrom(t5);
1.1100 +
1.1101 + PrintReadTime(TTimeIntervalMicroSeconds(0), readTime);
1.1102 + PrintFileSize(TheDb);
1.1103 + CleanupStack::PopAndDestroy(preBuf);
1.1104 +
1.1105 + TheDb.Close();
1.1106 + (void)RSqlDatabase::Delete(TheDbFileName);
1.1107 +
1.1108 + delete buf;
1.1109 + }
1.1110 +///////////////////////////////////////////////////////////////////////////////////
1.1111 +///////////////////////////////////////////////////////////////////////////////////
1.1112 +
1.1113 +void DoTests()
1.1114 + {
1.1115 + TheTestTitle.Format(_L("@SYMTestCaseID:SYSLIB-SQL-UT-4084 SQL, BLOB write, performance tests, encoding: \"%S\", page size: %d\r\n"),
1.1116 + TheCmdLineParams.iDbEncoding == TCmdLineParams::EDbUtf16 ? &KUtf16 : &KUtf8, TheCmdLineParams.iPageSize);
1.1117 + TheTest.Start(TheTestTitle);
1.1118 + BlobWriteTest();
1.1119 +
1.1120 + TheTestTitle.Format(_L("@SYMTestCaseID:SYSLIB-SQL-UT-4085 SQL, BLOB read, performance tests, encoding: \"%S\", page size: %d\r\n"),
1.1121 + TheCmdLineParams.iDbEncoding == TCmdLineParams::EDbUtf16 ? &KUtf16 : &KUtf8, TheCmdLineParams.iPageSize);
1.1122 + TheTest.Next(TheTestTitle);
1.1123 + BlobReadTest();
1.1124 +
1.1125 + TheTest.Printf(_L("==================================================================\r\n"));
1.1126 +
1.1127 + // Bigger blob tests - only on hardware, release mode
1.1128 +#if !defined __WINS__ && !defined __WINSCW__ && !defined _DEBUG
1.1129 +
1.1130 + TheBlobSize = 1024 * 1024 + 128 * 1024;//1.125Mb
1.1131 +
1.1132 + TheTestTitle.Format(_L("@SYMTestCaseID:SYSLIB-SQL-UT-4115 SQL, sequential BLOB writes, performance tests, encoding: \"%S\", page size: %d\r\n"),
1.1133 + TheCmdLineParams.iDbEncoding == TCmdLineParams::EDbUtf16 ? &KUtf16 : &KUtf8, TheCmdLineParams.iPageSize);
1.1134 + TheTest.Next(TheTestTitle);
1.1135 + TRAPD(err, SequentialWriteTestL());
1.1136 + TEST2(err, KErrNone);
1.1137 +
1.1138 + TheTestTitle.Format(_L("@SYMTestCaseID:SYSLIB-SQL-UT-4116 SQL, transaction sequential BLOB writes, performance tests, encoding: \"%S\", page size: %d\r\n"),
1.1139 + TheCmdLineParams.iDbEncoding == TCmdLineParams::EDbUtf16 ? &KUtf16 : &KUtf8, TheCmdLineParams.iPageSize);
1.1140 + TheTest.Next(TheTestTitle);
1.1141 + TRAP(err, TransSequentialWriteTestL());
1.1142 + TEST2(err, KErrNone);
1.1143 +
1.1144 + TheBlobSize = 256 * 1024 ; // 256Kb
1.1145 +
1.1146 + TheTestTitle.Format(_L("@SYMTestCaseID:SYSLIB-SQL-UT-4117 SQL, whole BLOB write, performance tests, encoding: \"%S\", page size: %d\r\n"),
1.1147 + TheCmdLineParams.iDbEncoding == TCmdLineParams::EDbUtf16 ? &KUtf16 : &KUtf8, TheCmdLineParams.iPageSize);
1.1148 + TheTest.Next(TheTestTitle);
1.1149 + TRAP(err, WholeWriteTestL());
1.1150 + TEST2(err, KErrNone);
1.1151 +
1.1152 + TheTestTitle.Format(_L("@SYMTestCaseID:SYSLIB-SQL-UT-4118 SQL, transaction whole BLOB write, performance tests, encoding: \"%S\", page size: %d\r\n"),
1.1153 + TheCmdLineParams.iDbEncoding == TCmdLineParams::EDbUtf16 ? &KUtf16 : &KUtf8, TheCmdLineParams.iPageSize);
1.1154 + TheTest.Next(TheTestTitle);
1.1155 + TRAP(err, TransWholeWriteTestL());
1.1156 + TEST2(err, KErrNone);
1.1157 +
1.1158 + TheTestTitle.Format(_L("@SYMTestCaseID:SYSLIB-SQL-UT-4119 SQL, whole BLOB read, performance tests, encoding: \"%S\", page size: %d\r\n"),
1.1159 + TheCmdLineParams.iDbEncoding == TCmdLineParams::EDbUtf16 ? &KUtf16 : &KUtf8, TheCmdLineParams.iPageSize);
1.1160 + TheTest.Next(TheTestTitle);
1.1161 + TRAP(err, WholeReadTestL());
1.1162 + TEST2(err, KErrNone);
1.1163 +
1.1164 +#endif//!defined __WINS__ && !defined __WINSCW__ && !defined _DEBUG
1.1165 + }
1.1166 +
1.1167 +TInt E32Main()
1.1168 + {
1.1169 + TheTest.Title();
1.1170 +
1.1171 + CTrapCleanup* tc = CTrapCleanup::New();
1.1172 + TheTest(tc != NULL);
1.1173 +
1.1174 + __UHEAP_MARK;
1.1175 +
1.1176 + GetCmdLineParamsAndSqlConfigString(TheTest, _L("t_sqlperformance2"), TheCmdLineParams, TheSqlConfigString);
1.1177 + _LIT(KDbName, "c:\\test\\t_sqlperformance2.db");
1.1178 + PrepareDbName(KDbName, TheCmdLineParams.iDriveName, TheDbFileName);
1.1179 +
1.1180 + TheTest.Printf(_L("==Databases: %S\r\n"), &TheDbFileName);
1.1181 +
1.1182 + TestEnvInit();
1.1183 + DoTests();
1.1184 + TestEnvDestroy();
1.1185 +
1.1186 + __UHEAP_MARKEND;
1.1187 +
1.1188 + TheTest.End();
1.1189 + TheTest.Close();
1.1190 +
1.1191 + delete tc;
1.1192 +
1.1193 + User::Heap().Check();
1.1194 + return KErrNone;
1.1195 + }
1.1196 +
1.1197 +