1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/sql/SRC/Server/SqlSrvResourceProfiler.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,1030 @@
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 <f32file.h>
1.20 +#include "SqlAssert.h"
1.21 +#include "SqlSrvResourceProfiler.h"
1.22 +#include "SqlResourceProfiler.h"
1.23 +#include "SqliteSymbian.h"
1.24 +#include <hal.h>
1.25 +
1.26 +#ifdef _SQLPROFILER
1.27 +
1.28 +///////////////////////////////// Heap max alloc /////////////////////////////////////
1.29 +
1.30 +/**
1.31 +If true the max alloc profiling is enabled.
1.32 +@internalComponent
1.33 +*/
1.34 +TBool TheSqlSrvProfilerMaxAllocEnabled = EFalse;
1.35 +/**
1.36 +The size of the biggest memory block ever allocated by the SQL server.
1.37 +Set only if compiled with _SQLPROFILER macro.
1.38 +@internalComponent
1.39 +*/
1.40 +TInt TheSqlSrvProfilerMaxAllocSize = 0;
1.41 +
1.42 +////////////////////////// IPC & SQL tracing related //////////////////////////////////
1.43 +
1.44 +/**
1.45 +If true the tracing is enabled (IPC calls & SQL statements).
1.46 +@internalComponent
1.47 +*/
1.48 +static TBool TheSqlSrvProfilerTraceEnabled = EFalse;
1.49 +/**
1.50 +Trace level:
1.51 + - 0: no IPC calls traced (default);
1.52 + - 1: only the 10 most important IPC calls traced - SQL statement execution, ....
1.53 + - 2: all IPC calls traced;
1.54 +@internalComponent
1.55 +*/
1.56 +static TInt TheSqlSrvProfilerTraceLevel = 0;
1.57 +/**
1.58 +If true the SQL statement tracing is enabled.
1.59 +@internalComponent
1.60 +*/
1.61 +static TBool TheSqlSrvProfilerSqlTraceEnabled = EFalse;
1.62 +
1.63 +/**
1.64 +When KSqlSrvProfilerDbName is with non-zero length, then only traces coming from database identified by
1.65 +KSqlSrvProfilerDbName name are printed out.
1.66 +@internalComponent
1.67 +*/
1.68 +//_LIT(KSqlSrvProfilerDbName, "default_avacon.dbSQL");
1.69 +_LIT(KSqlSrvProfilerDbName, "");
1.70 +static TUint TheSqlSrvProfilerHandle = 0;
1.71 +
1.72 +//File "read", "write", "sync" and "set size" counters, incremented inside the OS porting layer.
1.73 +TInt TheSqlSrvProfilerFileRead = 0;
1.74 +TInt TheSqlSrvProfilerFileWrite = 0;
1.75 +TInt TheSqlSrvProfilerFileSync = 0;
1.76 +TInt TheSqlSrvProfilerFileSetSize = 0;
1.77 +
1.78 +//Set it to true if you want traces to be stored into a file.
1.79 +static TBool TheSqlSrvProfilerTraceToFile = EFalse;
1.80 +
1.81 +//"Prepared" and "Executed" SQL statement counters
1.82 +static TInt TheSqlSrvProfilerPreparedCnt8 = 0;
1.83 +static TInt TheSqlSrvProfilerPreparedCnt16 = 0;
1.84 +static TInt TheSqlSrvProfilerExecutedCnt8 = 0;
1.85 +static TInt TheSqlSrvProfilerExecutedCnt16 = 0;
1.86 +
1.87 +///////////////////////////////// IPC counters ///////////////////////////////////////
1.88 +
1.89 +/**
1.90 +If true the IPC profiling is enabled.
1.91 +@internalComponent
1.92 +*/
1.93 +TBool TheSqlSrvProfilerIpcEnabled = EFalse;
1.94 +/**
1.95 +IPC requests, read and write counters.
1.96 +@internalComponent
1.97 +*/
1.98 +TInt TheSqlSrvProfilerIpc[ESqlIpcLast] = {0};
1.99 +/**
1.100 +IPC read and write - bytes.
1.101 +@internalComponent
1.102 +*/
1.103 +TInt64 TheSqlSrvProfilerIpcBytes[ESqlIpcLast] = {0};
1.104 +
1.105 +//////////////////////////////////////////////////////////////////////////////////////
1.106 +
1.107 +/**
1.108 +Starts the specified profiling counter.
1.109 +
1.110 +@leave KErrNotSupported, The requested profiling type is not supported;
1.111 + The function may also leave with some other system-wide error codes.
1.112 +
1.113 +Usage of the IPC call arguments:
1.114 + - Arg 0: [in] profiling counter type, one of the TSqlResourceProfiler::TSqlCounter enum item values.
1.115 + - Arg 1: [in] the length of the additional profiling parameters.
1.116 + - Arg 2: [in] additional profiling parameters.
1.117 +*/
1.118 +void TSqlSrvResourceProfiler::StartL(const RMessage2& aMessage)
1.119 + {
1.120 + const TSqlResourceProfiler::TSqlCounter KCounterType = static_cast <TSqlResourceProfiler::TSqlCounter> (aMessage.Int0());
1.121 + TInt err = KErrNone;
1.122 + switch(KCounterType)
1.123 + {
1.124 + case TSqlResourceProfiler::ESqlCounterFileIO:
1.125 + case TSqlResourceProfiler::ESqlCounterOsCall:
1.126 + case TSqlResourceProfiler::ESqlCounterOsCallTime:
1.127 + case TSqlResourceProfiler::ESqlCounterOsCallDetails:
1.128 + err = sqlite3SymbianProfilerStart(KCounterType);
1.129 + break;
1.130 + case TSqlResourceProfiler::ESqlCounterIpc:
1.131 + TheSqlSrvProfilerIpcEnabled = ETrue;
1.132 + break;
1.133 + case TSqlResourceProfiler::ESqlCounterMemory:
1.134 + err = sqlite3SymbianProfilerStart(KCounterType);
1.135 + break;
1.136 + case TSqlResourceProfiler::ESqlCounterMaxAlloc:
1.137 + TheSqlSrvProfilerMaxAllocEnabled = ETrue;
1.138 + err = sqlite3SymbianProfilerStart(KCounterType);
1.139 + break;
1.140 + case TSqlResourceProfiler::ESqlCounterTrace:
1.141 + {
1.142 + TheSqlSrvProfilerTraceEnabled = ETrue;
1.143 + TInt len = aMessage.Int1();
1.144 + __SQLPANIC_CLIENT2((TUint)len < 64, aMessage, ESqlPanicBadArgument);
1.145 + if(len > 0)
1.146 + {
1.147 + TBuf8<64> prmBuf;
1.148 + aMessage.ReadL(2, prmBuf);
1.149 + prmBuf.UpperCase();
1.150 + TPtrC8 ptr(prmBuf);
1.151 + _LIT8(KLevel0, "L0");
1.152 + _LIT8(KLevel1, "L1");
1.153 + _LIT8(KLevel2, "L2");
1.154 + _LIT8(KSqlStmtTraceOff, "S0");
1.155 + _LIT8(KSqlStmtTraceOn, "S1");
1.156 + while(ptr.Length() > 0)
1.157 + {
1.158 + TInt pos = ptr.Locate(TChar(';'));
1.159 + TPtrC8 str = ptr;
1.160 + if(pos >= 0)
1.161 + {
1.162 + str.Set(ptr.Left(pos));
1.163 + }
1.164 + if(str == KLevel0)
1.165 + {
1.166 + TheSqlSrvProfilerTraceLevel = 0;
1.167 + }
1.168 + else if(str == KLevel1)
1.169 + {
1.170 + TheSqlSrvProfilerTraceLevel = 1;
1.171 + }
1.172 + else if(str == KLevel2)
1.173 + {
1.174 + TheSqlSrvProfilerTraceLevel = 2;
1.175 + }
1.176 + else if(str == KSqlStmtTraceOff)
1.177 + {
1.178 + TheSqlSrvProfilerSqlTraceEnabled = EFalse;
1.179 + }
1.180 + else if(str == KSqlStmtTraceOn)
1.181 + {
1.182 + TheSqlSrvProfilerSqlTraceEnabled = ETrue;
1.183 + }
1.184 + if((TUint)pos > (ptr.Length() - 1))
1.185 + {
1.186 + break;
1.187 + }
1.188 + ptr.Set(ptr.Mid(pos + 1));
1.189 + }
1.190 + }
1.191 + }
1.192 + break;
1.193 + default:
1.194 + err = KErrNotSupported;
1.195 + break;
1.196 + }
1.197 + __SQLLEAVE_IF_ERROR2(err);
1.198 + }
1.199 +
1.200 +/**
1.201 +Stops the specified profiling counter.
1.202 +
1.203 +@leave KErrNotSupported, The requested profiling type is not supported;
1.204 + The function may also leave with some other system-wide error codes.
1.205 +
1.206 +Usage of the IPC call arguments:
1.207 + - Arg 0: [in] profiling counter type, one of the TSqlResourceProfiler::TSqlCounter enum item values.
1.208 +*/
1.209 +void TSqlSrvResourceProfiler::StopL(const RMessage2& aMessage)
1.210 + {
1.211 + const TSqlResourceProfiler::TSqlCounter KCounterType = static_cast <TSqlResourceProfiler::TSqlCounter> (aMessage.Int0());
1.212 + TInt err = KErrNone;
1.213 + switch(KCounterType)
1.214 + {
1.215 + case TSqlResourceProfiler::ESqlCounterFileIO:
1.216 + case TSqlResourceProfiler::ESqlCounterOsCall:
1.217 + case TSqlResourceProfiler::ESqlCounterOsCallTime:
1.218 + case TSqlResourceProfiler::ESqlCounterOsCallDetails:
1.219 + err = sqlite3SymbianProfilerStop(KCounterType);
1.220 + break;
1.221 + case TSqlResourceProfiler::ESqlCounterIpc:
1.222 + TheSqlSrvProfilerIpcEnabled = EFalse;
1.223 + break;
1.224 + case TSqlResourceProfiler::ESqlCounterMemory:
1.225 + err = sqlite3SymbianProfilerStop(KCounterType);
1.226 + break;
1.227 + case TSqlResourceProfiler::ESqlCounterMaxAlloc:
1.228 + TheSqlSrvProfilerMaxAllocEnabled = EFalse;
1.229 + err = sqlite3SymbianProfilerStop(KCounterType);
1.230 + break;
1.231 + case TSqlResourceProfiler::ESqlCounterTrace:
1.232 + TheSqlSrvProfilerTraceEnabled = EFalse;
1.233 + TheSqlSrvProfilerSqlTraceEnabled = EFalse;
1.234 + TheSqlSrvProfilerTraceLevel = 0;
1.235 + TheSqlSrvProfilerHandle = 0;
1.236 + break;
1.237 + default:
1.238 + err = KErrNotSupported;
1.239 + break;
1.240 + }
1.241 + __SQLLEAVE_IF_ERROR2(err);
1.242 + }
1.243 +
1.244 +/**
1.245 +Resets the specified profiling counter.
1.246 +
1.247 +@leave KErrNotSupported, The requested profiling type is not supported;
1.248 + The function may also leave with some other system-wide error codes.
1.249 +
1.250 +Usage of the IPC call arguments:
1.251 + - Arg 0: [in] profiling counter type, one of the TSqlResourceProfiler::TSqlCounter enum item values.
1.252 +*/
1.253 +void TSqlSrvResourceProfiler::ResetL(const RMessage2& aMessage)
1.254 + {
1.255 + const TSqlResourceProfiler::TSqlCounter KCounterType = static_cast <TSqlResourceProfiler::TSqlCounter> (aMessage.Int0());
1.256 + TInt err = KErrNone;
1.257 + switch(KCounterType)
1.258 + {
1.259 + case TSqlResourceProfiler::ESqlCounterFileIO:
1.260 + case TSqlResourceProfiler::ESqlCounterOsCall:
1.261 + case TSqlResourceProfiler::ESqlCounterOsCallTime:
1.262 + case TSqlResourceProfiler::ESqlCounterOsCallDetails:
1.263 + err = sqlite3SymbianProfilerReset(KCounterType);
1.264 + break;
1.265 + case TSqlResourceProfiler::ESqlCounterIpc:
1.266 + Mem::FillZ(TheSqlSrvProfilerIpc, sizeof(TheSqlSrvProfilerIpc));
1.267 + Mem::FillZ(TheSqlSrvProfilerIpcBytes, sizeof(TheSqlSrvProfilerIpcBytes));
1.268 + break;
1.269 + case TSqlResourceProfiler::ESqlCounterMemory:
1.270 + err = sqlite3SymbianProfilerReset(KCounterType);
1.271 + break;
1.272 + case TSqlResourceProfiler::ESqlCounterMaxAlloc:
1.273 + TheSqlSrvProfilerMaxAllocSize = 0;
1.274 + err = sqlite3SymbianProfilerReset(KCounterType);
1.275 + break;
1.276 + case TSqlResourceProfiler::ESqlCounterTrace:
1.277 + break;
1.278 + default:
1.279 + err = KErrNotSupported;
1.280 + break;
1.281 + }
1.282 + __SQLLEAVE_IF_ERROR2(err);
1.283 + }
1.284 +
1.285 +/**
1.286 +Retrieves the counter values for the specified profiling counter.
1.287 +
1.288 +@leave KErrNotSupported, The requested profiling type is not supported;
1.289 + The function may also leave with some other system-wide error codes.
1.290 +
1.291 +@see TSqlResourceProfiler
1.292 +
1.293 +Usage of the IPC call arguments:
1.294 + - Arg 0: [in] profiling counter type, one of the TSqlResourceProfiler::TSqlCounter enum item values.
1.295 + - Arg 1: [in] the size of the buffer for the profiling counter values.
1.296 + - Arg 2: [out] the buffer for the profiling counter values.
1.297 +*/
1.298 +void TSqlSrvResourceProfiler::QueryL(const RMessage2& aMessage)
1.299 + {
1.300 + const TSqlResourceProfiler::TSqlCounter KCounterType = static_cast <TSqlResourceProfiler::TSqlCounter> (aMessage.Int0());
1.301 + const TInt KIpcBufLen = 300;
1.302 + TBuf8<KIpcBufLen> ipcBuf;
1.303 + TInt err = KErrNone;
1.304 + switch(KCounterType)
1.305 + {
1.306 + case TSqlResourceProfiler::ESqlCounterFileIO:
1.307 + case TSqlResourceProfiler::ESqlCounterOsCall:
1.308 + case TSqlResourceProfiler::ESqlCounterOsCallTime:
1.309 + case TSqlResourceProfiler::ESqlCounterOsCallDetails:
1.310 + err = sqlite3SymbianProfilerQuery(KCounterType, ipcBuf);
1.311 + break;
1.312 + case TSqlResourceProfiler::ESqlCounterIpc:
1.313 + ipcBuf.AppendNum(TheSqlSrvProfilerIpc[ESqlIpcRq]);
1.314 + ipcBuf.Append(TChar(';'));
1.315 + ipcBuf.AppendNum(TheSqlSrvProfilerIpc[ESqlIpcRead]);
1.316 + ipcBuf.Append(TChar(';'));
1.317 + ipcBuf.AppendNum(TheSqlSrvProfilerIpc[ESqlIpcWrite]);
1.318 + ipcBuf.Append(TChar(';'));
1.319 + ipcBuf.AppendNum(TheSqlSrvProfilerIpcBytes[ESqlIpcRead]);
1.320 + ipcBuf.Append(TChar(';'));
1.321 + ipcBuf.AppendNum(TheSqlSrvProfilerIpcBytes[ESqlIpcWrite]);
1.322 + ipcBuf.Append(TChar(';'));
1.323 + break;
1.324 + case TSqlResourceProfiler::ESqlCounterMemory:
1.325 + {
1.326 + TInt totalAllocCells = 0;
1.327 + TInt totalAllocSize = 0;
1.328 + TInt totalFreeSpace = 0;
1.329 + TInt biggestBlockSize = 0;
1.330 + RHeap& heap = User::Heap();;
1.331 + totalAllocCells = heap.AllocSize(totalAllocSize);
1.332 + totalFreeSpace = heap.Available(biggestBlockSize);
1.333 + ipcBuf.AppendNum(totalAllocCells);
1.334 + ipcBuf.Append(TChar(';'));
1.335 + ipcBuf.AppendNum(totalAllocSize);
1.336 + ipcBuf.Append(TChar(';'));
1.337 + ipcBuf.AppendNum(totalFreeSpace);
1.338 + ipcBuf.Append(TChar(';'));
1.339 + ipcBuf.AppendNum(biggestBlockSize);
1.340 + ipcBuf.Append(TChar(';'));
1.341 + err = sqlite3SymbianProfilerQuery(KCounterType, ipcBuf);
1.342 + }
1.343 + break;
1.344 + case TSqlResourceProfiler::ESqlCounterMaxAlloc:
1.345 + ipcBuf.AppendNum(TheSqlSrvProfilerMaxAllocSize);
1.346 + ipcBuf.Append(TChar(';'));
1.347 + err = sqlite3SymbianProfilerQuery(KCounterType, ipcBuf);
1.348 + break;
1.349 + case TSqlResourceProfiler::ESqlCounterTrace:
1.350 + break;
1.351 + default:
1.352 + err = KErrNotSupported;
1.353 + break;
1.354 + }
1.355 + __SQLLEAVE_IF_ERROR2(err);
1.356 + aMessage.WriteL(2, ipcBuf);
1.357 + }
1.358 +
1.359 +////////////////////////// IPC tracing related ////////////////////////////////////////
1.360 +
1.361 +//Max trace line length
1.362 +const TInt KSqlTraceMaxLength = 220;
1.363 +//Trace buffer.
1.364 +static TBuf<KSqlTraceMaxLength> TheSqlTraceBuf;
1.365 +
1.366 +//IPC calls names - begin
1.367 +_LIT(KSqlSrvDbCreate, "DbCreate");
1.368 +_LIT(KSqlSrvDbCreateSecure, "DbCreateSecure");
1.369 +_LIT(KSqlSrvDbOpen, "DbOpen");
1.370 +_LIT(KSqlSrvDbOpenFromHandle, "DbOpenFromHandle");
1.371 +_LIT(KSqlSrvDbClose, "DbClose");
1.372 +_LIT(KSqlSrvDbCopy, "DbCopy");
1.373 +_LIT(KSqlSrvDbDelete, "DbDelete");
1.374 +_LIT(KSqlSrvLastErrorMsg, "LastErrorMsg");
1.375 +_LIT(KSqlSrvDbExec8, "DbExec8");
1.376 +_LIT(KSqlSrvDbExec16, "DbExec16");
1.377 +_LIT(KSqlSrvDbSetIsolationLevel, "DbSetIsolationLevel");
1.378 +_LIT(KSqlSrvDbGetSecurityPolicy, "DbGetSecurityPolicy");
1.379 +_LIT(KSqlSrvDbAttach, "DbAttach");
1.380 +_LIT(KSqlSrvDbAttachFromHandle, "DbAttachFromHandle");
1.381 +_LIT(KSqlSrvDbDetach, "DbDetach");
1.382 +_LIT(KSqlSrvDbScalarFullSelect8, "DbScalarFullSelect8");
1.383 +_LIT(KSqlSrvDbScalarFullSelect16, "DbScalarFullSelect16");
1.384 +_LIT(KSqlSrvDbInTransaction, "DbInTransaction");
1.385 +_LIT(KSqlSrvDbSize, "DbSize");
1.386 +_LIT(KSqlSrvDbSize2, "DbSize2");
1.387 +_LIT(KSqlSrvDbBlobSource, "DbBlobSource");
1.388 +_LIT(KSqlSrvDbLastInsertedRowId, "DbLastInsertedRowId");
1.389 +_LIT(KSqlSrvDbCompact, "DbCompact");
1.390 +_LIT(KSqlSrvDbReserveDriveSpace, "DbReserveDriveSpace");
1.391 +_LIT(KSqlSrvDbFreeReservedSpace, "DbFreeReservedSpace");
1.392 +_LIT(KSqlSrvDbGetReserveAccess, "DbGetReserveAccess");
1.393 +_LIT(KSqlSrvDbReleaseReserveAccess, "DbReleaseReserveAccess");
1.394 +_LIT(KSqlSrvStmtPrepare8, "StmtPrepare8");
1.395 +_LIT(KSqlSrvStmtPrepare16, "StmtPrepare16");
1.396 +_LIT(KSqlSrvStmtClose, "StmtClose");
1.397 +_LIT(KSqlSrvStmtReset, "StmtReset");
1.398 +_LIT(KSqlSrvStmtExec, "StmtExec");
1.399 +_LIT(KSqlSrvStmtAsyncExec, "StmtAsyncExec");
1.400 +_LIT(KSqlSrvStmtBindExec, "StmtBindExec");
1.401 +_LIT(KSqlSrvStmtAsyncBindExec, "StmtAsyncBindExec");
1.402 +_LIT(KSqlSrvStmtNext, "StmtNext");
1.403 +_LIT(KSqlSrvStmtBindNext, "StmtBindNext");
1.404 +_LIT(KSqlSrvStmtColumnNames, "StmtColumnNames");
1.405 +_LIT(KSqlSrvStmtParamNames, "StmtParamNames");
1.406 +_LIT(KSqlSrvStmtColumnSource, "StmtColumnSource");
1.407 +_LIT(KSqlSrvStmtBinParamSink, "StmtBinParamSink");
1.408 +_LIT(KSqlSrvStmtTxtParamSink16, "StmtTxtParamSink16");
1.409 +_LIT(KSqlSrvStmtBufFlat, "StmtBufFlat");
1.410 +_LIT(KSqlSrvStmtColumnValue, "StmtColumnValue");
1.411 +_LIT(KSqlSrvStmtDeclColumnTypes, "StmtDeclColumnTypes");
1.412 +_LIT(KSqlSrvStreamRead, "StreamRead");
1.413 +_LIT(KSqlSrvStreamWrite, "StreamWrite");
1.414 +_LIT(KSqlSrvStreamSize, "StreamSize");
1.415 +_LIT(KSqlSrvStreamSynch, "StreamSynch");
1.416 +_LIT(KSqlSrvStreamClose, "StreamClose");
1.417 +//IPC calls names - end
1.418 +
1.419 +//Gets as an argument the IPC call type in "aCode" parameter.
1.420 +//Returns:
1.421 +// 0 or positive integer: the IPC call is one of the 10 most important IPC calls (trace level 0).
1.422 +// KErrNotFound : the IPC call is some of the other possible call types (trace level 1).
1.423 +// KErrNotSupported : unknown IPC call type.
1.424 +//
1.425 +// aIpcCallName will always be set to IPC call name descriptor.
1.426 +static TInt SqlIpcTraceIdxAndName(TSqlSrvFunction aCode, TPtrC& aIpcCallName)
1.427 + {
1.428 + TInt rc = KErrNotFound;
1.429 + switch(aCode)
1.430 + {
1.431 + case ESqlSrvDbCreate:
1.432 + aIpcCallName.Set(KSqlSrvDbCreate);
1.433 + break;
1.434 + case ESqlSrvDbCreateSecure:
1.435 + aIpcCallName.Set(KSqlSrvDbCreateSecure);
1.436 + break;
1.437 + case ESqlSrvDbOpen:
1.438 + aIpcCallName.Set(KSqlSrvDbOpen);
1.439 + break;
1.440 + case ESqlSrvDbOpenFromHandle:
1.441 + aIpcCallName.Set(KSqlSrvDbOpenFromHandle);
1.442 + break;
1.443 + case ESqlSrvDbClose:
1.444 + aIpcCallName.Set(KSqlSrvDbClose);
1.445 + break;
1.446 + case ESqlSrvDbCopy:
1.447 + aIpcCallName.Set(KSqlSrvDbCopy);
1.448 + break;
1.449 + case ESqlSrvDbDelete:
1.450 + aIpcCallName.Set(KSqlSrvDbDelete);
1.451 + break;
1.452 + case ESqlSrvLastErrorMsg:
1.453 + aIpcCallName.Set(KSqlSrvLastErrorMsg);
1.454 + break;
1.455 + case ESqlSrvDbExec8:
1.456 + aIpcCallName.Set(KSqlSrvDbExec8);
1.457 + rc = 0;
1.458 + break;
1.459 + case ESqlSrvDbExec16:
1.460 + aIpcCallName.Set(KSqlSrvDbExec16);
1.461 + rc = 1;
1.462 + break;
1.463 + case ESqlSrvDbSetIsolationLevel:
1.464 + aIpcCallName.Set(KSqlSrvDbSetIsolationLevel);
1.465 + break;
1.466 + case ESqlSrvDbGetSecurityPolicy:
1.467 + aIpcCallName.Set(KSqlSrvDbGetSecurityPolicy);
1.468 + break;
1.469 + case ESqlSrvDbAttach:
1.470 + aIpcCallName.Set(KSqlSrvDbAttach);
1.471 + break;
1.472 + case ESqlSrvDbAttachFromHandle:
1.473 + aIpcCallName.Set(KSqlSrvDbAttachFromHandle);
1.474 + break;
1.475 + case ESqlSrvDbDetach:
1.476 + aIpcCallName.Set(KSqlSrvDbDetach);
1.477 + break;
1.478 + case ESqlSrvDbScalarFullSelect8:
1.479 + aIpcCallName.Set(KSqlSrvDbScalarFullSelect8);
1.480 + rc = 2;
1.481 + break;
1.482 + case ESqlSrvDbScalarFullSelect16:
1.483 + aIpcCallName.Set(KSqlSrvDbScalarFullSelect16);
1.484 + rc = 3;
1.485 + break;
1.486 + case ESqlSrvDbInTransaction:
1.487 + aIpcCallName.Set(KSqlSrvDbInTransaction);
1.488 + break;
1.489 + case ESqlSrvDbSize:
1.490 + aIpcCallName.Set(KSqlSrvDbSize);
1.491 + break;
1.492 + case ESqlSrvDbSize2:
1.493 + aIpcCallName.Set(KSqlSrvDbSize2);
1.494 + break;
1.495 + case ESqlSrvDbBlobSource:
1.496 + aIpcCallName.Set(KSqlSrvDbBlobSource);
1.497 + break;
1.498 + case ESqlSrvDbLastInsertedRowId:
1.499 + aIpcCallName.Set(KSqlSrvDbLastInsertedRowId);
1.500 + break;
1.501 + case ESqlSrvDbCompact:
1.502 + aIpcCallName.Set(KSqlSrvDbCompact);
1.503 + break;
1.504 + case ESqlSrvDbReserveDriveSpace:
1.505 + aIpcCallName.Set(KSqlSrvDbReserveDriveSpace);
1.506 + break;
1.507 + case ESqlSrvDbFreeReservedSpace:
1.508 + aIpcCallName.Set(KSqlSrvDbFreeReservedSpace);
1.509 + break;
1.510 + case ESqlSrvDbGetReserveAccess:
1.511 + aIpcCallName.Set(KSqlSrvDbGetReserveAccess);
1.512 + break;
1.513 + case ESqlSrvDbReleaseReserveAccess:
1.514 + aIpcCallName.Set(KSqlSrvDbReleaseReserveAccess);
1.515 + break;
1.516 + case ESqlSrvStmtPrepare8:
1.517 + aIpcCallName.Set(KSqlSrvStmtPrepare8);
1.518 + break;
1.519 + case ESqlSrvStmtPrepare16:
1.520 + aIpcCallName.Set(KSqlSrvStmtPrepare16);
1.521 + break;
1.522 + case ESqlSrvStmtClose:
1.523 + aIpcCallName.Set(KSqlSrvStmtClose);
1.524 + break;
1.525 + case ESqlSrvStmtReset:
1.526 + aIpcCallName.Set(KSqlSrvStmtReset);
1.527 + break;
1.528 + case ESqlSrvStmtExec:
1.529 + aIpcCallName.Set(KSqlSrvStmtExec);
1.530 + rc = 4;
1.531 + break;
1.532 + case ESqlSrvStmtAsyncExec:
1.533 + aIpcCallName.Set(KSqlSrvStmtAsyncExec);
1.534 + rc = 5;
1.535 + break;
1.536 + case ESqlSrvStmtBindExec:
1.537 + aIpcCallName.Set(KSqlSrvStmtBindExec);
1.538 + rc = 6;
1.539 + break;
1.540 + case ESqlSrvStmtAsyncBindExec:
1.541 + aIpcCallName.Set(KSqlSrvStmtAsyncBindExec);
1.542 + rc = 7;
1.543 + break;
1.544 + case ESqlSrvStmtNext:
1.545 + aIpcCallName.Set(KSqlSrvStmtNext);
1.546 + rc = 8;
1.547 + break;
1.548 + case ESqlSrvStmtBindNext:
1.549 + aIpcCallName.Set(KSqlSrvStmtBindNext);
1.550 + rc = 9;
1.551 + break;
1.552 + case ESqlSrvStmtColumnNames:
1.553 + aIpcCallName.Set(KSqlSrvStmtColumnNames);
1.554 + break;
1.555 + case ESqlSrvStmtParamNames:
1.556 + aIpcCallName.Set(KSqlSrvStmtParamNames);
1.557 + break;
1.558 + case ESqlSrvStmtColumnSource:
1.559 + aIpcCallName.Set(KSqlSrvStmtColumnSource);
1.560 + break;
1.561 + case ESqlSrvStmtBinParamSink:
1.562 + aIpcCallName.Set(KSqlSrvStmtBinParamSink);
1.563 + break;
1.564 + case ESqlSrvStmtTxtParamSink16:
1.565 + aIpcCallName.Set(KSqlSrvStmtTxtParamSink16);
1.566 + break;
1.567 + case ESqlSrvStmtBufFlat:
1.568 + aIpcCallName.Set(KSqlSrvStmtBufFlat);
1.569 + break;
1.570 + case ESqlSrvStmtColumnValue:
1.571 + aIpcCallName.Set(KSqlSrvStmtColumnValue);
1.572 + break;
1.573 + case ESqlSrvStmtDeclColumnTypes:
1.574 + aIpcCallName.Set(KSqlSrvStmtDeclColumnTypes);
1.575 + break;
1.576 + case ESqlSrvStreamRead:
1.577 + aIpcCallName.Set(KSqlSrvStreamRead);
1.578 + break;
1.579 + case ESqlSrvStreamWrite:
1.580 + aIpcCallName.Set(KSqlSrvStreamWrite);
1.581 + break;
1.582 + case ESqlSrvStreamSize:
1.583 + aIpcCallName.Set(KSqlSrvStreamSize);
1.584 + break;
1.585 + case ESqlSrvStreamSynch:
1.586 + aIpcCallName.Set(KSqlSrvStreamSynch);
1.587 + break;
1.588 + case ESqlSrvStreamClose:
1.589 + aIpcCallName.Set(KSqlSrvStreamClose);
1.590 + break;
1.591 + default:
1.592 + return KErrNotSupported;
1.593 + };
1.594 + __ASSERT_DEBUG((TUint)rc < KIpcTraceTypeCount || rc == KErrNotFound, __SQLPANIC2(ESqlPanicInternalError));
1.595 + return rc;
1.596 + }
1.597 +
1.598 +//Calculates and returns the time difference between aStartTicks and aEndTicks in microseconds.
1.599 +static TInt SqlConvertTicks2Us(TUint32 aStartTicks, TUint32 aEndTicks)
1.600 + {
1.601 + static TInt freq = 0;
1.602 + if(freq == 0)
1.603 + {
1.604 + TInt err = HAL::Get(HAL::EFastCounterFrequency, freq);
1.605 + if(err != KErrNone)
1.606 + {
1.607 + __SQLPANIC2((TSqlPanic)err);
1.608 + }
1.609 + }
1.610 + TInt64 diffTicks = (TInt64)aEndTicks - (TInt64)aStartTicks;
1.611 + if(diffTicks < 0)
1.612 + {
1.613 + diffTicks = KMaxTUint32 + diffTicks + 1;
1.614 + }
1.615 + const TInt KMicroSecIn1Sec = 1000000;
1.616 + TInt32 us = (diffTicks * KMicroSecIn1Sec) / freq;
1.617 + return us;
1.618 + }
1.619 +
1.620 +//Calculates the time since the first time this function has been called.
1.621 +static TInt64 SqlTimeFromStartUs()
1.622 + {
1.623 + struct TStartTime
1.624 + {
1.625 + inline TStartTime()
1.626 + {
1.627 + iTime.UniversalTime();
1.628 + }
1.629 + TTime iTime;
1.630 + };
1.631 + static TStartTime startTime;
1.632 + TTime time;
1.633 + time.UniversalTime();
1.634 + TTimeIntervalMicroSeconds us = time.MicroSecondsFrom(startTime.iTime);
1.635 + const TInt64 KMaxDiff = 999999999999LL;//999999999999 is the max number that can be printed out using %12ld format spec
1.636 + if(us.Int64() < 0 || us.Int64() >= KMaxDiff)
1.637 + {
1.638 + startTime.iTime = time;
1.639 + us = 0;
1.640 + }
1.641 + return us.Int64();
1.642 + }
1.643 +
1.644 +
1.645 +//Tracing data buffer
1.646 +const TInt KSqlSrvProfilePrnBufSize = 300;
1.647 +static TBuf<KSqlSrvProfilePrnBufSize> TheSqlSrvProfileTraceBuf;
1.648 +static TBuf8<KSqlSrvProfilePrnBufSize> TheSqlSrvProfileTraceBuf8;
1.649 +
1.650 +static RFs TheSqlSrvTraceFs;
1.651 +static RFile TheTheSqlSrvTraceFile;
1.652 +_LIT(KSqlSrvTraceFileName, "C:\\SQLTRACE");
1.653 +
1.654 +//Prints out a time stamp
1.655 +static void SqlSrvProfileTimePrintf()
1.656 + {
1.657 + static TInt64 prevTimeDiff = 0;;
1.658 + TInt64 timeDiff = SqlTimeFromStartUs();
1.659 + const TInt64 KTimeInterval = 1000000;
1.660 + if((timeDiff - prevTimeDiff) >= KTimeInterval || timeDiff < prevTimeDiff)
1.661 + {
1.662 + prevTimeDiff = timeDiff;
1.663 + TTime time;
1.664 + time.UniversalTime();
1.665 + TDateTime dt = time.DateTime();
1.666 + TheSqlSrvProfileTraceBuf8.Format(_L8("[SQL]¬\"%X\"¬¬TME¬¬¬¬¬¬¬¬¬¬¬¬%02d:%02d:%02d:%06d¬Prep8¬%d¬Prep16¬%d¬Ex8¬%d¬Ex16¬%d"),
1.667 + timeDiff, dt.Hour(), dt.Minute(), dt.Second(), dt.MicroSecond(),
1.668 + TheSqlSrvProfilerPreparedCnt8, TheSqlSrvProfilerPreparedCnt16,
1.669 + TheSqlSrvProfilerExecutedCnt8, TheSqlSrvProfilerExecutedCnt16);
1.670 + if(TheSqlSrvProfilerTraceToFile)
1.671 + {
1.672 + TheSqlSrvProfileTraceBuf8.Append(_L8("\r\n"));
1.673 + (void)TheTheSqlSrvTraceFile.Write(TheSqlSrvProfileTraceBuf8);
1.674 + }
1.675 + else
1.676 + {
1.677 + TheSqlSrvProfileTraceBuf8.Append(_L8("\n"));
1.678 + RDebug::RawPrint(TheSqlSrvProfileTraceBuf8);
1.679 + }
1.680 + }
1.681 + }
1.682 +
1.683 +//Trace types
1.684 +enum TSqlSrvProfilerTraceType
1.685 + {
1.686 + ESqlSrvProfilerNonSqlTrace,
1.687 + ESqlSrvProfilerMiddleLineSqlTrace,
1.688 + ESqlSrvProfilerLastLineSqlTrace
1.689 + };
1.690 +
1.691 +//Prints out the data that is in TheSqlSrvProfileTraceBuf.
1.692 +// aType = ESqlSrvProfilerNonSqlTrace - non-SQL trace
1.693 +// aType = ESqlSrvProfilerMiddleLineSqlTrace - not last line of an SQL trace
1.694 +// aType = ESqlSrvProfilerLastLineSqlTrace - last line of an SQL trace
1.695 +static void SqlSrvProfilePrintf(TSqlSrvProfilerTraceType aType)
1.696 + {
1.697 + SqlSrvProfileTimePrintf();
1.698 + TheSqlSrvProfileTraceBuf8.Copy(TheSqlSrvProfileTraceBuf);
1.699 + if(TheSqlSrvProfilerTraceToFile)
1.700 + {
1.701 + if(aType == 0 || aType == 2)
1.702 + {
1.703 + TheSqlSrvProfileTraceBuf8.Append(_L8("\r\n"));
1.704 + }
1.705 + (void)TheTheSqlSrvTraceFile.Write(TheSqlSrvProfileTraceBuf8);
1.706 + }
1.707 + else
1.708 + {
1.709 + TheSqlSrvProfileTraceBuf8.Append(_L8("\n"));
1.710 + RDebug::RawPrint(TheSqlSrvProfileTraceBuf8);
1.711 + }
1.712 + }
1.713 +
1.714 +//Called at the beginning of CSqlSrvSession::ServiceL().
1.715 +void SqlIpcStart(TUint& aIpcCounter, TUint32& aStartTicks, TUint aDbHandle)
1.716 + {
1.717 + if(TheSqlSrvProfilerTraceEnabled)
1.718 + {
1.719 + TheSqlSrvProfilerFileRead = TheSqlSrvProfilerFileWrite = TheSqlSrvProfilerFileSync = TheSqlSrvProfilerFileSetSize = 0;
1.720 + if(TheSqlSrvProfilerTraceLevel == 0)
1.721 + {
1.722 + return;
1.723 + }
1.724 + if(KSqlSrvProfilerDbName().Length() > 0 && (aDbHandle == 0 || TheSqlSrvProfilerHandle != aDbHandle))
1.725 + {
1.726 + return;
1.727 + }
1.728 + ++aIpcCounter;
1.729 + aStartTicks = User::FastCounter();
1.730 + }
1.731 + }
1.732 +
1.733 +//Called at the end of CSqlSrvSession::ServiceL().
1.734 +void SqlIpcEnd(TUint aIpcCounter, TUint32 aStartTicks, TSqlSrvFunction aFuncCode,
1.735 + TUint aDbHandle, TSqlSrvIpcTraceData aIpcTraceData[], TInt aRetCode)
1.736 + {
1.737 + if(TheSqlSrvProfilerTraceEnabled)
1.738 + {
1.739 + if(TheSqlSrvProfilerTraceLevel == 0)
1.740 + {
1.741 + return;
1.742 + }
1.743 + if(KSqlSrvProfilerDbName().Length() > 0 && (aDbHandle == 0 || TheSqlSrvProfilerHandle != aDbHandle))
1.744 + {
1.745 + return;
1.746 + }
1.747 + TUint32 endTicks = User::FastCounter();
1.748 + TInt executionTime = SqlConvertTicks2Us(aStartTicks, endTicks);
1.749 + TPtrC ipcCallName;
1.750 + TInt ipcCallIdx = SqlIpcTraceIdxAndName(aFuncCode, ipcCallName);
1.751 + TInt64 timeFromStart = SqlTimeFromStartUs();
1.752 + TInt64 ttlExecTime = 0;
1.753 + TInt count = 0;
1.754 + if(ipcCallIdx >= 0)
1.755 + {
1.756 + aIpcTraceData[ipcCallIdx].iExecutionTime += executionTime;
1.757 + ttlExecTime = aIpcTraceData[ipcCallIdx].iExecutionTime;
1.758 + count = ++aIpcTraceData[ipcCallIdx].iCount;
1.759 + }
1.760 + if(ipcCallIdx >= 0 || (ipcCallIdx == KErrNotFound && TheSqlSrvProfilerTraceLevel == 2))
1.761 + {
1.762 + TheSqlSrvProfileTraceBuf.Format(_L("[SQL]¬\"%X\"¬%ld¬IPC¬%u¬%S¬%ld¬%d¬%d¬%d¬%d¬%d¬%d¬rc¬%d"),
1.763 + //[SQL]
1.764 + aDbHandle, //Database handle
1.765 + timeFromStart, //Time from start, microseconds
1.766 + //IPC
1.767 + aIpcCounter, //IPC sequence counter for this database (connection)
1.768 + &ipcCallName, //IPC call name
1.769 + ttlExecTime, //All time spent in this IPC call type for this database (connection)
1.770 + executionTime, //This IPC call execution time
1.771 + count, //This IPC call sequence counter for this database (connection)
1.772 + TheSqlSrvProfilerFileRead, //File read count, performed during this IPC
1.773 + TheSqlSrvProfilerFileWrite, //File write count, performed during this IPC
1.774 + TheSqlSrvProfilerFileSync, //File flush count, performed during this IPC
1.775 + TheSqlSrvProfilerFileSetSize, //File set size count, performed during this IPC
1.776 + aRetCode); //IPC call - return code
1.777 + SqlSrvProfilePrintf(ESqlSrvProfilerNonSqlTrace);
1.778 + }
1.779 + }
1.780 + }
1.781 +
1.782 +//Called at the end of CSqlSrvSession::ServiceError().
1.783 +void SqlIpcError(TUint aIpcCounter, TSqlSrvFunction aFuncCode, TUint aDbHandle, TInt aError)
1.784 + {
1.785 + if(TheSqlSrvProfilerTraceEnabled)
1.786 + {
1.787 + if(KSqlSrvProfilerDbName().Length() > 0 && (aDbHandle == 0 || TheSqlSrvProfilerHandle != aDbHandle))
1.788 + {
1.789 + return;
1.790 + }
1.791 + TPtrC ipcCallName;
1.792 + (void)SqlIpcTraceIdxAndName(aFuncCode, ipcCallName);
1.793 + TInt64 timeFromStart = SqlTimeFromStartUs();
1.794 + TheSqlSrvProfileTraceBuf.Format(_L("[SQL]¬\"%X\"¬%ld¬ERR¬%u¬%S¬¬¬¬¬¬¬¬err¬%d"),
1.795 + //[SQL]
1.796 + aDbHandle, //Database (connection) handle
1.797 + timeFromStart, //Time from start, microseconds
1.798 + //ERR
1.799 + aIpcCounter, //IPC sequence counter for this database (connection)
1.800 + &ipcCallName, //IPC call name
1.801 + aError); //IPC call - return code
1.802 + SqlSrvProfilePrintf(ESqlSrvProfilerNonSqlTrace);
1.803 + }
1.804 + }
1.805 +
1.806 +//Prints the passed as a parameter 16-bit SQL statement.
1.807 +void SqlPrintSql16(TUint aDbHandle, const TDesC& aSql, TBool aPrepare)
1.808 + {
1.809 + if(!TheSqlSrvProfilerTraceEnabled || !TheSqlSrvProfilerSqlTraceEnabled)
1.810 + {
1.811 + return;
1.812 + }
1.813 + if(KSqlSrvProfilerDbName().Length() > 0 && (aDbHandle == 0 || TheSqlSrvProfilerHandle != aDbHandle))
1.814 + {
1.815 + return;
1.816 + }
1.817 +
1.818 + aPrepare ? ++TheSqlSrvProfilerPreparedCnt16 : ++TheSqlSrvProfilerExecutedCnt16;
1.819 +
1.820 + TInt64 timeFromStart = SqlTimeFromStartUs();
1.821 + TPtr line((TUint16*)TheSqlTraceBuf.Ptr(), 0, TheSqlTraceBuf.MaxLength());
1.822 + TInt len = aSql.Length();
1.823 + TInt pos = 0;
1.824 + do
1.825 + {
1.826 + _LIT(KPrepare, "Prepare16");
1.827 + _LIT(KExec, "Exec16");
1.828 + _LIT(KEmptyStr, "");
1.829 + if(pos == 0)
1.830 + {
1.831 + line.Format(_L("[SQL]¬\"%X\"¬%ld¬SQL¬¬%S¬¬¬¬¬¬¬¬¬¬"), aDbHandle, timeFromStart, aPrepare ? &KPrepare : &KExec);
1.832 + }
1.833 + else
1.834 + {
1.835 + if(!TheSqlSrvProfilerTraceToFile)
1.836 + {
1.837 + line.Format(_L("[SQL]¬\"%X\"¬%ld¬SQL¬¬%S¬¬¬¬¬¬¬¬¬¬"), aDbHandle, timeFromStart, &KEmptyStr);
1.838 + }
1.839 + }
1.840 + TInt l = Min(len, (line.MaxLength() - line.Length()));
1.841 + TPtrC ptr(aSql.Ptr() + pos, l);
1.842 + pos += l;
1.843 + len -= l;
1.844 + line.Append(ptr);
1.845 + TheSqlSrvProfileTraceBuf.Format(_L("%S"), &line);
1.846 + SqlSrvProfilePrintf(len > 0 ? ESqlSrvProfilerMiddleLineSqlTrace : ESqlSrvProfilerLastLineSqlTrace);
1.847 + line.Zero();
1.848 + } while(len > 0);
1.849 + }
1.850 +
1.851 +//Prints the passed as a parameter 8-bit SQL statement.
1.852 +void SqlPrintSql8(TUint aDbHandle, const TDesC8& aSql, TBool aPrepare)
1.853 + {
1.854 + if(!TheSqlSrvProfilerTraceEnabled || !TheSqlSrvProfilerSqlTraceEnabled)
1.855 + {
1.856 + return;
1.857 + }
1.858 + if(KSqlSrvProfilerDbName().Length() > 0 && (aDbHandle == 0 || TheSqlSrvProfilerHandle != aDbHandle))
1.859 + {
1.860 + return;
1.861 + }
1.862 +
1.863 + aPrepare ? ++TheSqlSrvProfilerPreparedCnt8 : ++TheSqlSrvProfilerExecutedCnt8;
1.864 +
1.865 + TInt64 timeFromStart = SqlTimeFromStartUs();
1.866 + TPtr line((TUint16*)TheSqlTraceBuf.Ptr(), 0, TheSqlTraceBuf.MaxLength());
1.867 + TInt len = aSql.Length();
1.868 + TInt pos = 0;
1.869 + do
1.870 + {
1.871 + _LIT(KPrepare, "Prepare8");
1.872 + _LIT(KExec, "Exec8");
1.873 + _LIT(KEmptyStr, "");
1.874 + if(pos == 0)
1.875 + {
1.876 + line.Format(_L("[SQL]¬\"%X\"¬%ld¬SQL¬¬%S¬¬¬¬¬¬¬¬¬¬"), aDbHandle, timeFromStart, aPrepare ? &KPrepare : &KExec);
1.877 + }
1.878 + else
1.879 + {
1.880 + if(!TheSqlSrvProfilerTraceToFile)
1.881 + {
1.882 + line.Format(_L("[SQL]¬\"%X\"¬%ld¬SQL¬¬%S¬¬¬¬¬¬¬¬¬¬"), aDbHandle, timeFromStart, &KEmptyStr);
1.883 + }
1.884 + }
1.885 + TInt l = Min(len, (line.MaxLength() - line.Length()));
1.886 + TPtrC8 ptr(aSql.Ptr() + pos, l);
1.887 + pos += l;
1.888 + len -= l;
1.889 + TPtr p2((TUint16*)line.Ptr() + line.Length(), 0, l);
1.890 + p2.Copy(ptr);
1.891 + line.SetLength(line.Length() + p2.Length());
1.892 + TheSqlSrvProfileTraceBuf.Format(_L("%S"), &line);
1.893 + SqlSrvProfilePrintf(len > 0 ? ESqlSrvProfilerMiddleLineSqlTrace : ESqlSrvProfilerLastLineSqlTrace);
1.894 + line.Zero();
1.895 + } while(len > 0);
1.896 + }
1.897 +
1.898 +//Prints the name of the just created database.
1.899 +void SqlPrintDbCreate(TUint aDbHandle, const TDesC& aDbName)
1.900 + {
1.901 + if(TheSqlSrvProfilerTraceEnabled)
1.902 + {
1.903 + if(KSqlSrvProfilerDbName().Length() > 0 && aDbName.FindF(KSqlSrvProfilerDbName) >= 0)
1.904 + {
1.905 + TheSqlSrvProfilerHandle = aDbHandle;
1.906 + }
1.907 + if(KSqlSrvProfilerDbName().Length() > 0 && (aDbHandle == 0 || TheSqlSrvProfilerHandle != aDbHandle))
1.908 + {
1.909 + return;
1.910 + }
1.911 + TInt64 timeFromStart = SqlTimeFromStartUs();
1.912 + TheSqlSrvProfileTraceBuf.Format(_L("[SQL]¬\"%X\"¬%ld¬CRE¬¬¬¬¬¬¬¬¬¬¬¬%S"),
1.913 + aDbHandle,
1.914 + timeFromStart,
1.915 + &aDbName);
1.916 + SqlSrvProfilePrintf(ESqlSrvProfilerNonSqlTrace);
1.917 + }
1.918 + }
1.919 +
1.920 +//Prints the name of the just opened database.
1.921 +void SqlPrintDbOpen(TUint aDbHandle, const TDesC& aDbName)
1.922 + {
1.923 + if(TheSqlSrvProfilerTraceEnabled)
1.924 + {
1.925 + if(KSqlSrvProfilerDbName().Length() > 0 && aDbName.FindF(KSqlSrvProfilerDbName) >= 0)
1.926 + {
1.927 + TheSqlSrvProfilerHandle = aDbHandle;
1.928 + }
1.929 + if(KSqlSrvProfilerDbName().Length() > 0 && (aDbHandle == 0 || TheSqlSrvProfilerHandle != aDbHandle))
1.930 + {
1.931 + return;
1.932 + }
1.933 + TInt64 timeFromStart = SqlTimeFromStartUs();
1.934 + TheSqlSrvProfileTraceBuf.Format(_L("[SQL]¬\"%X\"¬%ld¬OPN¬¬¬¬¬¬¬¬¬¬¬¬%S"),
1.935 + aDbHandle,
1.936 + timeFromStart,
1.937 + &aDbName);
1.938 + SqlSrvProfilePrintf(ESqlSrvProfilerNonSqlTrace);
1.939 + }
1.940 + }
1.941 +
1.942 +//Prints the handle of the just closed database.
1.943 +void SqlPrintDbClose(TUint aDbHandle)
1.944 + {
1.945 + if(TheSqlSrvProfilerTraceEnabled)
1.946 + {
1.947 + if(KSqlSrvProfilerDbName().Length() > 0 && (aDbHandle == 0 || TheSqlSrvProfilerHandle != aDbHandle))
1.948 + {
1.949 + return;
1.950 + }
1.951 + TInt64 timeFromStart = SqlTimeFromStartUs();
1.952 + TheSqlSrvProfileTraceBuf.Format(_L("[SQL]¬\"%X\"¬%ld¬CSE"),
1.953 + aDbHandle,
1.954 + timeFromStart);
1.955 + SqlSrvProfilePrintf(ESqlSrvProfilerNonSqlTrace);
1.956 + if(aDbHandle == TheSqlSrvProfilerHandle)
1.957 + {
1.958 + TheSqlSrvProfilerHandle = 0;
1.959 + }
1.960 + }
1.961 + }
1.962 +
1.963 +//Prints a trace when the SQL server starts
1.964 +void SqlPrintServerStart()
1.965 + {
1.966 + TInt64 timeFromStart = SqlTimeFromStartUs();
1.967 + if(TheSqlSrvProfilerTraceToFile)
1.968 + {
1.969 + TInt err = TheSqlSrvTraceFs.Connect();
1.970 + if(err == KErrNone)
1.971 + {
1.972 + TInt fileNum = 0;
1.973 + err = KErrGeneral;
1.974 + while(++fileNum < 1000 && err != KErrNone)
1.975 + {
1.976 + TBuf<80> ftrname;
1.977 + ftrname.Copy(KSqlSrvTraceFileName);
1.978 + ftrname.AppendNum(fileNum);
1.979 + ftrname.Append(_L(".txt"));
1.980 + err = TheTheSqlSrvTraceFile.Create(TheSqlSrvTraceFs, ftrname, EFileRead | EFileWrite);
1.981 + if(err == KErrNone)
1.982 + {
1.983 + break;
1.984 + }
1.985 + }
1.986 + }
1.987 + if(err != KErrNone)
1.988 + {
1.989 + TheSqlSrvTraceFs.Close();
1.990 + TheSqlSrvProfilerTraceToFile = EFalse;
1.991 + RDebug::Print(_L("SQL trace file creation failed with err=%d"), err);
1.992 + }
1.993 + }
1.994 + TheSqlSrvProfileTraceBuf.Format(_L("[SQL]¬¬%ld¬SRV¬¬Start"), timeFromStart);
1.995 + SqlSrvProfilePrintf(ESqlSrvProfilerNonSqlTrace);
1.996 + }
1.997 +
1.998 +//Prints a trace when the SQL server stops
1.999 +void SqlPrintServerStop()
1.1000 + {
1.1001 + TInt64 timeFromStart = SqlTimeFromStartUs();
1.1002 + TheSqlSrvProfileTraceBuf.Format(_L("[SQL]¬¬%ld¬SRV¬¬Stop"), timeFromStart);
1.1003 + SqlSrvProfilePrintf(ESqlSrvProfilerNonSqlTrace);
1.1004 + if(TheSqlSrvProfilerTraceToFile)
1.1005 + {
1.1006 + TheTheSqlSrvTraceFile.Close();
1.1007 + TheSqlSrvTraceFs.Close();
1.1008 + }
1.1009 + }
1.1010 +
1.1011 +#else //_SQLPROFILER
1.1012 +
1.1013 +void TSqlSrvResourceProfiler::StartL(const RMessage2&)
1.1014 + {
1.1015 + __SQLLEAVE2(KErrNotSupported);
1.1016 + }
1.1017 +
1.1018 +void TSqlSrvResourceProfiler::StopL(const RMessage2&)
1.1019 + {
1.1020 + __SQLLEAVE2(KErrNotSupported);
1.1021 + }
1.1022 +
1.1023 +void TSqlSrvResourceProfiler::ResetL(const RMessage2&)
1.1024 + {
1.1025 + __SQLLEAVE2(KErrNotSupported);
1.1026 + }
1.1027 +
1.1028 +void TSqlSrvResourceProfiler::QueryL(const RMessage2&)
1.1029 + {
1.1030 + __SQLLEAVE2(KErrNotSupported);
1.1031 + }
1.1032 +
1.1033 +#endif//_SQLPROFILER