|
1 // Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies). |
|
2 // All rights reserved. |
|
3 // This component and the accompanying materials are made available |
|
4 // under the terms of "Eclipse Public License v1.0" |
|
5 // which accompanies this distribution, and is available |
|
6 // at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
7 // |
|
8 // Initial Contributors: |
|
9 // Nokia Corporation - initial contribution. |
|
10 // |
|
11 // Contributors: |
|
12 // |
|
13 // Description: |
|
14 // |
|
15 |
|
16 #include <e32test.h> |
|
17 #include <e32math.h> |
|
18 #include <bautils.h> |
|
19 #include <hal.h> |
|
20 #include <stdlib.h> |
|
21 #include <sqldb.h> |
|
22 #include "SqlSrvStrings.h" |
|
23 #include "sqlite3.h" |
|
24 #include "SqliteSymbian.h" |
|
25 |
|
26 /////////////////////////////////////////////////////////////////////////////////////// |
|
27 |
|
28 RTest TheTest(_L("t_sqlperformance test")); |
|
29 RFs TheFs; |
|
30 |
|
31 TBuf<200> TheTestTitle; |
|
32 TBuf<256> TheCmd; |
|
33 TParse TheParse; |
|
34 TBuf<8> TheDriveName; |
|
35 |
|
36 _LIT8(KDbEncodingUtf8, "encoding=UTF-8"); |
|
37 _LIT(KDbEncodingUtf8text, "UTF8 encoded db"); |
|
38 _LIT(KDbEncodingUtf16text, "UTF16 encoded db"); |
|
39 |
|
40 TFileName TheSecureDbName; |
|
41 TFileName TheNonSecureDbName; |
|
42 TFileName TheNonSecureDbName2; |
|
43 TFileName TheNonSecureTmpDbName; |
|
44 TFileName TheSglRecDbFileName; |
|
45 |
|
46 enum TDbEncoding |
|
47 { |
|
48 EDbUtf8, |
|
49 EDbUtf16 |
|
50 }; |
|
51 |
|
52 TDbEncoding TheDbEncoding; |
|
53 |
|
54 _LIT(KSqlServerPrivateDir, "\\private\\10281e17\\"); |
|
55 |
|
56 _LIT(KCreateDbScript, "z:\\test\\contacts_schema_to_vendors.sql"); |
|
57 _LIT(KFillDbScript, "z:\\test\\add_simple_contacts.sql"); |
|
58 |
|
59 _LIT8(KCommitStr8, "COMMIT;"); |
|
60 _LIT16(KCommitStr16, "COMMIT;"); |
|
61 |
|
62 _LIT8(KUpdateSql8, "UPDATE IDENTITYTABLE SET CM_FIRSTNAME=:V1, CM_LASTNAME=:V2,CM_COMPANYNAME=:V3 WHERE PARENT_CMID=:ID"); |
|
63 _LIT16(KUpdateSql16, "UPDATE IDENTITYTABLE SET CM_FIRSTNAME=:V1, CM_LASTNAME=:V2,CM_COMPANYNAME=:V3 WHERE PARENT_CMID=:ID"); |
|
64 |
|
65 _LIT8(KUpdateSql2_8, "UPDATE IDENTITYTABLE SET CM_FIRSTNAME='%S%d',CM_LASTNAME='%S%d',CM_COMPANYNAME='%S%d' WHERE PARENT_CMID=%d"); |
|
66 _LIT16(KUpdateSql2_16, "UPDATE IDENTITYTABLE SET CM_FIRSTNAME='%S%d',CM_LASTNAME='%S%d',CM_COMPANYNAME='%S%d' WHERE PARENT_CMID=%d"); |
|
67 |
|
68 _LIT8(KSelectSql8, "SELECT CM_FIRSTNAME, CM_LASTNAME, CM_COMPANYNAME FROM IDENTITYTABLE WHERE PARENT_CMID > 50"); |
|
69 _LIT16(KSelectSql16, "SELECT CM_FIRSTNAME, CM_LASTNAME, CM_COMPANYNAME FROM IDENTITYTABLE WHERE PARENT_CMID > 50"); |
|
70 |
|
71 _LIT8(KDeleteSql8, "DELETE FROM IDENTITYTABLE WHERE PARENT_CMID > 50"); |
|
72 _LIT16(KDeleteSql16, "DELETE FROM IDENTITYTABLE WHERE PARENT_CMID > 50"); |
|
73 |
|
74 extern TPtrC GetFirstSqlStmt(TPtr& aString); |
|
75 |
|
76 _LIT(KFirstName, "FirstName-"); |
|
77 _LIT(KLastName, "LastName-"); |
|
78 _LIT(KCompanyName, "CompanyName-"); |
|
79 |
|
80 _LIT(KFirstName2, "12345678-"); |
|
81 _LIT(KLastName2, "ABCDEFGHIJK-"); |
|
82 _LIT(KCompanyName2, "KKKKKKKKKK10-"); |
|
83 |
|
84 const char* KRawPrmName1 = ":V1"; |
|
85 const char* KRawPrmName2 = ":V2"; |
|
86 const char* KRawPrmName3 = ":V3"; |
|
87 const char* KRawPrmName4 = ":ID"; |
|
88 |
|
89 _LIT(KPrmName1, ":V1"); |
|
90 _LIT(KPrmName2, ":V2"); |
|
91 _LIT(KPrmName3, ":V3"); |
|
92 _LIT(KPrmName4, ":ID"); |
|
93 |
|
94 const TInt KTestTecordCount = 1000; |
|
95 |
|
96 /////////////////////////////////////////////////////////////////////////////////////// |
|
97 |
|
98 void TestEnvDestroy() |
|
99 { |
|
100 (void)RSqlDatabase::Delete(TheNonSecureTmpDbName); |
|
101 (void)RSqlDatabase::Delete(TheNonSecureDbName2); |
|
102 (void)RSqlDatabase::Delete(TheNonSecureDbName); |
|
103 (void)RSqlDatabase::Delete(TheSecureDbName); |
|
104 TheFs.Close(); |
|
105 } |
|
106 |
|
107 /////////////////////////////////////////////////////////////////////////////////////// |
|
108 /////////////////////////////////////////////////////////////////////////////////////// |
|
109 //Test macros and functions |
|
110 void Check1(TInt aValue, TInt aLine) |
|
111 { |
|
112 if(!aValue) |
|
113 { |
|
114 TestEnvDestroy(); |
|
115 TheTest.Printf(_L("*** Line %d\r\n"), aLine); |
|
116 TheTest(EFalse, aLine); |
|
117 } |
|
118 } |
|
119 void Check2(TInt aValue, TInt aExpected, TInt aLine) |
|
120 { |
|
121 if(aValue != aExpected) |
|
122 { |
|
123 TestEnvDestroy(); |
|
124 TheTest.Printf(_L("*** Line %d, Expected error: %d, got: %d\r\n"), aLine, aExpected, aValue); |
|
125 TheTest(EFalse, aLine); |
|
126 } |
|
127 } |
|
128 #define TEST(arg) ::Check1((arg), __LINE__) |
|
129 #define TEST2(aValue, aExpected) ::Check2(aValue, aExpected, __LINE__) |
|
130 |
|
131 /////////////////////////////////////////////////////////////////////////////////////// |
|
132 |
|
133 void TestEnvInit() |
|
134 { |
|
135 TInt err = TheFs.Connect(); |
|
136 TEST2(err, KErrNone); |
|
137 |
|
138 err = TheFs.MkDir(TheNonSecureDbName); |
|
139 TEST(err == KErrNone || err == KErrAlreadyExists); |
|
140 } |
|
141 |
|
142 //Reads a SQL file and returns the file content as HBUFC string. |
|
143 //The caller is responsible for destroying the returned HBUFC object. |
|
144 template <class HBUFC> HBUFC* ReadSqlScript(const TDesC& aSqlFileName) |
|
145 { |
|
146 RFile file; |
|
147 TEST2(file.Open(TheFs, aSqlFileName, EFileRead), KErrNone); |
|
148 |
|
149 TInt size = 0; |
|
150 TEST2(file.Size(size), KErrNone); |
|
151 |
|
152 HBufC8* sql = HBufC8::New(size); |
|
153 TEST(sql != NULL); |
|
154 |
|
155 TPtr8 ptr = sql->Des(); |
|
156 TEST2(file.Read(ptr, size), KErrNone); |
|
157 |
|
158 file.Close(); |
|
159 |
|
160 HBUFC* sql2 = HBUFC::New(size); |
|
161 TEST(sql2 != NULL); |
|
162 sql2->Des().Copy(sql->Des()); |
|
163 delete sql; |
|
164 |
|
165 return sql2; |
|
166 } |
|
167 //Explicit ReadSqlScript() template instantiations. |
|
168 template HBufC8* ReadSqlScript<HBufC8>(const TDesC&); |
|
169 template HBufC16* ReadSqlScript<HBufC16>(const TDesC&); |
|
170 |
|
171 //Searches for the next aCommitStr appearance in aSqlScript string and returns a PTRC object holding |
|
172 //the SQL strings from the beginning of aSqlScript till the aCommitStr (including it). |
|
173 template <class PTRC, class DESC> PTRC GetNextTrans(PTRC& aSqlScript, const DESC& aCommitStr) |
|
174 { |
|
175 PTRC res(NULL, 0); |
|
176 TInt pos = aSqlScript.FindF(aCommitStr); |
|
177 if(pos >= 0) |
|
178 { |
|
179 pos += aCommitStr.Length(); |
|
180 res.Set(aSqlScript.Left(pos)); |
|
181 aSqlScript.Set(aSqlScript.Mid(pos)); |
|
182 } |
|
183 return res; |
|
184 } |
|
185 //Explicit GetNextTrans() template instantiations. |
|
186 template TPtrC8 GetNextTrans<TPtrC8, TDesC8>(TPtrC8&, const TDesC8&); |
|
187 template TPtrC16 GetNextTrans<TPtrC16, TDesC16>(TPtrC16&, const TDesC16&); |
|
188 |
|
189 //Prints aTicks parameter (converted to ms) |
|
190 void PrintStats(TUint32 aStartTicks, TUint32 aEndTicks) |
|
191 { |
|
192 static TInt freq = 0; |
|
193 if(freq == 0) |
|
194 { |
|
195 TEST2(HAL::Get(HAL::EFastCounterFrequency, freq), KErrNone); |
|
196 } |
|
197 TInt64 diffTicks = (TInt64)aEndTicks - (TInt64)aStartTicks; |
|
198 if(diffTicks < 0) |
|
199 { |
|
200 diffTicks = KMaxTUint32 + diffTicks + 1; |
|
201 } |
|
202 const TInt KMicroSecIn1Sec = 1000000; |
|
203 TInt32 us = (diffTicks * KMicroSecIn1Sec) / freq; |
|
204 TheTest.Printf(_L("####Execution time: %d ms\r\n"), us / 1000); |
|
205 } |
|
206 |
|
207 void PrintFileSize(const TDesC& aFileName) |
|
208 { |
|
209 TParse parse; |
|
210 parse.Set(aFileName, &KSqlServerPrivateDir(), 0); |
|
211 RFile file; |
|
212 TInt err = file.Open(TheFs, parse.FullName(), EFileRead); |
|
213 TEST2(err, KErrNone); |
|
214 TInt size = 0; |
|
215 err = file.Size(size); |
|
216 TEST2(err, KErrNone); |
|
217 TheTest.Printf(_L("####FileSize: %d\r\n"), size); |
|
218 file.Close(); |
|
219 } |
|
220 |
|
221 ////////////////////////////////////////////////////////////////////////////////////////////////////////////// |
|
222 /////// SQL SERVER performance tests |
|
223 ////////////////////////////////////////////////////////////////////////////////////////////////////////////// |
|
224 |
|
225 enum TDbType {ENonSecureDb, ESecureDb}; |
|
226 |
|
227 //Template class offering Create() and Open() methods for creating/opening a RSqlDatabase object |
|
228 template <TDbType TYPE> class TDbHelper |
|
229 { |
|
230 public: |
|
231 static void Create(const TDesC& aDbName); |
|
232 static RSqlDatabase Open(const TDesC& aDbName); |
|
233 }; |
|
234 |
|
235 //Creates aDb database schema. |
|
236 void CreateDbSchema(RSqlDatabase& aDb) |
|
237 { |
|
238 HBufC8* createDbScript = ReadSqlScript<HBufC8>(KCreateDbScript()); |
|
239 TInt err = aDb.Exec(createDbScript->Des()); |
|
240 TEST(err >= 0); |
|
241 delete createDbScript; |
|
242 } |
|
243 |
|
244 //Explicit TDbHelper class specialization for creating/opening a nonsecure RSqlDatabase object |
|
245 template <> class TDbHelper<ENonSecureDb> |
|
246 { |
|
247 public: |
|
248 static void Create(const TDesC& aDbName) |
|
249 { |
|
250 RSqlDatabase::Delete(aDbName); |
|
251 RSqlDatabase db; |
|
252 TInt err = db.Create(aDbName, TheDbEncoding == EDbUtf16 ? NULL : &KDbEncodingUtf8); |
|
253 TEST2(err, KErrNone); |
|
254 CreateDbSchema(db); |
|
255 db.Close(); |
|
256 } |
|
257 static RSqlDatabase Open(const TDesC& aDbName) |
|
258 { |
|
259 RSqlDatabase db; |
|
260 TInt err = db.Open(aDbName); |
|
261 TEST2(err, KErrNone); |
|
262 return db; |
|
263 } |
|
264 }; |
|
265 |
|
266 //Explicit TDbHelper class specialization for creating/opening a secure RSqlDatabase object |
|
267 template <> class TDbHelper<ESecureDb> |
|
268 { |
|
269 public: |
|
270 static void Create(const TDesC& aDbName) |
|
271 { |
|
272 RSqlDatabase::Delete(aDbName); |
|
273 RSqlSecurityPolicy securityPolicy; |
|
274 TInt err = securityPolicy.Create(TSecurityPolicy(TSecurityPolicy::EAlwaysPass)); |
|
275 TEST2(err, KErrNone); |
|
276 securityPolicy.SetDbPolicy(RSqlSecurityPolicy::ESchemaPolicy, TSecurityPolicy(ECapabilityReadUserData, ECapabilityWriteUserData)); |
|
277 securityPolicy.SetDbPolicy(RSqlSecurityPolicy::EWritePolicy, TSecurityPolicy(ECapabilityWriteUserData)); |
|
278 securityPolicy.SetDbPolicy(RSqlSecurityPolicy::EReadPolicy, TSecurityPolicy(ECapabilityReadUserData)); |
|
279 RSqlDatabase db; |
|
280 err = db.Create(aDbName, securityPolicy, TheDbEncoding == EDbUtf16 ? NULL : &KDbEncodingUtf8); |
|
281 TEST2(err, KErrNone); |
|
282 securityPolicy.Close(); |
|
283 CreateDbSchema(db); |
|
284 db.Close(); |
|
285 } |
|
286 static RSqlDatabase Open(const TDesC& aDbName) |
|
287 { |
|
288 RSqlDatabase db; |
|
289 TInt err = db.Open(aDbName); |
|
290 TEST2(err, KErrNone); |
|
291 return db; |
|
292 } |
|
293 }; |
|
294 |
|
295 //Executes SQL script |
|
296 template <class HBUFC, class PTRC, class DESC> void ExecuteSqlScript(RSqlDatabase& aDb, const TDesC& aScriptFileName, const DESC& aCommitStr) |
|
297 { |
|
298 HBUFC* fillDbScript = ReadSqlScript<HBUFC>(aScriptFileName); |
|
299 TUint32 start = User::FastCounter(); |
|
300 PTRC ptr(fillDbScript->Des()); |
|
301 PTRC sql(GetNextTrans<PTRC, DESC>(ptr, aCommitStr)); |
|
302 while(sql.Length() > 0) |
|
303 { |
|
304 TInt err = aDb.Exec(sql); |
|
305 if(err == KErrNoMemory) |
|
306 { |
|
307 TheTest.Printf(_L("###ERROR 'Out of memory'! The test cannot be completed!\r\n")); |
|
308 return; |
|
309 } |
|
310 TEST(err > 0); |
|
311 sql.Set(GetNextTrans<PTRC, DESC>(ptr, aCommitStr)); |
|
312 } |
|
313 TUint32 end = User::FastCounter(); |
|
314 PrintStats(start, end); |
|
315 delete fillDbScript; |
|
316 } |
|
317 //Explicit ExecuteSqlScript() template instantiations. |
|
318 template void ExecuteSqlScript<HBufC8, TPtrC8, TDesC8>(RSqlDatabase&, const TDesC&, const TDesC8&); |
|
319 template void ExecuteSqlScript<HBufC16, TPtrC16, TDesC16>(RSqlDatabase&, const TDesC&, const TDesC16&); |
|
320 |
|
321 /////////////////////////////////////////////////////////////////////////////////////// |
|
322 |
|
323 //"INSERT" test function |
|
324 template <class HBUFC, class PTRC, class DESC, TDbType TYPE> void InsertTest(const TDesC& aDbFileName, const DESC& aCommitStr) |
|
325 { |
|
326 TheTest.Printf(_L("\"Insert\" test\r\n")); |
|
327 RSqlDatabase db = TDbHelper<TYPE>::Open(aDbFileName); |
|
328 ExecuteSqlScript<HBUFC, PTRC, DESC>(db, KFillDbScript, aCommitStr); |
|
329 db.Close(); |
|
330 } |
|
331 //Explicit InsertTest() template instantiations. |
|
332 template void InsertTest<HBufC8, TPtrC8, TDesC8, ENonSecureDb>(const TDesC&, const TDesC8&); |
|
333 template void InsertTest<HBufC8, TPtrC8, TDesC8, ESecureDb>(const TDesC&, const TDesC8&); |
|
334 template void InsertTest<HBufC16, TPtrC16, TDesC16, ENonSecureDb>(const TDesC&, const TDesC16&); |
|
335 template void InsertTest<HBufC16, TPtrC16, TDesC16, ESecureDb>(const TDesC&, const TDesC16&); |
|
336 |
|
337 //"UPDATE" test function (parametrized update) |
|
338 template <class DESC, TDbType TYPE> void UpdateTest(const TDesC& aDbFileName, const DESC& aUpdateSql) |
|
339 { |
|
340 TheTest.Printf(_L("\"Update (parametrized)\" test\r\n")); |
|
341 RSqlDatabase db = TDbHelper<TYPE>::Open(aDbFileName); |
|
342 RSqlStatement stmt; |
|
343 TInt err = stmt.Prepare(db, aUpdateSql); |
|
344 TEST2(err, KErrNone); |
|
345 |
|
346 TInt firstNamePrmIdx = stmt.ParameterIndex(KPrmName1()); |
|
347 TEST(firstNamePrmIdx >= 0); |
|
348 TInt lastNamePrmIdx = stmt.ParameterIndex(KPrmName2()); |
|
349 TEST(lastNamePrmIdx >= 0); |
|
350 TInt companyNamePrmIdx = stmt.ParameterIndex(KPrmName3()); |
|
351 TEST(companyNamePrmIdx >= 0); |
|
352 TInt idIdx = stmt.ParameterIndex(KPrmName4()); |
|
353 TEST(idIdx >= 0); |
|
354 |
|
355 TUint32 start = User::FastCounter(); |
|
356 for(TInt id=1;id<=KTestTecordCount;++id) |
|
357 { |
|
358 TBuf<20> buf; |
|
359 buf.Copy(KFirstName); |
|
360 buf.AppendNum(id); |
|
361 err = stmt.BindText(firstNamePrmIdx, buf); |
|
362 TEST2(err, KErrNone); |
|
363 buf.Copy(KLastName); |
|
364 buf.AppendNum(id); |
|
365 err = stmt.BindText(lastNamePrmIdx, buf); |
|
366 TEST2(err, KErrNone); |
|
367 buf.Copy(KCompanyName); |
|
368 buf.AppendNum(id); |
|
369 err = stmt.BindText(companyNamePrmIdx, buf); |
|
370 TEST2(err, KErrNone); |
|
371 err = stmt.BindInt(idIdx, id); |
|
372 TEST2(err, KErrNone); |
|
373 err = stmt.Exec(); |
|
374 TEST(err > 0); |
|
375 err = stmt.Reset(); |
|
376 TEST2(err, KErrNone); |
|
377 } |
|
378 TUint32 end = User::FastCounter(); |
|
379 PrintStats(start, end); |
|
380 stmt.Close(); |
|
381 db.Close(); |
|
382 } |
|
383 //Explicit UpdateTest() template instantiations. |
|
384 template void UpdateTest<TDesC8, ENonSecureDb>(const TDesC&, const TDesC8&); |
|
385 template void UpdateTest<TDesC8, ESecureDb>(const TDesC&, const TDesC8&); |
|
386 template void UpdateTest<TDesC16, ENonSecureDb>(const TDesC&, const TDesC16&); |
|
387 template void UpdateTest<TDesC16, ESecureDb>(const TDesC&, const TDesC16&); |
|
388 |
|
389 //"UPDATE" test function (without parameters) - SQL server |
|
390 template <class BUF, class DESC, TDbType TYPE> void UpdateWPTest(const TDesC& aDbFileName, const DESC& aUpdateSql) |
|
391 { |
|
392 TheTest.Printf(_L("\"Update (without parameters)\" test\r\n")); |
|
393 RSqlDatabase db = TDbHelper<TYPE>::Open(aDbFileName); |
|
394 TBuf<200> fmtstr; |
|
395 fmtstr.Copy(aUpdateSql); |
|
396 |
|
397 TUint32 start = User::FastCounter(); |
|
398 for(TInt id=1;id<=KTestTecordCount;++id) |
|
399 { |
|
400 TBuf<200> buf; |
|
401 buf.Format(fmtstr, &KFirstName2, id, &KLastName2, id, &KCompanyName2, id, id); |
|
402 BUF sql; |
|
403 sql.Copy(buf); |
|
404 TInt err = db.Exec(sql); |
|
405 TEST(err > 0); |
|
406 } |
|
407 TUint32 end = User::FastCounter(); |
|
408 PrintStats(start, end); |
|
409 db.Close(); |
|
410 PrintFileSize(aDbFileName); |
|
411 } |
|
412 //Explicit UpdateWPTest() template instantiations. |
|
413 template void UpdateWPTest<TBuf8<200>, TDesC8, ENonSecureDb>(const TDesC&, const TDesC8&); |
|
414 template void UpdateWPTest<TBuf8<200>, TDesC8, ESecureDb>(const TDesC&, const TDesC8&); |
|
415 template void UpdateWPTest<TBuf16<200>, TDesC16, ENonSecureDb>(const TDesC&, const TDesC16&); |
|
416 template void UpdateWPTest<TBuf16<200>, TDesC16, ESecureDb>(const TDesC&, const TDesC16&); |
|
417 |
|
418 //"SELECT" test function |
|
419 template <class DESC, TDbType TYPE> void SelectTest(const TDesC& aDbFileName, const DESC& aSelectSql) |
|
420 { |
|
421 TheTest.Printf(_L("\"Select\" test\r\n")); |
|
422 RSqlDatabase db = TDbHelper<TYPE>::Open(aDbFileName); |
|
423 RSqlStatement stmt; |
|
424 TInt err = stmt.Prepare(db, aSelectSql); |
|
425 TEST2(err, KErrNone); |
|
426 TUint32 start = User::FastCounter(); |
|
427 while((err = stmt.Next()) == KSqlAtRow) |
|
428 { |
|
429 TBuf<20> buf; |
|
430 err = stmt.ColumnText(0, buf); |
|
431 TEST2(err, KErrNone); |
|
432 TEST(buf.Length() > 0); |
|
433 err = stmt.ColumnText(1, buf); |
|
434 TEST2(err, KErrNone); |
|
435 TEST(buf.Length() > 0); |
|
436 err = stmt.ColumnText(2, buf); |
|
437 TEST2(err, KErrNone); |
|
438 TEST(buf.Length() > 0); |
|
439 } |
|
440 TEST2(err, KSqlAtEnd); |
|
441 TUint32 end = User::FastCounter(); |
|
442 PrintStats(start, end); |
|
443 stmt.Close(); |
|
444 db.Close(); |
|
445 } |
|
446 //Explicit SelectTest() template instantiations. |
|
447 template void SelectTest<TDesC8, ENonSecureDb>(const TDesC&, const TDesC8&); |
|
448 template void SelectTest<TDesC8, ESecureDb>(const TDesC&, const TDesC8&); |
|
449 template void SelectTest<TDesC16, ENonSecureDb>(const TDesC&, const TDesC16&); |
|
450 template void SelectTest<TDesC16, ESecureDb>(const TDesC&, const TDesC16&); |
|
451 |
|
452 //"DELETE" test function |
|
453 template <class DESC, TDbType TYPE> void DeleteTest(const TDesC& aDbFileName, const DESC& aDeleteSql) |
|
454 { |
|
455 TheTest.Printf(_L("\"Delete\" test\r\n")); |
|
456 RSqlDatabase db = TDbHelper<TYPE>::Open(aDbFileName); |
|
457 TUint32 start = User::FastCounter(); |
|
458 TInt err = db.Exec(aDeleteSql); |
|
459 TEST(err > 0); |
|
460 TUint32 end = User::FastCounter(); |
|
461 PrintStats(start, end); |
|
462 db.Close(); |
|
463 } |
|
464 //Explicit SelectTest() template instantiations. |
|
465 template void DeleteTest<TDesC8, ENonSecureDb>(const TDesC&, const TDesC8&); |
|
466 template void DeleteTest<TDesC8, ESecureDb>(const TDesC&, const TDesC8&); |
|
467 template void DeleteTest<TDesC16, ENonSecureDb>(const TDesC&, const TDesC16&); |
|
468 template void DeleteTest<TDesC16, ESecureDb>(const TDesC&, const TDesC16&); |
|
469 |
|
470 //Performance test function: INSERT, UPDATE, SELECT |
|
471 template <class HBUFC, class PTRC, class DESC, TDbType TYPE> void PerformanceTest(const TDesC& aDbFileName, |
|
472 const DESC& aCommitStr, |
|
473 const DESC& aUpdateSql, |
|
474 const DESC& aSelectSql, |
|
475 const DESC& aDeleteSql) |
|
476 { |
|
477 CFileMan* fm = NULL; |
|
478 TRAPD(err, fm = CFileMan::NewL(TheFs)); |
|
479 TEST2(err, KErrNone); |
|
480 |
|
481 TDbHelper<TYPE>::Create(aDbFileName); |
|
482 InsertTest<HBUFC, PTRC, DESC, TYPE>(aDbFileName, aCommitStr); |
|
483 PrintFileSize(aDbFileName); |
|
484 (void)fm->Copy(aDbFileName, TheNonSecureTmpDbName); |
|
485 |
|
486 UpdateTest<DESC, TYPE>(aDbFileName, aUpdateSql); |
|
487 PrintFileSize(aDbFileName); |
|
488 SelectTest<DESC, TYPE>(aDbFileName, aSelectSql); |
|
489 |
|
490 DeleteTest<DESC, TYPE>(aDbFileName, aDeleteSql); |
|
491 PrintFileSize(aDbFileName); |
|
492 |
|
493 (void)fm->Copy(TheNonSecureTmpDbName, aDbFileName); |
|
494 (void)fm->Delete(TheNonSecureTmpDbName); |
|
495 delete fm; |
|
496 } |
|
497 //Explicit PerformanceTest() template instantiations. |
|
498 template void PerformanceTest<HBufC8, TPtrC8, TDesC8, ENonSecureDb>(const TDesC&, const TDesC8&, const TDesC8&, const TDesC8&, const TDesC8&); |
|
499 template void PerformanceTest<HBufC8, TPtrC8, TDesC8, ESecureDb>(const TDesC&, const TDesC8&, const TDesC8&, const TDesC8&, const TDesC8&); |
|
500 template void PerformanceTest<HBufC16, TPtrC16, TDesC16, ENonSecureDb>(const TDesC&, const TDesC16&, const TDesC16&, const TDesC16&, const TDesC16&); |
|
501 template void PerformanceTest<HBufC16, TPtrC16, TDesC16, ESecureDb>(const TDesC&, const TDesC16&, const TDesC16&, const TDesC16&, const TDesC16&); |
|
502 |
|
503 ////////////////////////////////////////////////////////////////////////////////////////////////////////////// |
|
504 /////// SQLITE API used directly |
|
505 ////////////////////////////////////////////////////////////////////////////////////////////////////////////// |
|
506 |
|
507 //Template class offering Create() and Open() methods for creating/opening a sqlite3 handle. |
|
508 template <TDbEncoding TYPE> class TDbHelper2 |
|
509 { |
|
510 public: |
|
511 static void Create(const TDesC& aDbName); |
|
512 static sqlite3* Open(const TDesC& aDbName); |
|
513 }; |
|
514 |
|
515 //If error - prints error message and panics the application |
|
516 void PanicIfError(sqlite3* aDbHandle, TInt aErr) |
|
517 { |
|
518 if(aErr != SQLITE_OK && aErr != SQLITE_DONE && aErr != SQLITE_ROW) |
|
519 { |
|
520 if(aDbHandle) |
|
521 { |
|
522 TPtrC p((const TUint16*)sqlite3_errmsg16(aDbHandle)); |
|
523 TheTest.Printf(_L("Database err %d, msg: %S\n\n"), aErr, &p); |
|
524 (void)sqlite3_close(aDbHandle); |
|
525 } |
|
526 TEST(0); |
|
527 } |
|
528 } |
|
529 |
|
530 //If error - prints error message and returns zero |
|
531 TInt ReportIfError(sqlite3* aDbHandle, TInt aErr) |
|
532 { |
|
533 if(aErr != SQLITE_OK && aErr != SQLITE_DONE && aErr != SQLITE_ROW) |
|
534 { |
|
535 if(aDbHandle) |
|
536 { |
|
537 TPtrC p((const TUint16*)sqlite3_errmsg16(aDbHandle)); |
|
538 TheTest.Printf(_L("Database err %d, msg: %S\n\n"), aErr, &p); |
|
539 } |
|
540 return ETrue; |
|
541 } |
|
542 return EFalse; |
|
543 } |
|
544 |
|
545 //Explicit TDbHelper2 class specialization for creating/opening a database with UTF8 default encoding |
|
546 template <> class TDbHelper2<EDbUtf8> |
|
547 { |
|
548 public: |
|
549 static void Create(const TDesC& aDbFileName) |
|
550 { |
|
551 (void)TheFs.Delete(aDbFileName); |
|
552 HBufC8* dbName = HBufC8::New(aDbFileName.Length() + 1); |
|
553 TEST(dbName != NULL); |
|
554 dbName->Des().Copy(aDbFileName); |
|
555 sqlite3* dbHandle = NULL; |
|
556 TInt err = sqlite3_open((const char*)(dbName->Des().PtrZ()), &dbHandle); |
|
557 delete dbName; |
|
558 PanicIfError(dbHandle, err); |
|
559 HBufC8* createDbScript = ReadSqlScript<HBufC8>(KCreateDbScript()); |
|
560 HBufC8* createDbScript2 = HBufC8::New(createDbScript->Des().Length() + 1); |
|
561 TEST(createDbScript2 != NULL); |
|
562 createDbScript2->Des().Copy(createDbScript->Des()); |
|
563 delete createDbScript; |
|
564 createDbScript2->Des().Append(TChar(0)); |
|
565 err = sqlite3_exec(dbHandle, (const char*)createDbScript2->Des().Ptr(), NULL, 0, NULL); |
|
566 PanicIfError(dbHandle, err); |
|
567 delete createDbScript2; |
|
568 (void)sqlite3_close(dbHandle); |
|
569 } |
|
570 static sqlite3* Open(const TDesC& aDbFileName) |
|
571 { |
|
572 HBufC8* dbName = HBufC8::New(aDbFileName.Length() + 1); |
|
573 TEST(dbName != NULL); |
|
574 dbName->Des().Copy(aDbFileName); |
|
575 sqlite3* dbHandle = NULL; |
|
576 TInt err = sqlite3_open((const char*)(dbName->Des().PtrZ()), &dbHandle); |
|
577 delete dbName; |
|
578 PanicIfError(dbHandle, err); |
|
579 return dbHandle; |
|
580 } |
|
581 }; |
|
582 |
|
583 //Explicit TDbHelper2 class specialization for creating/opening a database with UTF16 default encoding |
|
584 template <> class TDbHelper2<EDbUtf16> |
|
585 { |
|
586 public: |
|
587 static void Create(const TDesC& aDbFileName) |
|
588 { |
|
589 (void)TheFs.Delete(aDbFileName); |
|
590 HBufC16* dbName = HBufC16::New(aDbFileName.Length() + 1); |
|
591 TEST(dbName != NULL); |
|
592 dbName->Des().Copy(aDbFileName); |
|
593 sqlite3* dbHandle = NULL; |
|
594 TInt err = sqlite3_open16((const void*)(dbName->Des().PtrZ()), &dbHandle); |
|
595 delete dbName; |
|
596 PanicIfError(dbHandle, err); |
|
597 HBufC8* createDbScript = ReadSqlScript<HBufC8>(KCreateDbScript()); |
|
598 HBufC8* createDbScript2 = HBufC8::New(createDbScript->Des().Length() + 1); |
|
599 TEST(createDbScript2 != NULL); |
|
600 createDbScript2->Des().Copy(createDbScript->Des()); |
|
601 delete createDbScript; |
|
602 createDbScript2->Des().Append(TChar(0)); |
|
603 err = sqlite3_exec(dbHandle, (const char*)createDbScript2->Des().Ptr(), NULL, 0, NULL); |
|
604 PanicIfError(dbHandle, err); |
|
605 delete createDbScript2; |
|
606 (void)sqlite3_close(dbHandle); |
|
607 } |
|
608 static sqlite3* Open(const TDesC& aDbFileName) |
|
609 { |
|
610 HBufC16* dbName = HBufC16::New(aDbFileName.Length() + 1); |
|
611 TEST(dbName != NULL); |
|
612 dbName->Des().Copy(aDbFileName); |
|
613 sqlite3* dbHandle = NULL; |
|
614 TInt err = sqlite3_open16((const void*)(dbName->Des().PtrZ()), &dbHandle); |
|
615 delete dbName; |
|
616 PanicIfError(dbHandle, err); |
|
617 return dbHandle; |
|
618 } |
|
619 }; |
|
620 |
|
621 template <class HBUFC, class PTRC, class DESC> void InsertTest2(sqlite3* aDbHandle, const TDesC& aScriptFileName, const DESC& aCommitStr); |
|
622 |
|
623 //Explicit InsertTest2() template specialization for UTF8 encoded SQL strings |
|
624 template <> void InsertTest2<HBufC8, TPtrC8, TDesC8>(sqlite3* aDbHandle, const TDesC& aScriptFileName, const TDesC8& aCommitStr) |
|
625 { |
|
626 TheTest.Printf(_L("\"Insert\" test\r\n")); |
|
627 HBufC8* fillDbScript = ReadSqlScript<HBufC8>(aScriptFileName); |
|
628 TUint32 start = User::FastCounter(); |
|
629 TPtrC8 ptr(fillDbScript->Des()); |
|
630 TPtrC8 sql(GetNextTrans<TPtrC8, TDesC8>(ptr, aCommitStr)); |
|
631 while(sql.Length() > 0) |
|
632 { |
|
633 TUint8* p = (TUint8*)sql.Ptr(); |
|
634 p[sql.Length() - 1] = 0; |
|
635 TInt err = sqlite3_exec(aDbHandle, (const char*)sql.Ptr(), NULL, 0, NULL); |
|
636 PanicIfError(aDbHandle, err); |
|
637 sql.Set(GetNextTrans<TPtrC8, TDesC8>(ptr, aCommitStr)); |
|
638 } |
|
639 TUint32 end = User::FastCounter(); |
|
640 PrintStats(start, end); |
|
641 delete fillDbScript; |
|
642 } |
|
643 |
|
644 //Explicit InsertTest2() template specialization for UTF16 encoded SQL strings |
|
645 template <> void InsertTest2<HBufC16, TPtrC16, TDesC16>(sqlite3* aDbHandle, const TDesC& aScriptFileName, const TDesC16& aCommitStr) |
|
646 { |
|
647 TheTest.Printf(_L("\"Insert\" test\r\n")); |
|
648 HBufC16* fillDbScript = ReadSqlScript<HBufC16>(aScriptFileName); |
|
649 TUint32 start = User::FastCounter(); |
|
650 TPtrC16 ptr(fillDbScript->Des()); |
|
651 TPtrC16 sql(GetNextTrans<TPtrC16, TDesC16>(ptr, aCommitStr)); |
|
652 while(sql != KNullDesC16) |
|
653 { |
|
654 TPtr16 p((TUint16*)sql.Ptr(), sql.Length(), sql.Length()); |
|
655 TPtrC16 current(KNullDesC16); |
|
656 while(p.Length() > 1) //"> 1" because it is a zero terminated string |
|
657 { |
|
658 current.Set(GetFirstSqlStmt(p)); |
|
659 sqlite3_stmt* stmtHandle = NULL; |
|
660 const void* stmtTail = NULL; |
|
661 TInt err = sqlite3_prepare16_v2(aDbHandle, current.Ptr(), -1, &stmtHandle, &stmtTail); |
|
662 if(stmtHandle) //stmtHandle can be NULL for statements like this: ";". |
|
663 { |
|
664 if(err == SQLITE_OK) |
|
665 { |
|
666 while((err = sqlite3_step(stmtHandle)) == SQLITE_ROW) |
|
667 { |
|
668 } |
|
669 } |
|
670 TInt err2 = sqlite3_finalize(stmtHandle); |
|
671 TEST2(err2, SQLITE_OK); |
|
672 } |
|
673 if(ReportIfError(aDbHandle, err)) |
|
674 { |
|
675 delete fillDbScript; |
|
676 return; |
|
677 } |
|
678 }//while(p.Length() > 1) |
|
679 sql.Set(GetNextTrans<TPtrC16, TDesC16>(ptr, aCommitStr)); |
|
680 }//while(sql != KNullDesC16) |
|
681 TUint32 end = User::FastCounter(); |
|
682 PrintStats(start, end); |
|
683 delete fillDbScript; |
|
684 } |
|
685 |
|
686 template <class HBUFC, class DESC> void UpdateTest2(sqlite3* aDbHandle, const DESC& aUpdateSql); |
|
687 |
|
688 //Explicit UpdateTest2() template specialization for UTF8 encoded SQL strings |
|
689 template <> void UpdateTest2<HBufC8, TDesC8>(sqlite3* aDbHandle, const TDesC8& aUpdateSql) |
|
690 { |
|
691 TheTest.Printf(_L("\"Update\" test\r\n")); |
|
692 HBufC8* sql = HBufC8::New(aUpdateSql.Length() + 1); |
|
693 TEST(sql != NULL); |
|
694 sql->Des().Copy(aUpdateSql); |
|
695 sql->Des().Append(TChar(0)); |
|
696 |
|
697 sqlite3_stmt* stmtHandle = NULL; |
|
698 const char* stmtTail = NULL; |
|
699 TInt err = sqlite3_prepare_v2(aDbHandle, (const char*)sql->Des().Ptr(), -1, &stmtHandle, &stmtTail); |
|
700 delete sql; |
|
701 PanicIfError(aDbHandle, err); |
|
702 TInt firstNamePrmIdx = sqlite3_bind_parameter_index(stmtHandle, KRawPrmName1); |
|
703 TEST(firstNamePrmIdx >= 0); |
|
704 TInt lastNamePrmIdx = sqlite3_bind_parameter_index(stmtHandle, KRawPrmName2); |
|
705 TEST(lastNamePrmIdx >= 0); |
|
706 TInt companyNamePrmIdx = sqlite3_bind_parameter_index(stmtHandle, KRawPrmName3); |
|
707 TEST(companyNamePrmIdx >= 0); |
|
708 TInt idIdx = sqlite3_bind_parameter_index(stmtHandle, KRawPrmName4); |
|
709 TEST(idIdx >= 0); |
|
710 |
|
711 TUint32 start = User::FastCounter(); |
|
712 for(TInt id=1;id<=KTestTecordCount;++id) |
|
713 { |
|
714 TBuf8<20> buf1; |
|
715 buf1.Copy(KFirstName); |
|
716 buf1.AppendNum(id); |
|
717 buf1.Append(TChar(0)); |
|
718 err = sqlite3_bind_text(stmtHandle, firstNamePrmIdx, (const char*)buf1.Ptr(), -1, SQLITE_STATIC); |
|
719 TEST2(err, SQLITE_OK); |
|
720 TBuf8<20> buf2; |
|
721 buf2.Copy(KLastName); |
|
722 buf2.AppendNum(id); |
|
723 buf2.Append(TChar(0)); |
|
724 err = sqlite3_bind_text(stmtHandle, lastNamePrmIdx, (const char*)buf2.Ptr(), -1, SQLITE_STATIC); |
|
725 TEST2(err, SQLITE_OK); |
|
726 TBuf8<20> buf3; |
|
727 buf3.Copy(KCompanyName); |
|
728 buf3.AppendNum(id); |
|
729 buf3.Append(TChar(0)); |
|
730 err = sqlite3_bind_text(stmtHandle, companyNamePrmIdx, (const char*)buf3.Ptr(), -1, SQLITE_STATIC); |
|
731 TEST2(err, SQLITE_OK); |
|
732 err = sqlite3_bind_int(stmtHandle, idIdx, id); |
|
733 TEST2(err, SQLITE_OK); |
|
734 while((err = sqlite3_step(stmtHandle)) == SQLITE_ROW) |
|
735 { |
|
736 } |
|
737 PanicIfError(aDbHandle, err); |
|
738 err = sqlite3_reset(stmtHandle); |
|
739 PanicIfError(aDbHandle, err); |
|
740 } |
|
741 TUint32 end = User::FastCounter(); |
|
742 PrintStats(start, end); |
|
743 err = sqlite3_finalize(stmtHandle); |
|
744 TEST2(err, SQLITE_OK); |
|
745 } |
|
746 |
|
747 //Explicit UpdateTest2() template specialization for UTF16 encoded SQL strings |
|
748 template <> void UpdateTest2<HBufC16, TDesC16>(sqlite3* aDbHandle, const TDesC16& aUpdateSql) |
|
749 { |
|
750 TheTest.Printf(_L("\"Update\" test\r\n")); |
|
751 HBufC16* sql = HBufC16::New(aUpdateSql.Length() + 1); |
|
752 TEST(sql != NULL); |
|
753 sql->Des().Copy(aUpdateSql); |
|
754 sql->Des().Append(TChar(0)); |
|
755 |
|
756 sqlite3_stmt* stmtHandle = NULL; |
|
757 const void* stmtTail = NULL; |
|
758 TInt err = sqlite3_prepare16_v2(aDbHandle, (const void*)sql->Des().Ptr(), -1, &stmtHandle, &stmtTail); |
|
759 delete sql; |
|
760 PanicIfError(aDbHandle, err); |
|
761 TInt firstNamePrmIdx = sqlite3_bind_parameter_index(stmtHandle, KRawPrmName1); |
|
762 TEST(firstNamePrmIdx >= 0); |
|
763 TInt lastNamePrmIdx = sqlite3_bind_parameter_index(stmtHandle, KRawPrmName2); |
|
764 TEST(lastNamePrmIdx >= 0); |
|
765 TInt companyNamePrmIdx = sqlite3_bind_parameter_index(stmtHandle, KRawPrmName3); |
|
766 TEST(companyNamePrmIdx >= 0); |
|
767 TInt idIdx = sqlite3_bind_parameter_index(stmtHandle, KRawPrmName4); |
|
768 TEST(idIdx >= 0); |
|
769 |
|
770 TUint32 start = User::FastCounter(); |
|
771 for(TInt id=1;id<=KTestTecordCount;++id) |
|
772 { |
|
773 TBuf16<20> buf1; |
|
774 buf1.Copy(KFirstName); |
|
775 buf1.AppendNum(id); |
|
776 buf1.Append(TChar(0)); |
|
777 err = sqlite3_bind_text16(stmtHandle, firstNamePrmIdx, (const void*)buf1.Ptr(), -1, SQLITE_STATIC); |
|
778 TEST2(err, SQLITE_OK); |
|
779 TBuf16<20> buf2; |
|
780 buf2.Copy(KLastName); |
|
781 buf2.AppendNum(id); |
|
782 buf2.Append(TChar(0)); |
|
783 err = sqlite3_bind_text16(stmtHandle, lastNamePrmIdx, (const void*)buf2.Ptr(), -1, SQLITE_STATIC); |
|
784 TEST2(err, SQLITE_OK); |
|
785 TBuf16<20> buf3; |
|
786 buf3.Copy(KCompanyName); |
|
787 buf3.AppendNum(id); |
|
788 buf3.Append(TChar(0)); |
|
789 err = sqlite3_bind_text16(stmtHandle, companyNamePrmIdx, (const void*)buf3.Ptr(), -1, SQLITE_STATIC); |
|
790 TEST2(err, SQLITE_OK); |
|
791 err = sqlite3_bind_int(stmtHandle, idIdx, id); |
|
792 TEST2(err, SQLITE_OK); |
|
793 while((err = sqlite3_step(stmtHandle)) == SQLITE_ROW) |
|
794 { |
|
795 } |
|
796 PanicIfError(aDbHandle, err); |
|
797 err = sqlite3_reset(stmtHandle); |
|
798 PanicIfError(aDbHandle, err); |
|
799 } |
|
800 TUint32 end = User::FastCounter(); |
|
801 PrintStats(start, end); |
|
802 err = sqlite3_finalize(stmtHandle); |
|
803 TEST2(err, SQLITE_OK); |
|
804 } |
|
805 |
|
806 //"UPDATE" test function (without parameters) - SQLITE |
|
807 template <class DESC> void UpdateWPTest2(const TDesC& aDbName, const DESC& aUpdateSql); |
|
808 |
|
809 //Explicit UpdateWPTest2() template specialization for UTF8 encoded SQL strings |
|
810 template <> void UpdateWPTest2<TDesC8>(const TDesC& aDbName, const TDesC8& aUpdateSql) |
|
811 { |
|
812 TheTest.Printf(_L("\"Update (without parameters)\" test\r\n")); |
|
813 TBuf<200> fmtstr; |
|
814 fmtstr.Copy(aUpdateSql); |
|
815 |
|
816 sqlite3SymbianLibInit(); |
|
817 sqlite3* dbHandle = TDbHelper2<EDbUtf8>::Open(aDbName); |
|
818 |
|
819 TUint32 start = User::FastCounter(); |
|
820 for(TInt id=1;id<=KTestTecordCount;++id) |
|
821 { |
|
822 TBuf<200> buf; |
|
823 buf.Format(fmtstr, &KFirstName2, id, &KLastName2, id, &KCompanyName2, id, id); |
|
824 TBuf8<200> sql; |
|
825 sql.Copy(buf); |
|
826 sql.Append(0); |
|
827 TInt err = sqlite3_exec(dbHandle, (const char*)sql.Ptr(), 0, 0, 0); |
|
828 TEST2(err, SQLITE_OK); |
|
829 } |
|
830 TUint32 end = User::FastCounter(); |
|
831 PrintStats(start, end); |
|
832 |
|
833 TInt err2 = sqlite3_close(dbHandle); |
|
834 TEST2(err2, SQLITE_OK); |
|
835 sqlite3SymbianLibFinalize(); |
|
836 CloseSTDLIB(); |
|
837 } |
|
838 |
|
839 //Explicit UpdateWPTest2() template specialization for UTF16 encoded SQL strings |
|
840 template <> void UpdateWPTest2<TDesC16>(const TDesC& aDbName, const TDesC16& aUpdateSql) |
|
841 { |
|
842 TheTest.Printf(_L("\"Update (without parameters)\" test\r\n")); |
|
843 |
|
844 sqlite3SymbianLibInit(); |
|
845 sqlite3* dbHandle = TDbHelper2<EDbUtf16>::Open(aDbName); |
|
846 |
|
847 TUint32 start = User::FastCounter(); |
|
848 for(TInt id=1;id<=KTestTecordCount;++id) |
|
849 { |
|
850 TBuf<200> sql; |
|
851 sql.Format(aUpdateSql, &KFirstName2, id, &KLastName2, id, &KCompanyName2, id, id); |
|
852 sql.Append(0); |
|
853 sqlite3_stmt* stmtHandle = NULL; |
|
854 const void* stmtTail = NULL; |
|
855 TInt err = sqlite3_prepare16_v2(dbHandle, sql.Ptr(), -1, &stmtHandle, &stmtTail); |
|
856 TEST2(err, SQLITE_OK); |
|
857 if(stmtHandle) //stmtHandle can be NULL for statements like this: ";". |
|
858 { |
|
859 if(err == SQLITE_OK) |
|
860 { |
|
861 while((err = sqlite3_step(stmtHandle)) == SQLITE_ROW) |
|
862 { |
|
863 } |
|
864 } |
|
865 TInt err2 = sqlite3_finalize(stmtHandle); |
|
866 TEST2(err2, SQLITE_OK); |
|
867 TEST2(err, SQLITE_DONE); |
|
868 } |
|
869 } |
|
870 TUint32 end = User::FastCounter(); |
|
871 PrintStats(start, end); |
|
872 |
|
873 TInt err2 = sqlite3_close(dbHandle); |
|
874 TEST2(err2, SQLITE_OK); |
|
875 sqlite3SymbianLibFinalize(); |
|
876 CloseSTDLIB(); |
|
877 } |
|
878 |
|
879 template <class HBUFC, class DESC> void SelectTest2(sqlite3* aDbHandle, const DESC& aSelectSql); |
|
880 |
|
881 //Explicit SelectTest2() template specialization for UTF8 encoded SQL strings |
|
882 template <> void SelectTest2<HBufC8, TDesC8>(sqlite3* aDbHandle, const TDesC8& aSelectSql) |
|
883 { |
|
884 TheTest.Printf(_L("\"Select\" test\r\n")); |
|
885 HBufC8* sql = HBufC8::New(aSelectSql.Length() + 1); |
|
886 TEST(sql != NULL); |
|
887 sql->Des().Copy(aSelectSql); |
|
888 sql->Des().Append(TChar(0)); |
|
889 |
|
890 sqlite3_stmt* stmtHandle = NULL; |
|
891 const char* stmtTail = NULL; |
|
892 TInt err = sqlite3_prepare_v2(aDbHandle, (const char*)sql->Des().Ptr(), -1, &stmtHandle, &stmtTail); |
|
893 delete sql; |
|
894 PanicIfError(aDbHandle, err); |
|
895 |
|
896 TUint32 start = User::FastCounter(); |
|
897 while((err = sqlite3_step(stmtHandle)) == SQLITE_ROW) |
|
898 { |
|
899 TBuf8<20> buf; |
|
900 const unsigned char* p = sqlite3_column_text(stmtHandle, 0); |
|
901 buf.Copy(p, User::StringLength(p)); |
|
902 TEST(buf.Length() > 0); |
|
903 p = sqlite3_column_text(stmtHandle, 1); |
|
904 buf.Copy(p, User::StringLength(p)); |
|
905 TEST(buf.Length() > 0); |
|
906 p = sqlite3_column_text(stmtHandle, 2); |
|
907 buf.Copy(p, User::StringLength(p)); |
|
908 TEST(buf.Length() > 0); |
|
909 } |
|
910 TEST2(err, SQLITE_DONE); |
|
911 TUint32 end = User::FastCounter(); |
|
912 PrintStats(start, end); |
|
913 err = sqlite3_finalize(stmtHandle); |
|
914 TEST2(err, SQLITE_OK); |
|
915 } |
|
916 |
|
917 //Explicit SelectTest2() template specialization for UTF16 encoded SQL strings |
|
918 template <> void SelectTest2<HBufC16, TDesC16>(sqlite3* aDbHandle, const TDesC16& aSelectSql) |
|
919 { |
|
920 TheTest.Printf(_L("\"Select\" test\r\n")); |
|
921 HBufC16* sql = HBufC16::New(aSelectSql.Length() + 1); |
|
922 TEST(sql != NULL); |
|
923 sql->Des().Copy(aSelectSql); |
|
924 sql->Des().Append(TChar(0)); |
|
925 |
|
926 sqlite3_stmt* stmtHandle = NULL; |
|
927 const void* stmtTail = NULL; |
|
928 TInt err = sqlite3_prepare16_v2(aDbHandle, (const void*)sql->Des().Ptr(), -1, &stmtHandle, &stmtTail); |
|
929 delete sql; |
|
930 PanicIfError(aDbHandle, err); |
|
931 |
|
932 TUint32 start = User::FastCounter(); |
|
933 while((err = sqlite3_step(stmtHandle)) == SQLITE_ROW) |
|
934 { |
|
935 TBuf16<20> buf; |
|
936 const void* p = sqlite3_column_text16(stmtHandle, 0); |
|
937 buf.Copy((const TUint16*)p, User::StringLength((const TUint16*)p)); |
|
938 TEST(buf.Length() > 0); |
|
939 p = sqlite3_column_text16(stmtHandle, 1); |
|
940 buf.Copy((const TUint16*)p, User::StringLength((const TUint16*)p)); |
|
941 TEST(buf.Length() > 0); |
|
942 p = sqlite3_column_text16(stmtHandle, 2); |
|
943 buf.Copy((const TUint16*)p, User::StringLength((const TUint16*)p)); |
|
944 TEST(buf.Length() > 0); |
|
945 } |
|
946 TEST2(err, SQLITE_DONE); |
|
947 TUint32 end = User::FastCounter(); |
|
948 PrintStats(start, end); |
|
949 err = sqlite3_finalize(stmtHandle); |
|
950 TEST2(err, SQLITE_OK); |
|
951 } |
|
952 |
|
953 template <class HBUFC, class DESC> void DeleteTest2(sqlite3* aDbHandle, const DESC& aDeleteSql); |
|
954 |
|
955 //Explicit DeleteTest2() template specialization for UTF8 encoded SQL strings |
|
956 template <> void DeleteTest2<HBufC8, TDesC8>(sqlite3* aDbHandle, const TDesC8& aDeleteSql) |
|
957 { |
|
958 TheTest.Printf(_L("\"Delete\" test\r\n")); |
|
959 HBufC8* sql = HBufC8::New(aDeleteSql.Length() + 1); |
|
960 TEST(sql != NULL); |
|
961 sql->Des().Copy(aDeleteSql); |
|
962 sql->Des().Append(TChar(0)); |
|
963 TUint32 start = User::FastCounter(); |
|
964 TInt err = sqlite3_exec(aDbHandle, (const char*)sql->Des().Ptr(), 0, 0, 0); |
|
965 TEST2(err, SQLITE_OK); |
|
966 TUint32 end = User::FastCounter(); |
|
967 PrintStats(start, end); |
|
968 delete sql; |
|
969 } |
|
970 |
|
971 //Explicit DeleteTest2() template specialization for UTF16 encoded SQL strings |
|
972 template <> void DeleteTest2<HBufC16, TDesC16>(sqlite3* aDbHandle, const TDesC16& aDeleteSql) |
|
973 { |
|
974 TheTest.Printf(_L("\"Delete\" test\r\n")); |
|
975 HBufC16* sql = HBufC16::New(aDeleteSql.Length() + 1); |
|
976 TEST(sql != NULL); |
|
977 sql->Des().Copy(aDeleteSql); |
|
978 sql->Des().Append(TChar(0)); |
|
979 TUint32 start = User::FastCounter(); |
|
980 sqlite3_stmt* stmtHandle = NULL; |
|
981 const void* stmtTail = NULL; |
|
982 TInt err = sqlite3_prepare16_v2(aDbHandle, sql->Des().Ptr(), -1, &stmtHandle, &stmtTail); |
|
983 TEST2(err, SQLITE_OK); |
|
984 if(stmtHandle) //stmtHandle can be NULL for statements like this: ";". |
|
985 { |
|
986 if(err == SQLITE_OK) |
|
987 { |
|
988 while((err = sqlite3_step(stmtHandle)) == SQLITE_ROW) |
|
989 { |
|
990 } |
|
991 } |
|
992 TInt err2 = sqlite3_finalize(stmtHandle); |
|
993 TEST2(err2, SQLITE_OK); |
|
994 TEST2(err, SQLITE_DONE); |
|
995 } |
|
996 TUint32 end = User::FastCounter(); |
|
997 PrintStats(start, end); |
|
998 delete sql; |
|
999 } |
|
1000 |
|
1001 template <TDbEncoding TYPE, class HBUFC, class PTRC, class DESC> void PerformanceTest2(const TDesC& aDbFileName, |
|
1002 const DESC& aCommitStr, |
|
1003 const DESC& aUpdateSql, |
|
1004 const DESC& aSelectSql, |
|
1005 const DESC& aDeleteSql) |
|
1006 { |
|
1007 CFileMan* fm = NULL; |
|
1008 TRAPD(err, fm = CFileMan::NewL(TheFs)); |
|
1009 TEST2(err, KErrNone); |
|
1010 |
|
1011 sqlite3SymbianLibInit(); |
|
1012 TDbHelper2<TYPE>::Create(aDbFileName); |
|
1013 |
|
1014 sqlite3* dbHandle = TDbHelper2<TYPE>::Open(aDbFileName); |
|
1015 InsertTest2<HBUFC, PTRC, DESC>(dbHandle, KFillDbScript(), aCommitStr); |
|
1016 (void)sqlite3_close(dbHandle); dbHandle = NULL; |
|
1017 PrintFileSize(aDbFileName); |
|
1018 |
|
1019 dbHandle = TDbHelper2<TYPE>::Open(aDbFileName); |
|
1020 UpdateTest2<HBUFC, DESC>(dbHandle, aUpdateSql); |
|
1021 (void)sqlite3_close(dbHandle); dbHandle = NULL; |
|
1022 |
|
1023 dbHandle = TDbHelper2<TYPE>::Open(aDbFileName); |
|
1024 SelectTest2<HBUFC, DESC>(dbHandle, aSelectSql); |
|
1025 (void)sqlite3_close(dbHandle); dbHandle = NULL; |
|
1026 |
|
1027 (void)fm->Copy(aDbFileName, TheNonSecureTmpDbName); |
|
1028 |
|
1029 dbHandle = TDbHelper2<TYPE>::Open(aDbFileName); |
|
1030 DeleteTest2<HBUFC, DESC>(dbHandle, aDeleteSql); |
|
1031 (void)sqlite3_close(dbHandle); dbHandle = NULL; |
|
1032 PrintFileSize(aDbFileName); |
|
1033 |
|
1034 sqlite3SymbianLibFinalize(); |
|
1035 CloseSTDLIB(); |
|
1036 |
|
1037 (void)fm->Copy(TheNonSecureTmpDbName, aDbFileName); |
|
1038 (void)fm->Delete(TheNonSecureTmpDbName); |
|
1039 delete fm; |
|
1040 } |
|
1041 //Explicit PerformanceTest2() template instantiations. |
|
1042 template void PerformanceTest2<EDbUtf8, HBufC8, TPtrC8, TDesC8>(const TDesC&, const TDesC8&, const TDesC8&, const TDesC8&, const TDesC8&); |
|
1043 template void PerformanceTest2<EDbUtf16, HBufC8, TPtrC8, TDesC8>(const TDesC&, const TDesC8&, const TDesC8&, const TDesC8&, const TDesC8&); |
|
1044 template void PerformanceTest2<EDbUtf8, HBufC16, TPtrC16, TDesC16>(const TDesC&, const TDesC16&, const TDesC16&, const TDesC16&, const TDesC16&); |
|
1045 template void PerformanceTest2<EDbUtf16, HBufC16, TPtrC16, TDesC16>(const TDesC&, const TDesC16&, const TDesC16&, const TDesC16&, const TDesC16&); |
|
1046 |
|
1047 void ColumnValueAccessTest() |
|
1048 { |
|
1049 _LIT(KColName1, "Column1"); |
|
1050 _LIT(KColName2, "Column2"); |
|
1051 _LIT(KColName3, "Column3"); |
|
1052 _LIT(KColName4, "Column4"); |
|
1053 const TInt KColCount = 4; |
|
1054 TPtrC colNames[KColCount] = {KColName1(), KColName2(), KColName3(), KColName4()}; |
|
1055 TBuf<100> sql; |
|
1056 |
|
1057 //Create a test database |
|
1058 RSqlDatabase db; |
|
1059 TInt err = db.Create(TheNonSecureDbName2); |
|
1060 TEST2(err, KErrNone); |
|
1061 _LIT(KCreateSql, "CREATE TABLE A(%S INTEGER, %S INTEGER, %S INTEGER, %S INTEGER)"); |
|
1062 sql.Format(KCreateSql, &colNames[0], &colNames[1], &colNames[2], &colNames[3]); |
|
1063 err = db.Exec(sql); |
|
1064 TEST(err >= 0); |
|
1065 //Insert a record in the test database |
|
1066 _LIT(KInsertSql, "INSERT INTO A(%S, %S, %S, %S) VALUES(0, 1, 2, 3)"); |
|
1067 sql.Format(KInsertSql, &colNames[0], &colNames[1], &colNames[2], &colNames[3]); |
|
1068 err = db.Exec(sql); |
|
1069 TEST2(err, 1); |
|
1070 //Retrieve the record |
|
1071 RSqlStatement stmt; |
|
1072 err = stmt.Prepare(db, _L8("SELECT * FROM A")); |
|
1073 TEST2(err, KErrNone); |
|
1074 err = stmt.Next(); |
|
1075 TEST2(err, KSqlAtRow); |
|
1076 |
|
1077 //Init the random numbers generator |
|
1078 TInt64 seed = (TInt64)&ColumnValueAccessTest; |
|
1079 const TInt KTestCount = 20000; |
|
1080 TInt val; |
|
1081 |
|
1082 //Test 1: retrieve column values using the column index |
|
1083 TUint32 start = User::FastCounter(); |
|
1084 for(TInt i1=0;i1<KTestCount;++i1) |
|
1085 { |
|
1086 TInt colIdx = Math::Rand(seed) % KColCount; |
|
1087 val = stmt.ColumnInt(colIdx); |
|
1088 TEST(val == colIdx); |
|
1089 } |
|
1090 TUint32 end = User::FastCounter(); |
|
1091 PrintStats(start, end); |
|
1092 |
|
1093 //Test 2: retrieve column values using the column name |
|
1094 start = User::FastCounter(); |
|
1095 for(TInt i2=0;i2<KTestCount;++i2) |
|
1096 { |
|
1097 TInt colNameIdx = Math::Rand(seed) % KColCount; |
|
1098 TInt colIdx = stmt.ColumnIndex(colNames[colNameIdx]); |
|
1099 val = stmt.ColumnInt(colIdx); |
|
1100 TEST(val == colIdx); |
|
1101 } |
|
1102 end = User::FastCounter(); |
|
1103 PrintStats(start, end); |
|
1104 |
|
1105 //Cleanup |
|
1106 stmt.Close(); |
|
1107 db.Close(); |
|
1108 (void)RSqlDatabase::Delete(TheNonSecureDbName2); |
|
1109 } |
|
1110 |
|
1111 /////////////////////////////////////////////////////////////////////////////////// |
|
1112 //////////// "Single record" INSERT/UPDATE/DELETE tests //////////////// |
|
1113 /////////////////////////////////////////////////////////////////////////////////// |
|
1114 |
|
1115 _LIT(KZDbName, "z:\\test\\default_avacon.dbSQL"); |
|
1116 |
|
1117 RSqlDatabase TheDb; |
|
1118 |
|
1119 void OpenTestDb() |
|
1120 { |
|
1121 (void)RSqlDatabase::Delete(TheSglRecDbFileName); |
|
1122 TInt err = RSqlDatabase::Copy(KZDbName, TheSglRecDbFileName); |
|
1123 TEST2(err, KErrNone); |
|
1124 err = TheDb.Open(TheSglRecDbFileName); |
|
1125 TEST2(err, KErrNone); |
|
1126 } |
|
1127 |
|
1128 void CloseTestDb() |
|
1129 { |
|
1130 TheDb.Close(); |
|
1131 TInt err = RSqlDatabase::Delete(TheSglRecDbFileName); |
|
1132 TEST2(err, KErrNone); |
|
1133 } |
|
1134 |
|
1135 void SingleUpdateTest() |
|
1136 { |
|
1137 OpenTestDb(); |
|
1138 |
|
1139 _LIT(KUpdateSql, "UPDATE Table1 SET i2=41 WHERE i1 = 1"); |
|
1140 |
|
1141 TUint32 start = User::FastCounter(); |
|
1142 TInt err = TheDb.Exec(KUpdateSql); |
|
1143 TUint32 end = User::FastCounter(); |
|
1144 TEST2(err, 1); |
|
1145 |
|
1146 PrintStats(start, end); |
|
1147 |
|
1148 CloseTestDb(); |
|
1149 } |
|
1150 |
|
1151 void SingleInsertTest() |
|
1152 { |
|
1153 OpenTestDb(); |
|
1154 |
|
1155 _LIT(KInsertSql, "INSERT INTO Table1 (i1, i2, i3, i4, r5, t6, t7, t8, lt9, lb10) values(1001, 1, 2002, 1001, 1001.001001, '', 'attic attic baker', 'attic attic baker attic attic baker attic attic baker attic attic baker ', 'ATTIC ATTIC BAKER ATTIC ATTIC BAKER ATTIC ATTIC BAKER ATTIC ATTIC BAKER ', NULL)"); |
|
1156 |
|
1157 TUint32 start = User::FastCounter(); |
|
1158 TInt err = TheDb.Exec(KInsertSql); |
|
1159 TUint32 end = User::FastCounter(); |
|
1160 TEST2(err, 1); |
|
1161 |
|
1162 PrintStats(start, end); |
|
1163 |
|
1164 CloseTestDb(); |
|
1165 } |
|
1166 |
|
1167 void SingleDeleteTest() |
|
1168 { |
|
1169 OpenTestDb(); |
|
1170 |
|
1171 _LIT(KDeleteSql, "Delete from Table1 where i1 = 1"); |
|
1172 |
|
1173 TUint32 start = User::FastCounter(); |
|
1174 TInt err = TheDb.Exec(KDeleteSql); |
|
1175 TUint32 end = User::FastCounter(); |
|
1176 TEST2(err, 1); |
|
1177 |
|
1178 PrintStats(start, end); |
|
1179 |
|
1180 CloseTestDb(); |
|
1181 } |
|
1182 |
|
1183 void SelectLikeQueryPerfTest() |
|
1184 { |
|
1185 _LIT(KTestDatabase1, "c:\\test\\t_sqldefect_1.db"); |
|
1186 |
|
1187 _LIT8(KServerConfigString1, "encoding = \"UTF-8\""); |
|
1188 //create a sql db file |
|
1189 (void)RSqlDatabase::Delete(KTestDatabase1); |
|
1190 TInt err = TheDb.Create(KTestDatabase1, &KServerConfigString1); |
|
1191 TEST2(err, KErrNone); |
|
1192 |
|
1193 //Create a test table and insert some records |
|
1194 err = TheDb.Exec(_L("CREATE TABLE A(Id INTEGER PRIMARY KEY, Name TEXT)")); |
|
1195 TEST(err >= 0); |
|
1196 |
|
1197 //Add 100 records to the table |
|
1198 for(TInt k=0;k<100;++k) |
|
1199 { |
|
1200 TBuf<100> sql; |
|
1201 sql.Format(_L("INSERT INTO A VALUES(%d, 'Dvorák')"), k + 1); |
|
1202 err = TheDb.Exec(sql); |
|
1203 TEST2(err, 1); |
|
1204 } |
|
1205 |
|
1206 //Update one record |
|
1207 err = TheDb.Exec(_L("UPDATE A SET Name='dvorak1' WHERE ID = 50")); |
|
1208 TEST2(err, 1); |
|
1209 |
|
1210 TUint32 start = User::FastCounter(); |
|
1211 |
|
1212 //Create a statement object and issue a SELECT SQL statement + LIKE clause |
|
1213 //Test case 1 = full name search with LIKE |
|
1214 RSqlStatement stmt; |
|
1215 err = stmt.Prepare(TheDb, _L("SELECT COUNT(*) FROM A WHERE Name LIKE 'DVORAK1'")); |
|
1216 TEST2(err, KErrNone); |
|
1217 err = stmt.Next(); |
|
1218 TEST2(err, KSqlAtRow); |
|
1219 TInt cnt = stmt.ColumnInt(0); |
|
1220 TEST2(cnt, 1); |
|
1221 |
|
1222 stmt.Close(); |
|
1223 |
|
1224 TUint32 end = User::FastCounter(); |
|
1225 TEST2(err, 1); |
|
1226 PrintStats(start, end); |
|
1227 |
|
1228 TheDb.Close(); |
|
1229 (void)RSqlDatabase::Delete(KTestDatabase1); |
|
1230 } |
|
1231 |
|
1232 /////////////////////////////////////////////////////////////////////////////////// |
|
1233 /////////////////////////////////////////////////////////////////////////////////// |
|
1234 |
|
1235 /** |
|
1236 @SYMTestCaseID SYSLIB-SQL-CT-1648 |
|
1237 @SYMTestCaseDesc SQL database performance tests. |
|
1238 Three test types used: "insert records", "update records" and "select records". |
|
1239 The tests are executed on: secure database, non-secure database, client side database. |
|
1240 Each test executed twice using UTF8 and UTF16 encoded SQL statements. |
|
1241 @SYMTestPriority High |
|
1242 @SYMTestActions SQL database performance tests. |
|
1243 @SYMTestExpectedResults Test must not fail |
|
1244 @SYMREQ REQ5792 |
|
1245 REQ5793 |
|
1246 REQ5912 |
|
1247 REQ10273 |
|
1248 */ |
|
1249 void DoTests() |
|
1250 { |
|
1251 TheTest.Start(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1648 SQL performance tests")); |
|
1252 |
|
1253 TheTest.Printf(_L("Single \"update\" test\r\n")); |
|
1254 SingleUpdateTest(); |
|
1255 |
|
1256 TheTest.Printf(_L("Single \"insert\" test\r\n")); |
|
1257 SingleInsertTest(); |
|
1258 |
|
1259 TheTest.Printf(_L("Single \"delete\" test\r\n")); |
|
1260 SingleDeleteTest(); |
|
1261 |
|
1262 TheTestTitle.Copy(_L("SERVER, UTF8 SQL strings, non-secure, ")); |
|
1263 TheTestTitle.Append(TheDbEncoding == EDbUtf16 ? KDbEncodingUtf16text : KDbEncodingUtf8text); |
|
1264 TheTestTitle.Append(_L("\r\n")); |
|
1265 TheTest.Printf(TheTestTitle); |
|
1266 PerformanceTest<HBufC8, TPtrC8, TDesC8, ENonSecureDb>(TheNonSecureDbName, KCommitStr8(), KUpdateSql8(), KSelectSql8(), KDeleteSql8()); |
|
1267 |
|
1268 TheTestTitle.Copy(_L("SERVER, UTF8 SQL strings, non-secure, ")); |
|
1269 TheTestTitle.Append(TheDbEncoding == EDbUtf16 ? KDbEncodingUtf16text : KDbEncodingUtf8text); |
|
1270 TheTestTitle.Append(_L(", update test (without parameters)")); |
|
1271 TheTestTitle.Append(_L("\r\n")); |
|
1272 TheTest.Printf(TheTestTitle); |
|
1273 UpdateWPTest<TBuf8<200>, TDesC8, ENonSecureDb>(TheNonSecureDbName, KUpdateSql2_8()); |
|
1274 |
|
1275 TheTestTitle.Copy(_L("SERVER, UTF8 SQL strings, secure, ")); |
|
1276 TheTestTitle.Append(TheDbEncoding == EDbUtf16 ? KDbEncodingUtf16text : KDbEncodingUtf8text); |
|
1277 TheTestTitle.Append(_L("\r\n")); |
|
1278 TheTest.Printf(TheTestTitle); |
|
1279 PerformanceTest<HBufC8, TPtrC8, TDesC8, ESecureDb>(TheSecureDbName, KCommitStr8(), KUpdateSql8(), KSelectSql8(), KDeleteSql8()); |
|
1280 |
|
1281 TheTest.Printf(_L("SQLITE, UTF8 encoded database, UTF8 SQL strings\r\n")); |
|
1282 PerformanceTest2<EDbUtf8, HBufC8, TPtrC8, TDesC8>(TheNonSecureDbName, KCommitStr8(), KUpdateSql8(), KSelectSql8(), KDeleteSql8()); |
|
1283 |
|
1284 TheTest.Printf(_L("SQLITE, UTF8 encoded database, UTF8 SQL strings, update test (without parameters)\r\n")); |
|
1285 UpdateWPTest2<TDesC8>(TheNonSecureDbName, KUpdateSql2_8()); |
|
1286 |
|
1287 TheTest.Printf(_L("SQLITE, UTF16 encoded database, UTF8 SQL strings\r\n")); |
|
1288 PerformanceTest2<EDbUtf16, HBufC8, TPtrC8, TDesC8>(TheNonSecureDbName, KCommitStr8(), KUpdateSql8(), KSelectSql8(), KDeleteSql8()); |
|
1289 |
|
1290 TheTestTitle.Copy(_L("SERVER, UTF16 SQL strings, non-secure, ")); |
|
1291 TheTestTitle.Append(TheDbEncoding == EDbUtf16 ? KDbEncodingUtf16text : KDbEncodingUtf8text); |
|
1292 TheTestTitle.Append(_L("\r\n")); |
|
1293 TheTest.Printf(TheTestTitle); |
|
1294 PerformanceTest<HBufC16, TPtrC16, TDesC16, ENonSecureDb>(TheNonSecureDbName, KCommitStr16(), KUpdateSql16(), KSelectSql16(), KDeleteSql16()); |
|
1295 |
|
1296 TheTestTitle.Copy(_L("SERVER, UTF16 SQL strings, non-secure, ")); |
|
1297 TheTestTitle.Append(TheDbEncoding == EDbUtf16 ? KDbEncodingUtf16text : KDbEncodingUtf8text); |
|
1298 TheTestTitle.Append(_L(", update test (without parameters)\r\n")); |
|
1299 TheTest.Printf(TheTestTitle); |
|
1300 UpdateWPTest<TBuf16<200>, TDesC16, ENonSecureDb>(TheNonSecureDbName, KUpdateSql2_16()); |
|
1301 |
|
1302 TheTestTitle.Copy(_L("SERVER, UTF16 SQL strings, secure, ")); |
|
1303 TheTestTitle.Append(TheDbEncoding == EDbUtf16 ? KDbEncodingUtf16text : KDbEncodingUtf8text); |
|
1304 TheTestTitle.Append(_L("\r\n")); |
|
1305 TheTest.Printf(TheTestTitle); |
|
1306 PerformanceTest<HBufC16, TPtrC16, TDesC16, ESecureDb>(TheSecureDbName, KCommitStr16(), KUpdateSql16(), KSelectSql16(), KDeleteSql16()); |
|
1307 |
|
1308 TheTest.Printf(_L("SQLITE, UTF8 encoded database, UTF16 SQL strings\r\n")); |
|
1309 PerformanceTest2<EDbUtf8, HBufC16, TPtrC16, TDesC16>(TheNonSecureDbName, KCommitStr16(), KUpdateSql16(), KSelectSql16(), KDeleteSql16()); |
|
1310 |
|
1311 TheTest.Printf(_L("SQLITE, UTF16 encoded database, UTF16 SQL strings\r\n")); |
|
1312 PerformanceTest2<EDbUtf16, HBufC16, TPtrC16, TDesC16>(TheNonSecureDbName, KCommitStr16(), KUpdateSql16(), KSelectSql16(), KDeleteSql16()); |
|
1313 |
|
1314 TheTest.Printf(_L("SQLITE, UTF16 encoded database, UTF16 SQL strings, update test (without parameters)\r\n")); |
|
1315 UpdateWPTest2<TDesC16>(TheNonSecureDbName, KUpdateSql2_16()); |
|
1316 |
|
1317 TheTest.Printf(_L("Accessing column value by index or by name\r\n")); |
|
1318 ColumnValueAccessTest(); |
|
1319 |
|
1320 TheTest.Printf(_L("Retrieving data from UTF8 Database using SELECT LIKE statements\r\n")); |
|
1321 SelectLikeQueryPerfTest(); |
|
1322 |
|
1323 } |
|
1324 |
|
1325 //Usage: "t_sqlperformance [[-16/-8] [<drive letter>:]]" |
|
1326 |
|
1327 TInt E32Main() |
|
1328 { |
|
1329 TheTest.Title(); |
|
1330 |
|
1331 CTrapCleanup* tc = CTrapCleanup::New(); |
|
1332 |
|
1333 TheDbEncoding = EDbUtf16; |
|
1334 |
|
1335 User::CommandLine(TheCmd); |
|
1336 TheCmd.TrimAll(); |
|
1337 if(TheCmd.Length() > 0) |
|
1338 { |
|
1339 TPtrC prm1(KNullDesC); |
|
1340 TPtrC prm2(KNullDesC); |
|
1341 TInt pos = TheCmd.Locate(TChar(' ')); |
|
1342 if(pos > 0) |
|
1343 { |
|
1344 prm1.Set(TheCmd.Left(pos)); |
|
1345 prm2.Set(TheCmd.Mid(pos + 1)); |
|
1346 } |
|
1347 else |
|
1348 { |
|
1349 prm1.Set(TheCmd); |
|
1350 } |
|
1351 if(prm1.Compare(_L("-8")) == 0) |
|
1352 { |
|
1353 TheDbEncoding = EDbUtf8; |
|
1354 TheDriveName.Copy(prm2); |
|
1355 } |
|
1356 else if(prm2.Compare(_L("-8")) == 0) |
|
1357 { |
|
1358 TheDbEncoding = EDbUtf8; |
|
1359 TheDriveName.Copy(prm1); |
|
1360 } |
|
1361 else if(prm1.Compare(_L("-16")) == 0) |
|
1362 { |
|
1363 TheDbEncoding = EDbUtf16; |
|
1364 TheDriveName.Copy(prm2); |
|
1365 } |
|
1366 else if(prm2.Compare(_L("-16")) == 0) |
|
1367 { |
|
1368 TheDbEncoding = EDbUtf16; |
|
1369 TheDriveName.Copy(prm1); |
|
1370 } |
|
1371 } |
|
1372 |
|
1373 //Construct test database file names |
|
1374 _LIT(KSecureDbName, "c:[2121212A]t_perfdb.db"); |
|
1375 TheParse.Set(TheDriveName, &KSecureDbName, 0); |
|
1376 const TDesC& dbFilePath1 = TheParse.FullName(); |
|
1377 TheSecureDbName.Copy(dbFilePath1); |
|
1378 |
|
1379 _LIT(KNonSecureDbName, "c:\\test\\t_perfdb.db"); |
|
1380 TheParse.Set(TheDriveName, &KNonSecureDbName, 0); |
|
1381 const TDesC& dbFilePath2 = TheParse.FullName(); |
|
1382 TheNonSecureDbName.Copy(dbFilePath2); |
|
1383 |
|
1384 _LIT(KNonSecureDbName2, "c:\\test\\t_perfdb2.db"); |
|
1385 TheParse.Set(TheDriveName, &KNonSecureDbName2, 0); |
|
1386 const TDesC& dbFilePath3 = TheParse.FullName(); |
|
1387 TheNonSecureDbName2.Copy(dbFilePath3); |
|
1388 |
|
1389 _LIT(KNonSecureTmpDbName, "c:\\test\\tmp.db"); |
|
1390 TheParse.Set(TheDriveName, &KNonSecureTmpDbName, 0); |
|
1391 const TDesC& dbFilePath4 = TheParse.FullName(); |
|
1392 TheNonSecureTmpDbName.Copy(dbFilePath4); |
|
1393 |
|
1394 _LIT(KSglRecDbName, "c:\\test\\default_avacon.dbSQL"); |
|
1395 TheParse.Set(TheDriveName, &KSglRecDbName, 0); |
|
1396 const TDesC& dbFilePath5 = TheParse.FullName(); |
|
1397 TheSglRecDbFileName.Copy(dbFilePath5); |
|
1398 |
|
1399 __UHEAP_MARK; |
|
1400 |
|
1401 TestEnvInit(); |
|
1402 TheTest.Printf(_L("==Databases: %S, %S, %S, %S, %S\r\n"), &TheSecureDbName, &TheNonSecureDbName, |
|
1403 &TheNonSecureDbName2, &TheNonSecureTmpDbName, &TheSglRecDbFileName); |
|
1404 DoTests(); |
|
1405 TestEnvDestroy(); |
|
1406 |
|
1407 __UHEAP_MARKEND; |
|
1408 |
|
1409 TheTest.End(); |
|
1410 TheTest.Close(); |
|
1411 |
|
1412 delete tc; |
|
1413 |
|
1414 User::Heap().Check(); |
|
1415 return KErrNone; |
|
1416 } |