MercurialSymaptic / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
os/persistentdata/persistentstorage/sql/SRC/Server/SqlSrvResourceProfiler.cpp
author sl@SLION-WIN7.fritz.box
Fri, 15 Jun 2012 03:10:57 +0200
changeset 0 bde4ae8d615e
permissions -rw-r--r--
First public contribution. 
     1 // Copyright (c) 2008-2010 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 <f32file.h>

    17 #include "SqlAssert.h"

    18 #include "SqlSrvResourceProfiler.h"

    19 #include "SqlResourceProfiler.h"

    20 #include "SqliteSymbian.h"

    21 #include <hal.h>

    22 

    23 #ifdef _SQLPROFILER

    24 

    25 ///////////////////////////////// Heap max alloc /////////////////////////////////////

    26 

    27 /**

    28 If true the max alloc profiling is enabled.

    29 @internalComponent

    30 */

    31 TBool TheSqlSrvProfilerMaxAllocEnabled = EFalse;

    32 /**

    33 The size of the biggest memory block ever allocated by the SQL server.

    34 Set only if compiled with _SQLPROFILER macro.

    35 @internalComponent

    36 */

    37 TInt  TheSqlSrvProfilerMaxAllocSize = 0;

    38 

    39 ////////////////////////// IPC & SQL tracing related //////////////////////////////////

    40 

    41 /**

    42 If true the tracing is enabled (IPC calls & SQL statements).

    43 @internalComponent

    44 */

    45 static TBool TheSqlSrvProfilerTraceEnabled = EFalse;

    46 /**

    47 Trace level:

    48  - 0: no IPC calls traced (default);

    49  - 1: only the 10 most important IPC calls traced - SQL statement execution, ....

    50  - 2: all IPC calls traced; 

    51 @internalComponent

    52 */

    53 static TInt TheSqlSrvProfilerTraceLevel = 0;

    54 /**

    55 If true the SQL statement tracing is enabled.

    56 @internalComponent

    57 */

    58 static TBool TheSqlSrvProfilerSqlTraceEnabled = EFalse;

    59 

    60 /**

    61 When KSqlSrvProfilerDbName is with non-zero length, then only traces coming from database identified by

    62 KSqlSrvProfilerDbName name are printed out. 

    63 @internalComponent

    64 */

    65 //_LIT(KSqlSrvProfilerDbName, "default_avacon.dbSQL");

    66 _LIT(KSqlSrvProfilerDbName, "");

    67 static TUint TheSqlSrvProfilerHandle = 0;

    68 

    69 //File "read", "write", "sync" and "set size" counters, incremented inside the OS porting layer.

    70 TInt TheSqlSrvProfilerFileRead = 0;

    71 TInt TheSqlSrvProfilerFileWrite = 0;

    72 TInt TheSqlSrvProfilerFileSync = 0;

    73 TInt TheSqlSrvProfilerFileSetSize = 0;

    74 

    75 //Set it to true if you want traces to be stored into a file.

    76 static TBool TheSqlSrvProfilerTraceToFile = EFalse;

    77 

    78 //"Prepared" and "Executed" SQL statement counters

    79 static TInt TheSqlSrvProfilerPreparedCnt8 = 0;

    80 static TInt TheSqlSrvProfilerPreparedCnt16 = 0;

    81 static TInt TheSqlSrvProfilerExecutedCnt8 = 0;

    82 static TInt TheSqlSrvProfilerExecutedCnt16 = 0;

    83 

    84 ///////////////////////////////// IPC counters ///////////////////////////////////////

    85 

    86 /**

    87 If true the IPC profiling is enabled.

    88 @internalComponent

    89 */

    90 TBool TheSqlSrvProfilerIpcEnabled = EFalse;

    91 /**

    92 IPC requests, read and write counters.

    93 @internalComponent

    94 */

    95 TInt  TheSqlSrvProfilerIpc[ESqlIpcLast] = {0};

    96 /**

    97 IPC read and write - bytes.

    98 @internalComponent

    99 */

   100 TInt64 TheSqlSrvProfilerIpcBytes[ESqlIpcLast] = {0};

   101 

   102 //////////////////////////////////////////////////////////////////////////////////////

   103 

   104 /**

   105 Starts the specified profiling counter.

   106 

   107 @leave KErrNotSupported, The requested profiling type is not supported;

   108                  		 The function may also leave with some other system-wide error codes.

   109 

   110 Usage of the IPC call arguments:

   111  - Arg 0: [in]  profiling counter type, one of the TSqlResourceProfiler::TSqlCounter enum item values.

   112  - Arg 1: [in]  the length of the additional profiling parameters.

   113  - Arg 2: [in]  additional profiling parameters.

   114 */

   115 void TSqlSrvResourceProfiler::StartL(const RMessage2& aMessage)

   116 	{

   117 	const TSqlResourceProfiler::TSqlCounter KCounterType = static_cast <TSqlResourceProfiler::TSqlCounter> (aMessage.Int0());

   118 	TInt err = KErrNone;

   119 	switch(KCounterType)

   120 		{

   121 		case TSqlResourceProfiler::ESqlCounterFileIO:

   122 		case TSqlResourceProfiler::ESqlCounterOsCall:

   123 		case TSqlResourceProfiler::ESqlCounterOsCallTime:

   124 		case TSqlResourceProfiler::ESqlCounterOsCallDetails:

   125 			err = sqlite3SymbianProfilerStart(KCounterType);

   126 			break;

   127 		case TSqlResourceProfiler::ESqlCounterIpc:

   128 			TheSqlSrvProfilerIpcEnabled = ETrue;

   129 			break;

   130 		case TSqlResourceProfiler::ESqlCounterMemory:

   131 			err = sqlite3SymbianProfilerStart(KCounterType);

   132 			break;

   133 		case TSqlResourceProfiler::ESqlCounterMaxAlloc:

   134 			TheSqlSrvProfilerMaxAllocEnabled = ETrue;

   135 			err = sqlite3SymbianProfilerStart(KCounterType);

   136 			break;

   137 		case TSqlResourceProfiler::ESqlCounterTrace:

   138 		    {

   139 			TheSqlSrvProfilerTraceEnabled = ETrue;

   140 		    TInt len = aMessage.Int1();

   141 		    __SQLPANIC_CLIENT2((TUint)len < 64, aMessage, ESqlPanicBadArgument);

   142 		    if(len > 0)

   143 		        {

   144                 TBuf8<64> prmBuf;

   145                 aMessage.ReadL(2, prmBuf);

   146                 prmBuf.UpperCase();

   147                 TPtrC8 ptr(prmBuf);

   148                 _LIT8(KLevel0, "L0");

   149                 _LIT8(KLevel1, "L1");

   150                 _LIT8(KLevel2, "L2");

   151                 _LIT8(KSqlStmtTraceOff, "S0");

   152                 _LIT8(KSqlStmtTraceOn, "S1");

   153                 while(ptr.Length() > 0)

   154                     {

   155                     TInt pos = ptr.Locate(TChar(';'));

   156                     TPtrC8 str = ptr;

   157                     if(pos >= 0)

   158                         {

   159                         str.Set(ptr.Left(pos));

   160                         }

   161                     if(str == KLevel0)

   162                         {

   163                         TheSqlSrvProfilerTraceLevel = 0;

   164                         }

   165                     else if(str == KLevel1)

   166                         {

   167                         TheSqlSrvProfilerTraceLevel = 1;

   168                         }

   169                     else if(str == KLevel2)

   170                         {

   171                         TheSqlSrvProfilerTraceLevel = 2;

   172                         }

   173                     else if(str == KSqlStmtTraceOff)

   174                         {

   175                         TheSqlSrvProfilerSqlTraceEnabled = EFalse;

   176                         }

   177                     else if(str == KSqlStmtTraceOn)

   178                         {

   179                         TheSqlSrvProfilerSqlTraceEnabled = ETrue;

   180                         }

   181                     if((TUint)pos > (ptr.Length() - 1))

   182                         {

   183                         break;

   184                         }

   185                     ptr.Set(ptr.Mid(pos + 1));

   186                     }

   187 		        }

   188 		    }

   189 			break;

   190 		default:

   191 			err = KErrNotSupported;

   192 			break;

   193 		}

   194 	__SQLLEAVE_IF_ERROR2(err);

   195 	}

   196 	

   197 /**

   198 Stops the specified profiling counter.

   199 

   200 @leave KErrNotSupported, The requested profiling type is not supported;

   201                  		 The function may also leave with some other system-wide error codes.

   202 

   203 Usage of the IPC call arguments:

   204  - Arg 0: [in]  profiling counter type, one of the TSqlResourceProfiler::TSqlCounter enum item values.

   205 */

   206 void TSqlSrvResourceProfiler::StopL(const RMessage2& aMessage)

   207 	{

   208 	const TSqlResourceProfiler::TSqlCounter KCounterType = static_cast <TSqlResourceProfiler::TSqlCounter> (aMessage.Int0());

   209 	TInt err = KErrNone;

   210 	switch(KCounterType)

   211 		{

   212 		case TSqlResourceProfiler::ESqlCounterFileIO:

   213 		case TSqlResourceProfiler::ESqlCounterOsCall:

   214 		case TSqlResourceProfiler::ESqlCounterOsCallTime:

   215 		case TSqlResourceProfiler::ESqlCounterOsCallDetails:

   216 			err = sqlite3SymbianProfilerStop(KCounterType);

   217 			break;

   218 		case TSqlResourceProfiler::ESqlCounterIpc:

   219 			TheSqlSrvProfilerIpcEnabled = EFalse;

   220 			break;

   221 		case TSqlResourceProfiler::ESqlCounterMemory:

   222 			err = sqlite3SymbianProfilerStop(KCounterType);

   223 			break;

   224 		case TSqlResourceProfiler::ESqlCounterMaxAlloc:

   225 			TheSqlSrvProfilerMaxAllocEnabled = EFalse;

   226 			err = sqlite3SymbianProfilerStop(KCounterType);

   227 			break;

   228         case TSqlResourceProfiler::ESqlCounterTrace:

   229             TheSqlSrvProfilerTraceEnabled = EFalse;

   230             TheSqlSrvProfilerSqlTraceEnabled = EFalse;

   231             TheSqlSrvProfilerTraceLevel = 0;

   232             TheSqlSrvProfilerHandle = 0;

   233             break;

   234 		default:

   235 			err = KErrNotSupported;

   236 			break;

   237 		}

   238 	__SQLLEAVE_IF_ERROR2(err);

   239 	}

   240 	

   241 /**

   242 Resets the specified profiling counter.

   243 

   244 @leave KErrNotSupported, The requested profiling type is not supported;

   245                  		 The function may also leave with some other system-wide error codes.

   246 

   247 Usage of the IPC call arguments:

   248  - Arg 0: [in]  profiling counter type, one of the TSqlResourceProfiler::TSqlCounter enum item values.

   249 */

   250 void TSqlSrvResourceProfiler::ResetL(const RMessage2& aMessage)

   251 	{

   252 	const TSqlResourceProfiler::TSqlCounter KCounterType = static_cast <TSqlResourceProfiler::TSqlCounter> (aMessage.Int0());

   253 	TInt err = KErrNone;

   254 	switch(KCounterType)

   255 		{

   256 		case TSqlResourceProfiler::ESqlCounterFileIO:

   257 		case TSqlResourceProfiler::ESqlCounterOsCall:

   258 		case TSqlResourceProfiler::ESqlCounterOsCallTime:

   259 		case TSqlResourceProfiler::ESqlCounterOsCallDetails:

   260 			err = sqlite3SymbianProfilerReset(KCounterType);

   261 			break;

   262 		case TSqlResourceProfiler::ESqlCounterIpc:

   263 			Mem::FillZ(TheSqlSrvProfilerIpc, sizeof(TheSqlSrvProfilerIpc));

   264 			Mem::FillZ(TheSqlSrvProfilerIpcBytes, sizeof(TheSqlSrvProfilerIpcBytes));

   265 			break;

   266 		case TSqlResourceProfiler::ESqlCounterMemory:

   267 			err = sqlite3SymbianProfilerReset(KCounterType);

   268 			break;

   269 		case TSqlResourceProfiler::ESqlCounterMaxAlloc:

   270 			TheSqlSrvProfilerMaxAllocSize = 0;

   271 			err = sqlite3SymbianProfilerReset(KCounterType);

   272 			break;

   273         case TSqlResourceProfiler::ESqlCounterTrace:

   274             break;

   275 		default:

   276 			err = KErrNotSupported;

   277 			break;

   278 		}

   279 	__SQLLEAVE_IF_ERROR2(err);

   280 	}

   281 	

   282 /**

   283 Retrieves the counter values for the specified profiling counter.

   284 

   285 @leave KErrNotSupported, The requested profiling type is not supported;

   286                  		 The function may also leave with some other system-wide error codes.

   287 

   288 @see TSqlResourceProfiler

   289 

   290 Usage of the IPC call arguments:

   291  - Arg 0: [in]  profiling counter type, one of the TSqlResourceProfiler::TSqlCounter enum item values.

   292  - Arg 1: [in]  the size of the buffer for the profiling counter values.

   293  - Arg 2: [out] the buffer for the profiling counter values.

   294 */

   295 void TSqlSrvResourceProfiler::QueryL(const RMessage2& aMessage)

   296 	{

   297 	const TSqlResourceProfiler::TSqlCounter KCounterType = static_cast <TSqlResourceProfiler::TSqlCounter> (aMessage.Int0());

   298 	const TInt KIpcBufLen = 300;

   299 	TBuf8<KIpcBufLen> ipcBuf;

   300 	TInt err = KErrNone;

   301 	switch(KCounterType)

   302 		{

   303 		case TSqlResourceProfiler::ESqlCounterFileIO:

   304 		case TSqlResourceProfiler::ESqlCounterOsCall:

   305 		case TSqlResourceProfiler::ESqlCounterOsCallTime:

   306 		case TSqlResourceProfiler::ESqlCounterOsCallDetails:

   307 			err = sqlite3SymbianProfilerQuery(KCounterType, ipcBuf);

   308 			break;

   309 		case TSqlResourceProfiler::ESqlCounterIpc:

   310 			ipcBuf.AppendNum(TheSqlSrvProfilerIpc[ESqlIpcRq]);

   311 			ipcBuf.Append(TChar(';'));

   312 			ipcBuf.AppendNum(TheSqlSrvProfilerIpc[ESqlIpcRead]);

   313 			ipcBuf.Append(TChar(';'));

   314 			ipcBuf.AppendNum(TheSqlSrvProfilerIpc[ESqlIpcWrite]);

   315 			ipcBuf.Append(TChar(';'));

   316 			ipcBuf.AppendNum(TheSqlSrvProfilerIpcBytes[ESqlIpcRead]);

   317 			ipcBuf.Append(TChar(';'));

   318 			ipcBuf.AppendNum(TheSqlSrvProfilerIpcBytes[ESqlIpcWrite]);

   319 			ipcBuf.Append(TChar(';'));

   320 			break;

   321 		case TSqlResourceProfiler::ESqlCounterMemory:

   322 			{

   323 			TInt totalAllocCells = 0;

   324 			TInt totalAllocSize = 0;

   325 			TInt totalFreeSpace = 0;

   326 			TInt biggestBlockSize = 0;

   327 			RHeap& heap = User::Heap();;

   328 			totalAllocCells = heap.AllocSize(totalAllocSize);

   329 			totalFreeSpace = heap.Available(biggestBlockSize);

   330 			ipcBuf.AppendNum(totalAllocCells);

   331 			ipcBuf.Append(TChar(';'));

   332 			ipcBuf.AppendNum(totalAllocSize);

   333 			ipcBuf.Append(TChar(';'));

   334 			ipcBuf.AppendNum(totalFreeSpace);

   335 			ipcBuf.Append(TChar(';'));

   336 			ipcBuf.AppendNum(biggestBlockSize);

   337 			ipcBuf.Append(TChar(';'));

   338 			err = sqlite3SymbianProfilerQuery(KCounterType, ipcBuf);

   339 			}

   340 			break;

   341 		case TSqlResourceProfiler::ESqlCounterMaxAlloc:

   342 			ipcBuf.AppendNum(TheSqlSrvProfilerMaxAllocSize);

   343 			ipcBuf.Append(TChar(';'));

   344 			err = sqlite3SymbianProfilerQuery(KCounterType, ipcBuf);

   345 			break;

   346         case TSqlResourceProfiler::ESqlCounterTrace:

   347             break;

   348 		default:

   349 			err = KErrNotSupported;

   350 			break;

   351 		}

   352 	__SQLLEAVE_IF_ERROR2(err);

   353 	aMessage.WriteL(2, ipcBuf);

   354 	}

   355 	

   356 ////////////////////////// IPC tracing related ////////////////////////////////////////

   357 

   358 //Max trace line length

   359 const TInt KSqlTraceMaxLength = 220;

   360 //Trace buffer.

   361 static TBuf<KSqlTraceMaxLength> TheSqlTraceBuf;

   362 

   363 //IPC calls names - begin

   364 _LIT(KSqlSrvDbCreate, "DbCreate");

   365 _LIT(KSqlSrvDbCreateSecure, "DbCreateSecure");

   366 _LIT(KSqlSrvDbOpen, "DbOpen");

   367 _LIT(KSqlSrvDbOpenFromHandle, "DbOpenFromHandle");

   368 _LIT(KSqlSrvDbClose, "DbClose");

   369 _LIT(KSqlSrvDbCopy, "DbCopy");

   370 _LIT(KSqlSrvDbDelete, "DbDelete");

   371 _LIT(KSqlSrvLastErrorMsg, "LastErrorMsg");

   372 _LIT(KSqlSrvDbExec8, "DbExec8");

   373 _LIT(KSqlSrvDbExec16, "DbExec16");

   374 _LIT(KSqlSrvDbSetIsolationLevel, "DbSetIsolationLevel");

   375 _LIT(KSqlSrvDbGetSecurityPolicy, "DbGetSecurityPolicy");

   376 _LIT(KSqlSrvDbAttach, "DbAttach");

   377 _LIT(KSqlSrvDbAttachFromHandle, "DbAttachFromHandle");

   378 _LIT(KSqlSrvDbDetach, "DbDetach");

   379 _LIT(KSqlSrvDbScalarFullSelect8, "DbScalarFullSelect8");

   380 _LIT(KSqlSrvDbScalarFullSelect16, "DbScalarFullSelect16");

   381 _LIT(KSqlSrvDbInTransaction, "DbInTransaction");

   382 _LIT(KSqlSrvDbSize, "DbSize");

   383 _LIT(KSqlSrvDbSize2, "DbSize2");

   384 _LIT(KSqlSrvDbBlobSource, "DbBlobSource");

   385 _LIT(KSqlSrvDbLastInsertedRowId, "DbLastInsertedRowId");

   386 _LIT(KSqlSrvDbCompact, "DbCompact");

   387 _LIT(KSqlSrvDbReserveDriveSpace, "DbReserveDriveSpace");

   388 _LIT(KSqlSrvDbFreeReservedSpace, "DbFreeReservedSpace");

   389 _LIT(KSqlSrvDbGetReserveAccess, "DbGetReserveAccess");

   390 _LIT(KSqlSrvDbReleaseReserveAccess, "DbReleaseReserveAccess");

   391 _LIT(KSqlSrvStmtPrepare8, "StmtPrepare8");

   392 _LIT(KSqlSrvStmtPrepare16, "StmtPrepare16");

   393 _LIT(KSqlSrvStmtClose, "StmtClose");

   394 _LIT(KSqlSrvStmtReset, "StmtReset");

   395 _LIT(KSqlSrvStmtExec, "StmtExec");

   396 _LIT(KSqlSrvStmtAsyncExec, "StmtAsyncExec");

   397 _LIT(KSqlSrvStmtBindExec, "StmtBindExec");

   398 _LIT(KSqlSrvStmtAsyncBindExec, "StmtAsyncBindExec");

   399 _LIT(KSqlSrvStmtNext, "StmtNext");

   400 _LIT(KSqlSrvStmtBindNext, "StmtBindNext");

   401 _LIT(KSqlSrvStmtColumnNames, "StmtColumnNames");

   402 _LIT(KSqlSrvStmtParamNames, "StmtParamNames");

   403 _LIT(KSqlSrvStmtColumnSource, "StmtColumnSource");

   404 _LIT(KSqlSrvStmtBinParamSink, "StmtBinParamSink");

   405 _LIT(KSqlSrvStmtTxtParamSink16, "StmtTxtParamSink16");

   406 _LIT(KSqlSrvStmtBufFlat, "StmtBufFlat");

   407 _LIT(KSqlSrvStmtColumnValue, "StmtColumnValue");

   408 _LIT(KSqlSrvStmtDeclColumnTypes, "StmtDeclColumnTypes");

   409 _LIT(KSqlSrvStreamRead, "StreamRead");

   410 _LIT(KSqlSrvStreamWrite, "StreamWrite");

   411 _LIT(KSqlSrvStreamSize, "StreamSize");

   412 _LIT(KSqlSrvStreamSynch, "StreamSynch");

   413 _LIT(KSqlSrvStreamClose, "StreamClose");

   414 //IPC calls names - end

   415 

   416 //Gets as an argument the IPC call type in "aCode" parameter.

   417 //Returns: 

   418 // 0 or positive integer: the IPC call is one of the 10 most important IPC calls (trace level 0).

   419 // KErrNotFound         : the IPC call is some of the other possible call types (trace level 1).

   420 // KErrNotSupported     : unknown IPC call type.

   421 //

   422 // aIpcCallName will always be set to IPC call name descriptor.

   423 static TInt SqlIpcTraceIdxAndName(TSqlSrvFunction aCode, TPtrC& aIpcCallName)

   424     {

   425     TInt rc = KErrNotFound;

   426     switch(aCode)

   427         {

   428         case ESqlSrvDbCreate:

   429             aIpcCallName.Set(KSqlSrvDbCreate);

   430             break;

   431         case ESqlSrvDbCreateSecure:

   432             aIpcCallName.Set(KSqlSrvDbCreateSecure);

   433             break;

   434         case ESqlSrvDbOpen:

   435             aIpcCallName.Set(KSqlSrvDbOpen);

   436             break;

   437         case ESqlSrvDbOpenFromHandle:

   438             aIpcCallName.Set(KSqlSrvDbOpenFromHandle);

   439             break;

   440         case ESqlSrvDbClose:

   441             aIpcCallName.Set(KSqlSrvDbClose);

   442             break;

   443         case ESqlSrvDbCopy:

   444             aIpcCallName.Set(KSqlSrvDbCopy);

   445             break;

   446         case ESqlSrvDbDelete:

   447             aIpcCallName.Set(KSqlSrvDbDelete);

   448             break;

   449         case ESqlSrvLastErrorMsg:

   450             aIpcCallName.Set(KSqlSrvLastErrorMsg);

   451             break;

   452         case ESqlSrvDbExec8:

   453             aIpcCallName.Set(KSqlSrvDbExec8);

   454             rc = 0;

   455             break;

   456         case ESqlSrvDbExec16:

   457             aIpcCallName.Set(KSqlSrvDbExec16);

   458             rc = 1;

   459             break;

   460         case ESqlSrvDbSetIsolationLevel:

   461             aIpcCallName.Set(KSqlSrvDbSetIsolationLevel);

   462             break;

   463         case ESqlSrvDbGetSecurityPolicy:

   464             aIpcCallName.Set(KSqlSrvDbGetSecurityPolicy);

   465             break;

   466         case ESqlSrvDbAttach:

   467             aIpcCallName.Set(KSqlSrvDbAttach);

   468             break;

   469         case ESqlSrvDbAttachFromHandle:

   470             aIpcCallName.Set(KSqlSrvDbAttachFromHandle);

   471             break;

   472         case ESqlSrvDbDetach:

   473             aIpcCallName.Set(KSqlSrvDbDetach);

   474             break;

   475         case ESqlSrvDbScalarFullSelect8:

   476             aIpcCallName.Set(KSqlSrvDbScalarFullSelect8);

   477             rc = 2;

   478             break;

   479         case ESqlSrvDbScalarFullSelect16:

   480             aIpcCallName.Set(KSqlSrvDbScalarFullSelect16);

   481             rc = 3;

   482             break;

   483         case ESqlSrvDbInTransaction:

   484             aIpcCallName.Set(KSqlSrvDbInTransaction);

   485             break;

   486         case ESqlSrvDbSize:

   487             aIpcCallName.Set(KSqlSrvDbSize);

   488             break;

   489         case ESqlSrvDbSize2:

   490             aIpcCallName.Set(KSqlSrvDbSize2);

   491             break;

   492         case ESqlSrvDbBlobSource:

   493             aIpcCallName.Set(KSqlSrvDbBlobSource);

   494             break;

   495         case ESqlSrvDbLastInsertedRowId:

   496             aIpcCallName.Set(KSqlSrvDbLastInsertedRowId);

   497             break;

   498         case ESqlSrvDbCompact:

   499             aIpcCallName.Set(KSqlSrvDbCompact);

   500             break;

   501         case ESqlSrvDbReserveDriveSpace:

   502             aIpcCallName.Set(KSqlSrvDbReserveDriveSpace);

   503             break;

   504         case ESqlSrvDbFreeReservedSpace:

   505             aIpcCallName.Set(KSqlSrvDbFreeReservedSpace);

   506             break;

   507         case ESqlSrvDbGetReserveAccess:

   508             aIpcCallName.Set(KSqlSrvDbGetReserveAccess);

   509             break;

   510         case ESqlSrvDbReleaseReserveAccess:

   511             aIpcCallName.Set(KSqlSrvDbReleaseReserveAccess);

   512             break;

   513         case ESqlSrvStmtPrepare8:

   514             aIpcCallName.Set(KSqlSrvStmtPrepare8);

   515             break;

   516         case ESqlSrvStmtPrepare16:

   517             aIpcCallName.Set(KSqlSrvStmtPrepare16);

   518             break;

   519         case ESqlSrvStmtClose:

   520             aIpcCallName.Set(KSqlSrvStmtClose);

   521             break;

   522         case ESqlSrvStmtReset:

   523             aIpcCallName.Set(KSqlSrvStmtReset);

   524             break;

   525         case ESqlSrvStmtExec:

   526             aIpcCallName.Set(KSqlSrvStmtExec);

   527             rc = 4;

   528             break;

   529         case ESqlSrvStmtAsyncExec:

   530             aIpcCallName.Set(KSqlSrvStmtAsyncExec);

   531             rc = 5;

   532             break;

   533         case ESqlSrvStmtBindExec:

   534             aIpcCallName.Set(KSqlSrvStmtBindExec);

   535             rc = 6;

   536             break;

   537         case ESqlSrvStmtAsyncBindExec:

   538             aIpcCallName.Set(KSqlSrvStmtAsyncBindExec);

   539             rc = 7;

   540             break;

   541         case ESqlSrvStmtNext:

   542             aIpcCallName.Set(KSqlSrvStmtNext);

   543             rc = 8;

   544             break;

   545         case ESqlSrvStmtBindNext:

   546             aIpcCallName.Set(KSqlSrvStmtBindNext);

   547             rc = 9;

   548             break;

   549         case ESqlSrvStmtColumnNames:

   550             aIpcCallName.Set(KSqlSrvStmtColumnNames);

   551             break;

   552         case ESqlSrvStmtParamNames:

   553             aIpcCallName.Set(KSqlSrvStmtParamNames);

   554             break;

   555         case ESqlSrvStmtColumnSource:

   556             aIpcCallName.Set(KSqlSrvStmtColumnSource);

   557             break;

   558         case ESqlSrvStmtBinParamSink:

   559             aIpcCallName.Set(KSqlSrvStmtBinParamSink);

   560             break;

   561         case ESqlSrvStmtTxtParamSink16:

   562             aIpcCallName.Set(KSqlSrvStmtTxtParamSink16);

   563             break;

   564         case ESqlSrvStmtBufFlat:

   565             aIpcCallName.Set(KSqlSrvStmtBufFlat);

   566             break;

   567         case ESqlSrvStmtColumnValue:

   568             aIpcCallName.Set(KSqlSrvStmtColumnValue);

   569             break;

   570         case ESqlSrvStmtDeclColumnTypes:

   571             aIpcCallName.Set(KSqlSrvStmtDeclColumnTypes);

   572             break;

   573         case ESqlSrvStreamRead:

   574             aIpcCallName.Set(KSqlSrvStreamRead);

   575             break;

   576         case ESqlSrvStreamWrite:

   577             aIpcCallName.Set(KSqlSrvStreamWrite);

   578             break;

   579         case ESqlSrvStreamSize:

   580             aIpcCallName.Set(KSqlSrvStreamSize);

   581             break;

   582         case ESqlSrvStreamSynch:

   583             aIpcCallName.Set(KSqlSrvStreamSynch);

   584             break;

   585         case ESqlSrvStreamClose:

   586             aIpcCallName.Set(KSqlSrvStreamClose);

   587             break;

   588         default:

   589             return KErrNotSupported;

   590         };

   591     __ASSERT_DEBUG((TUint)rc < KIpcTraceTypeCount || rc == KErrNotFound, __SQLPANIC2(ESqlPanicInternalError));

   592     return rc;

   593     }

   594 

   595 //Calculates and returns the time difference between aStartTicks and aEndTicks in microseconds.  

   596 static TInt SqlConvertTicks2Us(TUint32 aStartTicks, TUint32 aEndTicks)

   597     {

   598     static TInt freq = 0;

   599     if(freq == 0)

   600         {

   601         TInt err = HAL::Get(HAL::EFastCounterFrequency, freq);

   602         if(err != KErrNone)

   603             {

   604             __SQLPANIC2((TSqlPanic)err);

   605             }

   606         }

   607     TInt64 diffTicks = (TInt64)aEndTicks - (TInt64)aStartTicks;

   608     if(diffTicks < 0)

   609         {

   610         diffTicks = KMaxTUint32 + diffTicks + 1;

   611         }

   612     const TInt KMicroSecIn1Sec = 1000000;

   613     TInt32 us = (diffTicks * KMicroSecIn1Sec) / freq;

   614     return us;

   615     }

   616 

   617 //Calculates the time since the first time this function has been called.

   618 static TInt64 SqlTimeFromStartUs()

   619     {

   620     struct TStartTime

   621         {

   622         inline TStartTime()

   623             {

   624             iTime.UniversalTime();

   625             }

   626         TTime iTime;

   627         };

   628     static TStartTime startTime;

   629     TTime time;

   630     time.UniversalTime();

   631     TTimeIntervalMicroSeconds us = time.MicroSecondsFrom(startTime.iTime);

   632     const TInt64 KMaxDiff = 999999999999LL;//999999999999 is the max number that can be printed out using %12ld format spec

   633     if(us.Int64() < 0 || us.Int64() >= KMaxDiff)

   634         {

   635         startTime.iTime = time;

   636         us = 0;

   637         }

   638     return us.Int64();

   639     }

   640 

   641 

   642 //Tracing data buffer

   643 const TInt KSqlSrvProfilePrnBufSize = 300;

   644 static TBuf<KSqlSrvProfilePrnBufSize> TheSqlSrvProfileTraceBuf;

   645 static TBuf8<KSqlSrvProfilePrnBufSize> TheSqlSrvProfileTraceBuf8;

   646 

   647 static RFs TheSqlSrvTraceFs;

   648 static RFile TheTheSqlSrvTraceFile;

   649 _LIT(KSqlSrvTraceFileName, "C:\\SQLTRACE");

   650 

   651 //Prints out a time stamp

   652 static void SqlSrvProfileTimePrintf()

   653     {

   654     static TInt64 prevTimeDiff = 0;;

   655     TInt64 timeDiff = SqlTimeFromStartUs();

   656     const TInt64 KTimeInterval = 1000000; 

   657     if((timeDiff - prevTimeDiff) >= KTimeInterval || timeDiff < prevTimeDiff)

   658         {

   659         prevTimeDiff = timeDiff;

   660         TTime time;

   661         time.UniversalTime();

   662         TDateTime dt = time.DateTime();

   663         TheSqlSrvProfileTraceBuf8.Format(_L8("[SQL]¬\"%X\"¬¬TME¬¬¬¬¬¬¬¬¬¬¬¬%02d:%02d:%02d:%06d¬Prep8¬%d¬Prep16¬%d¬Ex8¬%d¬Ex16¬%d"),

   664                 timeDiff, dt.Hour(), dt.Minute(), dt.Second(), dt.MicroSecond(),

   665                 TheSqlSrvProfilerPreparedCnt8, TheSqlSrvProfilerPreparedCnt16, 

   666                 TheSqlSrvProfilerExecutedCnt8, TheSqlSrvProfilerExecutedCnt16);

   667         if(TheSqlSrvProfilerTraceToFile)

   668             {

   669             TheSqlSrvProfileTraceBuf8.Append(_L8("\r\n"));

   670             (void)TheTheSqlSrvTraceFile.Write(TheSqlSrvProfileTraceBuf8);

   671             }

   672         else

   673             {

   674             TheSqlSrvProfileTraceBuf8.Append(_L8("\n"));

   675             RDebug::RawPrint(TheSqlSrvProfileTraceBuf8);

   676             }

   677         }

   678     }

   679 

   680 //Trace types

   681 enum TSqlSrvProfilerTraceType

   682     {

   683     ESqlSrvProfilerNonSqlTrace,

   684     ESqlSrvProfilerMiddleLineSqlTrace,

   685     ESqlSrvProfilerLastLineSqlTrace

   686     };

   687 

   688 //Prints out the data that is in TheSqlSrvProfileTraceBuf.

   689 // aType = ESqlSrvProfilerNonSqlTrace       - non-SQL trace

   690 // aType = ESqlSrvProfilerMiddleLineSqlTrace - not last line of an SQL trace

   691 // aType = ESqlSrvProfilerLastLineSqlTrace  - last line of an SQL trace

   692 static void SqlSrvProfilePrintf(TSqlSrvProfilerTraceType aType)

   693     {

   694     SqlSrvProfileTimePrintf();

   695     TheSqlSrvProfileTraceBuf8.Copy(TheSqlSrvProfileTraceBuf);

   696     if(TheSqlSrvProfilerTraceToFile)

   697         {

   698         if(aType == 0 || aType == 2)

   699             {

   700             TheSqlSrvProfileTraceBuf8.Append(_L8("\r\n"));

   701             }

   702         (void)TheTheSqlSrvTraceFile.Write(TheSqlSrvProfileTraceBuf8);

   703         }

   704     else

   705         {

   706         TheSqlSrvProfileTraceBuf8.Append(_L8("\n"));

   707         RDebug::RawPrint(TheSqlSrvProfileTraceBuf8);

   708         }

   709     }

   710 

   711 //Called at the beginning of CSqlSrvSession::ServiceL().

   712 void SqlIpcStart(TUint& aIpcCounter, TUint32& aStartTicks, TUint aDbHandle)

   713     {

   714     if(TheSqlSrvProfilerTraceEnabled)

   715         {

   716         TheSqlSrvProfilerFileRead = TheSqlSrvProfilerFileWrite = TheSqlSrvProfilerFileSync = TheSqlSrvProfilerFileSetSize = 0;

   717         if(TheSqlSrvProfilerTraceLevel == 0)

   718             {

   719             return;

   720             }

   721         if(KSqlSrvProfilerDbName().Length() > 0 && (aDbHandle == 0 || TheSqlSrvProfilerHandle != aDbHandle))

   722             {

   723             return;

   724             }

   725         ++aIpcCounter;

   726         aStartTicks = User::FastCounter();

   727         }

   728     }

   729 

   730 //Called at the end of CSqlSrvSession::ServiceL().

   731 void SqlIpcEnd(TUint aIpcCounter, TUint32 aStartTicks, TSqlSrvFunction aFuncCode, 

   732                TUint aDbHandle, TSqlSrvIpcTraceData aIpcTraceData[], TInt aRetCode)

   733     {

   734     if(TheSqlSrvProfilerTraceEnabled)

   735         {

   736         if(TheSqlSrvProfilerTraceLevel == 0)

   737             {

   738             return;

   739             }

   740         if(KSqlSrvProfilerDbName().Length() > 0 &&  (aDbHandle == 0 || TheSqlSrvProfilerHandle != aDbHandle))

   741             {

   742             return;

   743             }

   744         TUint32 endTicks = User::FastCounter();

   745         TInt executionTime = SqlConvertTicks2Us(aStartTicks, endTicks);

   746         TPtrC ipcCallName;

   747         TInt ipcCallIdx = SqlIpcTraceIdxAndName(aFuncCode, ipcCallName); 

   748         TInt64 timeFromStart = SqlTimeFromStartUs();

   749         TInt64 ttlExecTime = 0;

   750         TInt count = 0;

   751         if(ipcCallIdx >= 0)

   752             {

   753             aIpcTraceData[ipcCallIdx].iExecutionTime += executionTime;

   754             ttlExecTime = aIpcTraceData[ipcCallIdx].iExecutionTime;

   755             count = ++aIpcTraceData[ipcCallIdx].iCount;

   756             }

   757         if(ipcCallIdx >= 0  || (ipcCallIdx == KErrNotFound && TheSqlSrvProfilerTraceLevel == 2))

   758             {

   759             TheSqlSrvProfileTraceBuf.Format(_L("[SQL]¬\"%X\"¬%ld¬IPC¬%u¬%S¬%ld¬%d¬%d¬%d¬%d¬%d¬%d¬rc¬%d"),  

   760 														//[SQL]

   761                     aDbHandle,							//Database handle

   762                     timeFromStart,						//Time from start, microseconds

   763 														//IPC

   764                     aIpcCounter,						//IPC sequence counter for this database (connection)

   765                     &ipcCallName,						//IPC call name

   766                     ttlExecTime,						//All time spent in this IPC call type for this database (connection)

   767                     executionTime,						//This IPC call execution time

   768                     count,								//This IPC call sequence counter for this database (connection)

   769                     TheSqlSrvProfilerFileRead,			//File read count, performed during this IPC

   770                     TheSqlSrvProfilerFileWrite,			//File write count, performed during this IPC

   771                     TheSqlSrvProfilerFileSync,			//File flush count, performed during this IPC

   772                     TheSqlSrvProfilerFileSetSize,		//File set size count, performed during this IPC

   773                     aRetCode);							//IPC call - return code

   774             SqlSrvProfilePrintf(ESqlSrvProfilerNonSqlTrace);

   775             }

   776         }

   777     }

   778 

   779 //Called at the end of CSqlSrvSession::ServiceError().

   780 void SqlIpcError(TUint aIpcCounter, TSqlSrvFunction aFuncCode, TUint aDbHandle, TInt aError)

   781     {

   782     if(TheSqlSrvProfilerTraceEnabled)

   783         {

   784         if(KSqlSrvProfilerDbName().Length() > 0 &&  (aDbHandle == 0 || TheSqlSrvProfilerHandle != aDbHandle))

   785             {

   786             return;

   787             }

   788         TPtrC ipcCallName;

   789         (void)SqlIpcTraceIdxAndName(aFuncCode, ipcCallName); 

   790         TInt64 timeFromStart = SqlTimeFromStartUs();

   791         TheSqlSrvProfileTraceBuf.Format(_L("[SQL]¬\"%X\"¬%ld¬ERR¬%u¬%S¬¬¬¬¬¬¬¬err¬%d"), 

   792 									//[SQL]

   793                 aDbHandle,			//Database (connection) handle

   794                 timeFromStart,		//Time from start, microseconds

   795 									//ERR

   796                 aIpcCounter,		//IPC sequence counter for this database (connection)

   797                 &ipcCallName,		//IPC call name

   798                 aError);			//IPC call - return code

   799         SqlSrvProfilePrintf(ESqlSrvProfilerNonSqlTrace);

   800         }

   801     }

   802 

   803 //Prints the passed as a parameter 16-bit SQL statement.

   804 void SqlPrintSql16(TUint aDbHandle, const TDesC& aSql, TBool aPrepare)

   805     {

   806     if(!TheSqlSrvProfilerTraceEnabled || !TheSqlSrvProfilerSqlTraceEnabled)

   807         {

   808         return;

   809         }

   810     if(KSqlSrvProfilerDbName().Length() > 0 &&  (aDbHandle == 0 || TheSqlSrvProfilerHandle != aDbHandle))

   811         {

   812         return;

   813         }

   814     

   815     aPrepare ? ++TheSqlSrvProfilerPreparedCnt16 : ++TheSqlSrvProfilerExecutedCnt16;

   816     

   817     TInt64 timeFromStart = SqlTimeFromStartUs();

   818     TPtr line((TUint16*)TheSqlTraceBuf.Ptr(), 0, TheSqlTraceBuf.MaxLength());

   819     TInt len = aSql.Length();

   820     TInt pos = 0;

   821     do

   822         {

   823         _LIT(KPrepare,  "Prepare16");

   824         _LIT(KExec,     "Exec16");

   825         _LIT(KEmptyStr,  "");

   826         if(pos == 0)

   827             {

   828             line.Format(_L("[SQL]¬\"%X\"¬%ld¬SQL¬¬%S¬¬¬¬¬¬¬¬¬¬"), aDbHandle, timeFromStart, aPrepare ? &KPrepare : &KExec);

   829             }

   830         else

   831             {

   832             if(!TheSqlSrvProfilerTraceToFile)

   833                 {

   834                 line.Format(_L("[SQL]¬\"%X\"¬%ld¬SQL¬¬%S¬¬¬¬¬¬¬¬¬¬"), aDbHandle, timeFromStart, &KEmptyStr);

   835                 }

   836             }

   837         TInt l = Min(len, (line.MaxLength() - line.Length()));

   838         TPtrC ptr(aSql.Ptr() + pos, l);

   839         pos += l;

   840         len -= l;

   841         line.Append(ptr);

   842         TheSqlSrvProfileTraceBuf.Format(_L("%S"), &line); 

   843         SqlSrvProfilePrintf(len > 0 ? ESqlSrvProfilerMiddleLineSqlTrace : ESqlSrvProfilerLastLineSqlTrace);

   844         line.Zero();

   845         } while(len > 0);

   846     }

   847  

   848 //Prints the passed as a parameter 8-bit SQL statement.

   849 void SqlPrintSql8(TUint aDbHandle, const TDesC8& aSql, TBool aPrepare)

   850     {

   851     if(!TheSqlSrvProfilerTraceEnabled || !TheSqlSrvProfilerSqlTraceEnabled)

   852         {

   853         return;

   854         }

   855     if(KSqlSrvProfilerDbName().Length() > 0 &&  (aDbHandle == 0 || TheSqlSrvProfilerHandle != aDbHandle))

   856         {

   857         return;

   858         }

   859     

   860     aPrepare ? ++TheSqlSrvProfilerPreparedCnt8 : ++TheSqlSrvProfilerExecutedCnt8;

   861     

   862     TInt64 timeFromStart = SqlTimeFromStartUs();

   863     TPtr line((TUint16*)TheSqlTraceBuf.Ptr(), 0, TheSqlTraceBuf.MaxLength());

   864     TInt len = aSql.Length();

   865     TInt pos = 0;

   866     do

   867         {

   868         _LIT(KPrepare,   "Prepare8");

   869         _LIT(KExec,      "Exec8");

   870         _LIT(KEmptyStr,  "");

   871         if(pos == 0)

   872             {

   873             line.Format(_L("[SQL]¬\"%X\"¬%ld¬SQL¬¬%S¬¬¬¬¬¬¬¬¬¬"), aDbHandle, timeFromStart, aPrepare ? &KPrepare : &KExec);

   874             }

   875         else

   876             {

   877             if(!TheSqlSrvProfilerTraceToFile)

   878                 {

   879                 line.Format(_L("[SQL]¬\"%X\"¬%ld¬SQL¬¬%S¬¬¬¬¬¬¬¬¬¬"), aDbHandle, timeFromStart, &KEmptyStr);

   880                 }

   881             }

   882         TInt l = Min(len, (line.MaxLength() - line.Length()));

   883         TPtrC8 ptr(aSql.Ptr() + pos, l);

   884         pos += l;

   885         len -= l;

   886         TPtr p2((TUint16*)line.Ptr() + line.Length(), 0, l);  

   887         p2.Copy(ptr);

   888         line.SetLength(line.Length() + p2.Length());

   889         TheSqlSrvProfileTraceBuf.Format(_L("%S"), &line); 

   890         SqlSrvProfilePrintf(len > 0 ? ESqlSrvProfilerMiddleLineSqlTrace : ESqlSrvProfilerLastLineSqlTrace);

   891         line.Zero();

   892         } while(len > 0);

   893     }

   894 

   895 //Prints the name of the just created database.

   896 void SqlPrintDbCreate(TUint aDbHandle, const TDesC& aDbName)

   897     {

   898     if(TheSqlSrvProfilerTraceEnabled)

   899         {

   900         if(KSqlSrvProfilerDbName().Length() > 0 && aDbName.FindF(KSqlSrvProfilerDbName) >= 0)

   901             {

   902             TheSqlSrvProfilerHandle = aDbHandle;

   903             }

   904         if(KSqlSrvProfilerDbName().Length() > 0 &&  (aDbHandle == 0 || TheSqlSrvProfilerHandle != aDbHandle))

   905             {

   906             return;

   907             }

   908         TInt64 timeFromStart = SqlTimeFromStartUs();

   909         TheSqlSrvProfileTraceBuf.Format(_L("[SQL]¬\"%X\"¬%ld¬CRE¬¬¬¬¬¬¬¬¬¬¬¬%S"), 

   910                 aDbHandle, 

   911                 timeFromStart,

   912                 &aDbName);

   913         SqlSrvProfilePrintf(ESqlSrvProfilerNonSqlTrace);

   914         }

   915     }

   916 

   917 //Prints the name of the just opened database.

   918 void SqlPrintDbOpen(TUint aDbHandle, const TDesC& aDbName)

   919     {

   920     if(TheSqlSrvProfilerTraceEnabled)

   921         {

   922         if(KSqlSrvProfilerDbName().Length() > 0 && aDbName.FindF(KSqlSrvProfilerDbName) >= 0)

   923             {

   924             TheSqlSrvProfilerHandle = aDbHandle;

   925             }

   926         if(KSqlSrvProfilerDbName().Length() > 0 &&  (aDbHandle == 0 || TheSqlSrvProfilerHandle != aDbHandle))

   927             {

   928             return;

   929             }

   930         TInt64 timeFromStart = SqlTimeFromStartUs();

   931         TheSqlSrvProfileTraceBuf.Format(_L("[SQL]¬\"%X\"¬%ld¬OPN¬¬¬¬¬¬¬¬¬¬¬¬%S"), 

   932                 aDbHandle, 

   933                 timeFromStart,

   934                 &aDbName);

   935         SqlSrvProfilePrintf(ESqlSrvProfilerNonSqlTrace);

   936         }

   937     }

   938 

   939 //Prints the handle of the just closed database.

   940 void SqlPrintDbClose(TUint aDbHandle)

   941     {

   942     if(TheSqlSrvProfilerTraceEnabled)

   943         {

   944         if(KSqlSrvProfilerDbName().Length() > 0 &&  (aDbHandle == 0 || TheSqlSrvProfilerHandle != aDbHandle))

   945             {

   946             return;

   947             }

   948         TInt64 timeFromStart = SqlTimeFromStartUs();

   949         TheSqlSrvProfileTraceBuf.Format(_L("[SQL]¬\"%X\"¬%ld¬CSE"),  

   950                 aDbHandle, 

   951                 timeFromStart);

   952         SqlSrvProfilePrintf(ESqlSrvProfilerNonSqlTrace);

   953         if(aDbHandle == TheSqlSrvProfilerHandle)

   954             {

   955             TheSqlSrvProfilerHandle = 0;

   956             }

   957         }

   958     }

   959 

   960 //Prints a trace when the SQL server starts

   961 void SqlPrintServerStart()

   962     {

   963     TInt64 timeFromStart = SqlTimeFromStartUs();

   964     if(TheSqlSrvProfilerTraceToFile)

   965         {

   966         TInt err = TheSqlSrvTraceFs.Connect();

   967         if(err == KErrNone)

   968             {

   969             TInt fileNum = 0;

   970             err = KErrGeneral;

   971             while(++fileNum < 1000 && err != KErrNone)

   972                 {

   973                 TBuf<80> ftrname;

   974                 ftrname.Copy(KSqlSrvTraceFileName);

   975                 ftrname.AppendNum(fileNum);

   976                 ftrname.Append(_L(".txt"));

   977                 err = TheTheSqlSrvTraceFile.Create(TheSqlSrvTraceFs, ftrname, EFileRead | EFileWrite);

   978                 if(err == KErrNone)

   979                     {

   980                     break;

   981                     }

   982                 }

   983             }

   984         if(err != KErrNone)

   985             {

   986             TheSqlSrvTraceFs.Close();

   987             TheSqlSrvProfilerTraceToFile = EFalse;

   988             RDebug::Print(_L("SQL trace file creation failed with err=%d"), err);

   989             }

   990         }

   991     TheSqlSrvProfileTraceBuf.Format(_L("[SQL]¬¬%ld¬SRV¬¬Start"), timeFromStart); 

   992     SqlSrvProfilePrintf(ESqlSrvProfilerNonSqlTrace);

   993     }

   994 

   995 //Prints a trace when the SQL server stops

   996 void SqlPrintServerStop()

   997     {

   998     TInt64 timeFromStart = SqlTimeFromStartUs();

   999     TheSqlSrvProfileTraceBuf.Format(_L("[SQL]¬¬%ld¬SRV¬¬Stop"), timeFromStart); 

  1000     SqlSrvProfilePrintf(ESqlSrvProfilerNonSqlTrace);

  1001     if(TheSqlSrvProfilerTraceToFile)

  1002         {

  1003         TheTheSqlSrvTraceFile.Close();

  1004         TheSqlSrvTraceFs.Close();

  1005         }

  1006     }

  1007 

  1008 #else //_SQLPROFILER

  1009 

  1010 void TSqlSrvResourceProfiler::StartL(const RMessage2&)

  1011 	{

  1012 	__SQLLEAVE2(KErrNotSupported);

  1013 	}

  1014 	

  1015 void TSqlSrvResourceProfiler::StopL(const RMessage2&)

  1016 	{

  1017 	__SQLLEAVE2(KErrNotSupported);

  1018 	}

  1019 	

  1020 void TSqlSrvResourceProfiler::ResetL(const RMessage2&)

  1021 	{

  1022 	__SQLLEAVE2(KErrNotSupported);

  1023 	}

  1024 	

  1025 void TSqlSrvResourceProfiler::QueryL(const RMessage2&)

  1026 	{

  1027 	__SQLLEAVE2(KErrNotSupported);

  1028 	}

  1029 	

  1030 #endif//_SQLPROFILER
Symaptic