Annotation of embedaddon/sqlite3/src/test_osinst.c, revision 1.1
1.1 ! misho 1: /*
! 2: ** 2008 April 10
! 3: **
! 4: ** The author disclaims copyright to this source code. In place of
! 5: ** a legal notice, here is a blessing:
! 6: **
! 7: ** May you do good and not evil.
! 8: ** May you find forgiveness for yourself and forgive others.
! 9: ** May you share freely, never taking more than you give.
! 10: **
! 11: ******************************************************************************
! 12: **
! 13: ** This file contains the implementation of an SQLite vfs wrapper that
! 14: ** adds instrumentation to all vfs and file methods. C and Tcl interfaces
! 15: ** are provided to control the instrumentation.
! 16: */
! 17:
! 18: /*
! 19: ** This module contains code for a wrapper VFS that causes a log of
! 20: ** most VFS calls to be written into a nominated file on disk. The log
! 21: ** is stored in a compressed binary format to reduce the amount of IO
! 22: ** overhead introduced into the application by logging.
! 23: **
! 24: ** All calls on sqlite3_file objects except xFileControl() are logged.
! 25: ** Additionally, calls to the xAccess(), xOpen(), and xDelete()
! 26: ** methods are logged. The other sqlite3_vfs object methods (xDlXXX,
! 27: ** xRandomness, xSleep, xCurrentTime, xGetLastError and xCurrentTimeInt64)
! 28: ** are not logged.
! 29: **
! 30: ** The binary log files are read using a virtual table implementation
! 31: ** also contained in this file.
! 32: **
! 33: ** CREATING LOG FILES:
! 34: **
! 35: ** int sqlite3_vfslog_new(
! 36: ** const char *zVfs, // Name of new VFS
! 37: ** const char *zParentVfs, // Name of parent VFS (or NULL)
! 38: ** const char *zLog // Name of log file to write to
! 39: ** );
! 40: **
! 41: ** int sqlite3_vfslog_finalize(const char *zVfs);
! 42: **
! 43: ** ANNOTATING LOG FILES:
! 44: **
! 45: ** To write an arbitrary message into a log file:
! 46: **
! 47: ** int sqlite3_vfslog_annotate(const char *zVfs, const char *zMsg);
! 48: **
! 49: ** READING LOG FILES:
! 50: **
! 51: ** Log files are read using the "vfslog" virtual table implementation
! 52: ** in this file. To register the virtual table with SQLite, use:
! 53: **
! 54: ** int sqlite3_vfslog_register(sqlite3 *db);
! 55: **
! 56: ** Then, if the log file is named "vfs.log", the following SQL command:
! 57: **
! 58: ** CREATE VIRTUAL TABLE v USING vfslog('vfs.log');
! 59: **
! 60: ** creates a virtual table with 6 columns, as follows:
! 61: **
! 62: ** CREATE TABLE v(
! 63: ** event TEXT, // "xOpen", "xRead" etc.
! 64: ** file TEXT, // Name of file this call applies to
! 65: ** clicks INTEGER, // Time spent in call
! 66: ** rc INTEGER, // Return value
! 67: ** size INTEGER, // Bytes read or written
! 68: ** offset INTEGER // File offset read or written
! 69: ** );
! 70: */
! 71:
! 72: #include "sqlite3.h"
! 73: #include <string.h>
! 74: #include <assert.h>
! 75:
! 76:
! 77: /*
! 78: ** Maximum pathname length supported by the vfslog backend.
! 79: */
! 80: #define INST_MAX_PATHNAME 512
! 81:
! 82: #define OS_ACCESS 1
! 83: #define OS_CHECKRESERVEDLOCK 2
! 84: #define OS_CLOSE 3
! 85: #define OS_CURRENTTIME 4
! 86: #define OS_DELETE 5
! 87: #define OS_DEVCHAR 6
! 88: #define OS_FILECONTROL 7
! 89: #define OS_FILESIZE 8
! 90: #define OS_FULLPATHNAME 9
! 91: #define OS_LOCK 11
! 92: #define OS_OPEN 12
! 93: #define OS_RANDOMNESS 13
! 94: #define OS_READ 14
! 95: #define OS_SECTORSIZE 15
! 96: #define OS_SLEEP 16
! 97: #define OS_SYNC 17
! 98: #define OS_TRUNCATE 18
! 99: #define OS_UNLOCK 19
! 100: #define OS_WRITE 20
! 101: #define OS_SHMUNMAP 22
! 102: #define OS_SHMMAP 23
! 103: #define OS_SHMLOCK 25
! 104: #define OS_SHMBARRIER 26
! 105: #define OS_ANNOTATE 28
! 106:
! 107: #define OS_NUMEVENTS 29
! 108:
! 109: #define VFSLOG_BUFFERSIZE 8192
! 110:
! 111: typedef struct VfslogVfs VfslogVfs;
! 112: typedef struct VfslogFile VfslogFile;
! 113:
! 114: struct VfslogVfs {
! 115: sqlite3_vfs base; /* VFS methods */
! 116: sqlite3_vfs *pVfs; /* Parent VFS */
! 117: int iNextFileId; /* Next file id */
! 118: sqlite3_file *pLog; /* Log file handle */
! 119: sqlite3_int64 iOffset; /* Log file offset of start of write buffer */
! 120: int nBuf; /* Number of valid bytes in aBuf[] */
! 121: char aBuf[VFSLOG_BUFFERSIZE]; /* Write buffer */
! 122: };
! 123:
! 124: struct VfslogFile {
! 125: sqlite3_file base; /* IO methods */
! 126: sqlite3_file *pReal; /* Underlying file handle */
! 127: sqlite3_vfs *pVfslog; /* Associated VsflogVfs object */
! 128: int iFileId; /* File id number */
! 129: };
! 130:
! 131: #define REALVFS(p) (((VfslogVfs *)(p))->pVfs)
! 132:
! 133:
! 134:
! 135: /*
! 136: ** Method declarations for vfslog_file.
! 137: */
! 138: static int vfslogClose(sqlite3_file*);
! 139: static int vfslogRead(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst);
! 140: static int vfslogWrite(sqlite3_file*,const void*,int iAmt, sqlite3_int64 iOfst);
! 141: static int vfslogTruncate(sqlite3_file*, sqlite3_int64 size);
! 142: static int vfslogSync(sqlite3_file*, int flags);
! 143: static int vfslogFileSize(sqlite3_file*, sqlite3_int64 *pSize);
! 144: static int vfslogLock(sqlite3_file*, int);
! 145: static int vfslogUnlock(sqlite3_file*, int);
! 146: static int vfslogCheckReservedLock(sqlite3_file*, int *pResOut);
! 147: static int vfslogFileControl(sqlite3_file*, int op, void *pArg);
! 148: static int vfslogSectorSize(sqlite3_file*);
! 149: static int vfslogDeviceCharacteristics(sqlite3_file*);
! 150:
! 151: static int vfslogShmLock(sqlite3_file *pFile, int ofst, int n, int flags);
! 152: static int vfslogShmMap(sqlite3_file *pFile,int,int,int,volatile void **);
! 153: static void vfslogShmBarrier(sqlite3_file*);
! 154: static int vfslogShmUnmap(sqlite3_file *pFile, int deleteFlag);
! 155:
! 156: /*
! 157: ** Method declarations for vfslog_vfs.
! 158: */
! 159: static int vfslogOpen(sqlite3_vfs*, const char *, sqlite3_file*, int , int *);
! 160: static int vfslogDelete(sqlite3_vfs*, const char *zName, int syncDir);
! 161: static int vfslogAccess(sqlite3_vfs*, const char *zName, int flags, int *);
! 162: static int vfslogFullPathname(sqlite3_vfs*, const char *zName, int, char *zOut);
! 163: static void *vfslogDlOpen(sqlite3_vfs*, const char *zFilename);
! 164: static void vfslogDlError(sqlite3_vfs*, int nByte, char *zErrMsg);
! 165: static void (*vfslogDlSym(sqlite3_vfs *pVfs, void *p, const char*zSym))(void);
! 166: static void vfslogDlClose(sqlite3_vfs*, void*);
! 167: static int vfslogRandomness(sqlite3_vfs*, int nByte, char *zOut);
! 168: static int vfslogSleep(sqlite3_vfs*, int microseconds);
! 169: static int vfslogCurrentTime(sqlite3_vfs*, double*);
! 170:
! 171: static int vfslogGetLastError(sqlite3_vfs*, int, char *);
! 172: static int vfslogCurrentTimeInt64(sqlite3_vfs*, sqlite3_int64*);
! 173:
! 174: static sqlite3_vfs vfslog_vfs = {
! 175: 1, /* iVersion */
! 176: sizeof(VfslogFile), /* szOsFile */
! 177: INST_MAX_PATHNAME, /* mxPathname */
! 178: 0, /* pNext */
! 179: 0, /* zName */
! 180: 0, /* pAppData */
! 181: vfslogOpen, /* xOpen */
! 182: vfslogDelete, /* xDelete */
! 183: vfslogAccess, /* xAccess */
! 184: vfslogFullPathname, /* xFullPathname */
! 185: vfslogDlOpen, /* xDlOpen */
! 186: vfslogDlError, /* xDlError */
! 187: vfslogDlSym, /* xDlSym */
! 188: vfslogDlClose, /* xDlClose */
! 189: vfslogRandomness, /* xRandomness */
! 190: vfslogSleep, /* xSleep */
! 191: vfslogCurrentTime, /* xCurrentTime */
! 192: vfslogGetLastError, /* xGetLastError */
! 193: vfslogCurrentTimeInt64 /* xCurrentTime */
! 194: };
! 195:
! 196: static sqlite3_io_methods vfslog_io_methods = {
! 197: 2, /* iVersion */
! 198: vfslogClose, /* xClose */
! 199: vfslogRead, /* xRead */
! 200: vfslogWrite, /* xWrite */
! 201: vfslogTruncate, /* xTruncate */
! 202: vfslogSync, /* xSync */
! 203: vfslogFileSize, /* xFileSize */
! 204: vfslogLock, /* xLock */
! 205: vfslogUnlock, /* xUnlock */
! 206: vfslogCheckReservedLock, /* xCheckReservedLock */
! 207: vfslogFileControl, /* xFileControl */
! 208: vfslogSectorSize, /* xSectorSize */
! 209: vfslogDeviceCharacteristics, /* xDeviceCharacteristics */
! 210: vfslogShmMap, /* xShmMap */
! 211: vfslogShmLock, /* xShmLock */
! 212: vfslogShmBarrier, /* xShmBarrier */
! 213: vfslogShmUnmap /* xShmUnmap */
! 214: };
! 215:
! 216: #if SQLITE_OS_UNIX && !defined(NO_GETTOD)
! 217: #include <sys/time.h>
! 218: static sqlite3_uint64 vfslog_time(){
! 219: struct timeval sTime;
! 220: gettimeofday(&sTime, 0);
! 221: return sTime.tv_usec + (sqlite3_uint64)sTime.tv_sec * 1000000;
! 222: }
! 223: #elif SQLITE_OS_WIN
! 224: #include <windows.h>
! 225: #include <time.h>
! 226: static sqlite3_uint64 vfslog_time(){
! 227: FILETIME ft;
! 228: sqlite3_uint64 u64time = 0;
! 229:
! 230: GetSystemTimeAsFileTime(&ft);
! 231:
! 232: u64time |= ft.dwHighDateTime;
! 233: u64time <<= 32;
! 234: u64time |= ft.dwLowDateTime;
! 235:
! 236: /* ft is 100-nanosecond intervals, we want microseconds */
! 237: return u64time /(sqlite3_uint64)10;
! 238: }
! 239: #else
! 240: static sqlite3_uint64 vfslog_time(){
! 241: return 0;
! 242: }
! 243: #endif
! 244:
! 245: static void vfslog_call(sqlite3_vfs *, int, int, int, int, int, int);
! 246: static void vfslog_string(sqlite3_vfs *, const char *);
! 247:
! 248: /*
! 249: ** Close an vfslog-file.
! 250: */
! 251: static int vfslogClose(sqlite3_file *pFile){
! 252: sqlite3_uint64 t;
! 253: int rc = SQLITE_OK;
! 254: VfslogFile *p = (VfslogFile *)pFile;
! 255:
! 256: t = vfslog_time();
! 257: if( p->pReal->pMethods ){
! 258: rc = p->pReal->pMethods->xClose(p->pReal);
! 259: }
! 260: t = vfslog_time() - t;
! 261: vfslog_call(p->pVfslog, OS_CLOSE, p->iFileId, t, rc, 0, 0);
! 262: return rc;
! 263: }
! 264:
! 265: /*
! 266: ** Read data from an vfslog-file.
! 267: */
! 268: static int vfslogRead(
! 269: sqlite3_file *pFile,
! 270: void *zBuf,
! 271: int iAmt,
! 272: sqlite_int64 iOfst
! 273: ){
! 274: int rc;
! 275: sqlite3_uint64 t;
! 276: VfslogFile *p = (VfslogFile *)pFile;
! 277: t = vfslog_time();
! 278: rc = p->pReal->pMethods->xRead(p->pReal, zBuf, iAmt, iOfst);
! 279: t = vfslog_time() - t;
! 280: vfslog_call(p->pVfslog, OS_READ, p->iFileId, t, rc, iAmt, (int)iOfst);
! 281: return rc;
! 282: }
! 283:
! 284: /*
! 285: ** Write data to an vfslog-file.
! 286: */
! 287: static int vfslogWrite(
! 288: sqlite3_file *pFile,
! 289: const void *z,
! 290: int iAmt,
! 291: sqlite_int64 iOfst
! 292: ){
! 293: int rc;
! 294: sqlite3_uint64 t;
! 295: VfslogFile *p = (VfslogFile *)pFile;
! 296: t = vfslog_time();
! 297: rc = p->pReal->pMethods->xWrite(p->pReal, z, iAmt, iOfst);
! 298: t = vfslog_time() - t;
! 299: vfslog_call(p->pVfslog, OS_WRITE, p->iFileId, t, rc, iAmt, (int)iOfst);
! 300: return rc;
! 301: }
! 302:
! 303: /*
! 304: ** Truncate an vfslog-file.
! 305: */
! 306: static int vfslogTruncate(sqlite3_file *pFile, sqlite_int64 size){
! 307: int rc;
! 308: sqlite3_uint64 t;
! 309: VfslogFile *p = (VfslogFile *)pFile;
! 310: t = vfslog_time();
! 311: rc = p->pReal->pMethods->xTruncate(p->pReal, size);
! 312: t = vfslog_time() - t;
! 313: vfslog_call(p->pVfslog, OS_TRUNCATE, p->iFileId, t, rc, 0, (int)size);
! 314: return rc;
! 315: }
! 316:
! 317: /*
! 318: ** Sync an vfslog-file.
! 319: */
! 320: static int vfslogSync(sqlite3_file *pFile, int flags){
! 321: int rc;
! 322: sqlite3_uint64 t;
! 323: VfslogFile *p = (VfslogFile *)pFile;
! 324: t = vfslog_time();
! 325: rc = p->pReal->pMethods->xSync(p->pReal, flags);
! 326: t = vfslog_time() - t;
! 327: vfslog_call(p->pVfslog, OS_SYNC, p->iFileId, t, rc, flags, 0);
! 328: return rc;
! 329: }
! 330:
! 331: /*
! 332: ** Return the current file-size of an vfslog-file.
! 333: */
! 334: static int vfslogFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){
! 335: int rc;
! 336: sqlite3_uint64 t;
! 337: VfslogFile *p = (VfslogFile *)pFile;
! 338: t = vfslog_time();
! 339: rc = p->pReal->pMethods->xFileSize(p->pReal, pSize);
! 340: t = vfslog_time() - t;
! 341: vfslog_call(p->pVfslog, OS_FILESIZE, p->iFileId, t, rc, 0, (int)*pSize);
! 342: return rc;
! 343: }
! 344:
! 345: /*
! 346: ** Lock an vfslog-file.
! 347: */
! 348: static int vfslogLock(sqlite3_file *pFile, int eLock){
! 349: int rc;
! 350: sqlite3_uint64 t;
! 351: VfslogFile *p = (VfslogFile *)pFile;
! 352: t = vfslog_time();
! 353: rc = p->pReal->pMethods->xLock(p->pReal, eLock);
! 354: t = vfslog_time() - t;
! 355: vfslog_call(p->pVfslog, OS_LOCK, p->iFileId, t, rc, eLock, 0);
! 356: return rc;
! 357: }
! 358:
! 359: /*
! 360: ** Unlock an vfslog-file.
! 361: */
! 362: static int vfslogUnlock(sqlite3_file *pFile, int eLock){
! 363: int rc;
! 364: sqlite3_uint64 t;
! 365: VfslogFile *p = (VfslogFile *)pFile;
! 366: t = vfslog_time();
! 367: rc = p->pReal->pMethods->xUnlock(p->pReal, eLock);
! 368: t = vfslog_time() - t;
! 369: vfslog_call(p->pVfslog, OS_UNLOCK, p->iFileId, t, rc, eLock, 0);
! 370: return rc;
! 371: }
! 372:
! 373: /*
! 374: ** Check if another file-handle holds a RESERVED lock on an vfslog-file.
! 375: */
! 376: static int vfslogCheckReservedLock(sqlite3_file *pFile, int *pResOut){
! 377: int rc;
! 378: sqlite3_uint64 t;
! 379: VfslogFile *p = (VfslogFile *)pFile;
! 380: t = vfslog_time();
! 381: rc = p->pReal->pMethods->xCheckReservedLock(p->pReal, pResOut);
! 382: t = vfslog_time() - t;
! 383: vfslog_call(p->pVfslog, OS_CHECKRESERVEDLOCK, p->iFileId, t, rc, *pResOut, 0);
! 384: return rc;
! 385: }
! 386:
! 387: /*
! 388: ** File control method. For custom operations on an vfslog-file.
! 389: */
! 390: static int vfslogFileControl(sqlite3_file *pFile, int op, void *pArg){
! 391: VfslogFile *p = (VfslogFile *)pFile;
! 392: int rc = p->pReal->pMethods->xFileControl(p->pReal, op, pArg);
! 393: if( op==SQLITE_FCNTL_VFSNAME && rc==SQLITE_OK ){
! 394: *(char**)pArg = sqlite3_mprintf("vfslog/%z", *(char**)pArg);
! 395: }
! 396: return rc;
! 397: }
! 398:
! 399: /*
! 400: ** Return the sector-size in bytes for an vfslog-file.
! 401: */
! 402: static int vfslogSectorSize(sqlite3_file *pFile){
! 403: int rc;
! 404: sqlite3_uint64 t;
! 405: VfslogFile *p = (VfslogFile *)pFile;
! 406: t = vfslog_time();
! 407: rc = p->pReal->pMethods->xSectorSize(p->pReal);
! 408: t = vfslog_time() - t;
! 409: vfslog_call(p->pVfslog, OS_SECTORSIZE, p->iFileId, t, rc, 0, 0);
! 410: return rc;
! 411: }
! 412:
! 413: /*
! 414: ** Return the device characteristic flags supported by an vfslog-file.
! 415: */
! 416: static int vfslogDeviceCharacteristics(sqlite3_file *pFile){
! 417: int rc;
! 418: sqlite3_uint64 t;
! 419: VfslogFile *p = (VfslogFile *)pFile;
! 420: t = vfslog_time();
! 421: rc = p->pReal->pMethods->xDeviceCharacteristics(p->pReal);
! 422: t = vfslog_time() - t;
! 423: vfslog_call(p->pVfslog, OS_DEVCHAR, p->iFileId, t, rc, 0, 0);
! 424: return rc;
! 425: }
! 426:
! 427: static int vfslogShmLock(sqlite3_file *pFile, int ofst, int n, int flags){
! 428: int rc;
! 429: sqlite3_uint64 t;
! 430: VfslogFile *p = (VfslogFile *)pFile;
! 431: t = vfslog_time();
! 432: rc = p->pReal->pMethods->xShmLock(p->pReal, ofst, n, flags);
! 433: t = vfslog_time() - t;
! 434: vfslog_call(p->pVfslog, OS_SHMLOCK, p->iFileId, t, rc, 0, 0);
! 435: return rc;
! 436: }
! 437: static int vfslogShmMap(
! 438: sqlite3_file *pFile,
! 439: int iRegion,
! 440: int szRegion,
! 441: int isWrite,
! 442: volatile void **pp
! 443: ){
! 444: int rc;
! 445: sqlite3_uint64 t;
! 446: VfslogFile *p = (VfslogFile *)pFile;
! 447: t = vfslog_time();
! 448: rc = p->pReal->pMethods->xShmMap(p->pReal, iRegion, szRegion, isWrite, pp);
! 449: t = vfslog_time() - t;
! 450: vfslog_call(p->pVfslog, OS_SHMMAP, p->iFileId, t, rc, 0, 0);
! 451: return rc;
! 452: }
! 453: static void vfslogShmBarrier(sqlite3_file *pFile){
! 454: sqlite3_uint64 t;
! 455: VfslogFile *p = (VfslogFile *)pFile;
! 456: t = vfslog_time();
! 457: p->pReal->pMethods->xShmBarrier(p->pReal);
! 458: t = vfslog_time() - t;
! 459: vfslog_call(p->pVfslog, OS_SHMBARRIER, p->iFileId, t, SQLITE_OK, 0, 0);
! 460: }
! 461: static int vfslogShmUnmap(sqlite3_file *pFile, int deleteFlag){
! 462: int rc;
! 463: sqlite3_uint64 t;
! 464: VfslogFile *p = (VfslogFile *)pFile;
! 465: t = vfslog_time();
! 466: rc = p->pReal->pMethods->xShmUnmap(p->pReal, deleteFlag);
! 467: t = vfslog_time() - t;
! 468: vfslog_call(p->pVfslog, OS_SHMUNMAP, p->iFileId, t, rc, 0, 0);
! 469: return rc;
! 470: }
! 471:
! 472:
! 473: /*
! 474: ** Open an vfslog file handle.
! 475: */
! 476: static int vfslogOpen(
! 477: sqlite3_vfs *pVfs,
! 478: const char *zName,
! 479: sqlite3_file *pFile,
! 480: int flags,
! 481: int *pOutFlags
! 482: ){
! 483: int rc;
! 484: sqlite3_uint64 t;
! 485: VfslogFile *p = (VfslogFile *)pFile;
! 486: VfslogVfs *pLog = (VfslogVfs *)pVfs;
! 487:
! 488: pFile->pMethods = &vfslog_io_methods;
! 489: p->pReal = (sqlite3_file *)&p[1];
! 490: p->pVfslog = pVfs;
! 491: p->iFileId = ++pLog->iNextFileId;
! 492:
! 493: t = vfslog_time();
! 494: rc = REALVFS(pVfs)->xOpen(REALVFS(pVfs), zName, p->pReal, flags, pOutFlags);
! 495: t = vfslog_time() - t;
! 496:
! 497: vfslog_call(pVfs, OS_OPEN, p->iFileId, t, rc, 0, 0);
! 498: vfslog_string(pVfs, zName);
! 499: return rc;
! 500: }
! 501:
! 502: /*
! 503: ** Delete the file located at zPath. If the dirSync argument is true,
! 504: ** ensure the file-system modifications are synced to disk before
! 505: ** returning.
! 506: */
! 507: static int vfslogDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){
! 508: int rc;
! 509: sqlite3_uint64 t;
! 510: t = vfslog_time();
! 511: rc = REALVFS(pVfs)->xDelete(REALVFS(pVfs), zPath, dirSync);
! 512: t = vfslog_time() - t;
! 513: vfslog_call(pVfs, OS_DELETE, 0, t, rc, dirSync, 0);
! 514: vfslog_string(pVfs, zPath);
! 515: return rc;
! 516: }
! 517:
! 518: /*
! 519: ** Test for access permissions. Return true if the requested permission
! 520: ** is available, or false otherwise.
! 521: */
! 522: static int vfslogAccess(
! 523: sqlite3_vfs *pVfs,
! 524: const char *zPath,
! 525: int flags,
! 526: int *pResOut
! 527: ){
! 528: int rc;
! 529: sqlite3_uint64 t;
! 530: t = vfslog_time();
! 531: rc = REALVFS(pVfs)->xAccess(REALVFS(pVfs), zPath, flags, pResOut);
! 532: t = vfslog_time() - t;
! 533: vfslog_call(pVfs, OS_ACCESS, 0, t, rc, flags, *pResOut);
! 534: vfslog_string(pVfs, zPath);
! 535: return rc;
! 536: }
! 537:
! 538: /*
! 539: ** Populate buffer zOut with the full canonical pathname corresponding
! 540: ** to the pathname in zPath. zOut is guaranteed to point to a buffer
! 541: ** of at least (INST_MAX_PATHNAME+1) bytes.
! 542: */
! 543: static int vfslogFullPathname(
! 544: sqlite3_vfs *pVfs,
! 545: const char *zPath,
! 546: int nOut,
! 547: char *zOut
! 548: ){
! 549: return REALVFS(pVfs)->xFullPathname(REALVFS(pVfs), zPath, nOut, zOut);
! 550: }
! 551:
! 552: /*
! 553: ** Open the dynamic library located at zPath and return a handle.
! 554: */
! 555: static void *vfslogDlOpen(sqlite3_vfs *pVfs, const char *zPath){
! 556: return REALVFS(pVfs)->xDlOpen(REALVFS(pVfs), zPath);
! 557: }
! 558:
! 559: /*
! 560: ** Populate the buffer zErrMsg (size nByte bytes) with a human readable
! 561: ** utf-8 string describing the most recent error encountered associated
! 562: ** with dynamic libraries.
! 563: */
! 564: static void vfslogDlError(sqlite3_vfs *pVfs, int nByte, char *zErrMsg){
! 565: REALVFS(pVfs)->xDlError(REALVFS(pVfs), nByte, zErrMsg);
! 566: }
! 567:
! 568: /*
! 569: ** Return a pointer to the symbol zSymbol in the dynamic library pHandle.
! 570: */
! 571: static void (*vfslogDlSym(sqlite3_vfs *pVfs, void *p, const char *zSym))(void){
! 572: return REALVFS(pVfs)->xDlSym(REALVFS(pVfs), p, zSym);
! 573: }
! 574:
! 575: /*
! 576: ** Close the dynamic library handle pHandle.
! 577: */
! 578: static void vfslogDlClose(sqlite3_vfs *pVfs, void *pHandle){
! 579: REALVFS(pVfs)->xDlClose(REALVFS(pVfs), pHandle);
! 580: }
! 581:
! 582: /*
! 583: ** Populate the buffer pointed to by zBufOut with nByte bytes of
! 584: ** random data.
! 585: */
! 586: static int vfslogRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){
! 587: return REALVFS(pVfs)->xRandomness(REALVFS(pVfs), nByte, zBufOut);
! 588: }
! 589:
! 590: /*
! 591: ** Sleep for nMicro microseconds. Return the number of microseconds
! 592: ** actually slept.
! 593: */
! 594: static int vfslogSleep(sqlite3_vfs *pVfs, int nMicro){
! 595: return REALVFS(pVfs)->xSleep(REALVFS(pVfs), nMicro);
! 596: }
! 597:
! 598: /*
! 599: ** Return the current time as a Julian Day number in *pTimeOut.
! 600: */
! 601: static int vfslogCurrentTime(sqlite3_vfs *pVfs, double *pTimeOut){
! 602: return REALVFS(pVfs)->xCurrentTime(REALVFS(pVfs), pTimeOut);
! 603: }
! 604:
! 605: static int vfslogGetLastError(sqlite3_vfs *pVfs, int a, char *b){
! 606: return REALVFS(pVfs)->xGetLastError(REALVFS(pVfs), a, b);
! 607: }
! 608: static int vfslogCurrentTimeInt64(sqlite3_vfs *pVfs, sqlite3_int64 *p){
! 609: return REALVFS(pVfs)->xCurrentTimeInt64(REALVFS(pVfs), p);
! 610: }
! 611:
! 612: static void vfslog_flush(VfslogVfs *p){
! 613: #ifdef SQLITE_TEST
! 614: extern int sqlite3_io_error_pending;
! 615: extern int sqlite3_io_error_persist;
! 616: extern int sqlite3_diskfull_pending;
! 617:
! 618: int pending = sqlite3_io_error_pending;
! 619: int persist = sqlite3_io_error_persist;
! 620: int diskfull = sqlite3_diskfull_pending;
! 621:
! 622: sqlite3_io_error_pending = 0;
! 623: sqlite3_io_error_persist = 0;
! 624: sqlite3_diskfull_pending = 0;
! 625: #endif
! 626:
! 627: if( p->nBuf ){
! 628: p->pLog->pMethods->xWrite(p->pLog, p->aBuf, p->nBuf, p->iOffset);
! 629: p->iOffset += p->nBuf;
! 630: p->nBuf = 0;
! 631: }
! 632:
! 633: #ifdef SQLITE_TEST
! 634: sqlite3_io_error_pending = pending;
! 635: sqlite3_io_error_persist = persist;
! 636: sqlite3_diskfull_pending = diskfull;
! 637: #endif
! 638: }
! 639:
! 640: static void put32bits(unsigned char *p, unsigned int v){
! 641: p[0] = v>>24;
! 642: p[1] = v>>16;
! 643: p[2] = v>>8;
! 644: p[3] = v;
! 645: }
! 646:
! 647: static void vfslog_call(
! 648: sqlite3_vfs *pVfs,
! 649: int eEvent,
! 650: int iFileid,
! 651: int nClick,
! 652: int return_code,
! 653: int size,
! 654: int offset
! 655: ){
! 656: VfslogVfs *p = (VfslogVfs *)pVfs;
! 657: unsigned char *zRec;
! 658: if( (24+p->nBuf)>sizeof(p->aBuf) ){
! 659: vfslog_flush(p);
! 660: }
! 661: zRec = (unsigned char *)&p->aBuf[p->nBuf];
! 662: put32bits(&zRec[0], eEvent);
! 663: put32bits(&zRec[4], iFileid);
! 664: put32bits(&zRec[8], nClick);
! 665: put32bits(&zRec[12], return_code);
! 666: put32bits(&zRec[16], size);
! 667: put32bits(&zRec[20], offset);
! 668: p->nBuf += 24;
! 669: }
! 670:
! 671: static void vfslog_string(sqlite3_vfs *pVfs, const char *zStr){
! 672: VfslogVfs *p = (VfslogVfs *)pVfs;
! 673: unsigned char *zRec;
! 674: int nStr = zStr ? strlen(zStr) : 0;
! 675: if( (4+nStr+p->nBuf)>sizeof(p->aBuf) ){
! 676: vfslog_flush(p);
! 677: }
! 678: zRec = (unsigned char *)&p->aBuf[p->nBuf];
! 679: put32bits(&zRec[0], nStr);
! 680: if( zStr ){
! 681: memcpy(&zRec[4], zStr, nStr);
! 682: }
! 683: p->nBuf += (4 + nStr);
! 684: }
! 685:
! 686: static void vfslog_finalize(VfslogVfs *p){
! 687: if( p->pLog->pMethods ){
! 688: vfslog_flush(p);
! 689: p->pLog->pMethods->xClose(p->pLog);
! 690: }
! 691: sqlite3_free(p);
! 692: }
! 693:
! 694: int sqlite3_vfslog_finalize(const char *zVfs){
! 695: sqlite3_vfs *pVfs;
! 696: pVfs = sqlite3_vfs_find(zVfs);
! 697: if( !pVfs || pVfs->xOpen!=vfslogOpen ){
! 698: return SQLITE_ERROR;
! 699: }
! 700: sqlite3_vfs_unregister(pVfs);
! 701: vfslog_finalize((VfslogVfs *)pVfs);
! 702: return SQLITE_OK;
! 703: }
! 704:
! 705: int sqlite3_vfslog_new(
! 706: const char *zVfs, /* New VFS name */
! 707: const char *zParentVfs, /* Parent VFS name (or NULL) */
! 708: const char *zLog /* Log file name */
! 709: ){
! 710: VfslogVfs *p;
! 711: sqlite3_vfs *pParent;
! 712: int nByte;
! 713: int flags;
! 714: int rc;
! 715: char *zFile;
! 716: int nVfs;
! 717:
! 718: pParent = sqlite3_vfs_find(zParentVfs);
! 719: if( !pParent ){
! 720: return SQLITE_ERROR;
! 721: }
! 722:
! 723: nVfs = strlen(zVfs);
! 724: nByte = sizeof(VfslogVfs) + pParent->szOsFile + nVfs+1+pParent->mxPathname+1;
! 725: p = (VfslogVfs *)sqlite3_malloc(nByte);
! 726: memset(p, 0, nByte);
! 727:
! 728: p->pVfs = pParent;
! 729: p->pLog = (sqlite3_file *)&p[1];
! 730: memcpy(&p->base, &vfslog_vfs, sizeof(sqlite3_vfs));
! 731: p->base.zName = &((char *)p->pLog)[pParent->szOsFile];
! 732: p->base.szOsFile += pParent->szOsFile;
! 733: memcpy((char *)p->base.zName, zVfs, nVfs);
! 734:
! 735: zFile = (char *)&p->base.zName[nVfs+1];
! 736: pParent->xFullPathname(pParent, zLog, pParent->mxPathname, zFile);
! 737:
! 738: flags = SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE|SQLITE_OPEN_MASTER_JOURNAL;
! 739: pParent->xDelete(pParent, zFile, 0);
! 740: rc = pParent->xOpen(pParent, zFile, p->pLog, flags, &flags);
! 741: if( rc==SQLITE_OK ){
! 742: memcpy(p->aBuf, "sqlite_ostrace1.....", 20);
! 743: p->iOffset = 0;
! 744: p->nBuf = 20;
! 745: rc = sqlite3_vfs_register((sqlite3_vfs *)p, 1);
! 746: }
! 747: if( rc ){
! 748: vfslog_finalize(p);
! 749: }
! 750: return rc;
! 751: }
! 752:
! 753: int sqlite3_vfslog_annotate(const char *zVfs, const char *zMsg){
! 754: sqlite3_vfs *pVfs;
! 755: pVfs = sqlite3_vfs_find(zVfs);
! 756: if( !pVfs || pVfs->xOpen!=vfslogOpen ){
! 757: return SQLITE_ERROR;
! 758: }
! 759: vfslog_call(pVfs, OS_ANNOTATE, 0, 0, 0, 0, 0);
! 760: vfslog_string(pVfs, zMsg);
! 761: return SQLITE_OK;
! 762: }
! 763:
! 764: static const char *vfslog_eventname(int eEvent){
! 765: const char *zEvent = 0;
! 766:
! 767: switch( eEvent ){
! 768: case OS_CLOSE: zEvent = "xClose"; break;
! 769: case OS_READ: zEvent = "xRead"; break;
! 770: case OS_WRITE: zEvent = "xWrite"; break;
! 771: case OS_TRUNCATE: zEvent = "xTruncate"; break;
! 772: case OS_SYNC: zEvent = "xSync"; break;
! 773: case OS_FILESIZE: zEvent = "xFilesize"; break;
! 774: case OS_LOCK: zEvent = "xLock"; break;
! 775: case OS_UNLOCK: zEvent = "xUnlock"; break;
! 776: case OS_CHECKRESERVEDLOCK: zEvent = "xCheckResLock"; break;
! 777: case OS_FILECONTROL: zEvent = "xFileControl"; break;
! 778: case OS_SECTORSIZE: zEvent = "xSectorSize"; break;
! 779: case OS_DEVCHAR: zEvent = "xDeviceChar"; break;
! 780: case OS_OPEN: zEvent = "xOpen"; break;
! 781: case OS_DELETE: zEvent = "xDelete"; break;
! 782: case OS_ACCESS: zEvent = "xAccess"; break;
! 783: case OS_FULLPATHNAME: zEvent = "xFullPathname"; break;
! 784: case OS_RANDOMNESS: zEvent = "xRandomness"; break;
! 785: case OS_SLEEP: zEvent = "xSleep"; break;
! 786: case OS_CURRENTTIME: zEvent = "xCurrentTime"; break;
! 787:
! 788: case OS_SHMUNMAP: zEvent = "xShmUnmap"; break;
! 789: case OS_SHMLOCK: zEvent = "xShmLock"; break;
! 790: case OS_SHMBARRIER: zEvent = "xShmBarrier"; break;
! 791: case OS_SHMMAP: zEvent = "xShmMap"; break;
! 792:
! 793: case OS_ANNOTATE: zEvent = "annotation"; break;
! 794: }
! 795:
! 796: return zEvent;
! 797: }
! 798:
! 799: typedef struct VfslogVtab VfslogVtab;
! 800: typedef struct VfslogCsr VfslogCsr;
! 801:
! 802: /*
! 803: ** Virtual table type for the vfslog reader module.
! 804: */
! 805: struct VfslogVtab {
! 806: sqlite3_vtab base; /* Base class */
! 807: sqlite3_file *pFd; /* File descriptor open on vfslog file */
! 808: sqlite3_int64 nByte; /* Size of file in bytes */
! 809: char *zFile; /* File name for pFd */
! 810: };
! 811:
! 812: /*
! 813: ** Virtual table cursor type for the vfslog reader module.
! 814: */
! 815: struct VfslogCsr {
! 816: sqlite3_vtab_cursor base; /* Base class */
! 817: sqlite3_int64 iRowid; /* Current rowid. */
! 818: sqlite3_int64 iOffset; /* Offset of next record in file */
! 819: char *zTransient; /* Transient 'file' string */
! 820: int nFile; /* Size of array azFile[] */
! 821: char **azFile; /* File strings */
! 822: unsigned char aBuf[1024]; /* Current vfs log entry (read from file) */
! 823: };
! 824:
! 825: static unsigned int get32bits(unsigned char *p){
! 826: return (p[0]<<24) + (p[1]<<16) + (p[2]<<8) + p[3];
! 827: }
! 828:
! 829: /*
! 830: ** The argument must point to a buffer containing a nul-terminated string.
! 831: ** If the string begins with an SQL quote character it is overwritten by
! 832: ** the dequoted version. Otherwise the buffer is left unmodified.
! 833: */
! 834: static void dequote(char *z){
! 835: char quote; /* Quote character (if any ) */
! 836: quote = z[0];
! 837: if( quote=='[' || quote=='\'' || quote=='"' || quote=='`' ){
! 838: int iIn = 1; /* Index of next byte to read from input */
! 839: int iOut = 0; /* Index of next byte to write to output */
! 840: if( quote=='[' ) quote = ']';
! 841: while( z[iIn] ){
! 842: if( z[iIn]==quote ){
! 843: if( z[iIn+1]!=quote ) break;
! 844: z[iOut++] = quote;
! 845: iIn += 2;
! 846: }else{
! 847: z[iOut++] = z[iIn++];
! 848: }
! 849: }
! 850: z[iOut] = '\0';
! 851: }
! 852: }
! 853:
! 854: #ifndef SQLITE_OMIT_VIRTUALTABLE
! 855: /*
! 856: ** Connect to or create a vfslog virtual table.
! 857: */
! 858: static int vlogConnect(
! 859: sqlite3 *db,
! 860: void *pAux,
! 861: int argc, const char *const*argv,
! 862: sqlite3_vtab **ppVtab,
! 863: char **pzErr
! 864: ){
! 865: sqlite3_vfs *pVfs; /* VFS used to read log file */
! 866: int flags; /* flags passed to pVfs->xOpen() */
! 867: VfslogVtab *p;
! 868: int rc;
! 869: int nByte;
! 870: char *zFile;
! 871:
! 872: *ppVtab = 0;
! 873: pVfs = sqlite3_vfs_find(0);
! 874: nByte = sizeof(VfslogVtab) + pVfs->szOsFile + pVfs->mxPathname;
! 875: p = sqlite3_malloc(nByte);
! 876: if( p==0 ) return SQLITE_NOMEM;
! 877: memset(p, 0, nByte);
! 878:
! 879: p->pFd = (sqlite3_file *)&p[1];
! 880: p->zFile = &((char *)p->pFd)[pVfs->szOsFile];
! 881:
! 882: zFile = sqlite3_mprintf("%s", argv[3]);
! 883: if( !zFile ){
! 884: sqlite3_free(p);
! 885: return SQLITE_NOMEM;
! 886: }
! 887: dequote(zFile);
! 888: pVfs->xFullPathname(pVfs, zFile, pVfs->mxPathname, p->zFile);
! 889: sqlite3_free(zFile);
! 890:
! 891: flags = SQLITE_OPEN_READWRITE|SQLITE_OPEN_MASTER_JOURNAL;
! 892: rc = pVfs->xOpen(pVfs, p->zFile, p->pFd, flags, &flags);
! 893:
! 894: if( rc==SQLITE_OK ){
! 895: p->pFd->pMethods->xFileSize(p->pFd, &p->nByte);
! 896: sqlite3_declare_vtab(db,
! 897: "CREATE TABLE xxx(event, file, click, rc, size, offset)"
! 898: );
! 899: *ppVtab = &p->base;
! 900: }else{
! 901: sqlite3_free(p);
! 902: }
! 903:
! 904: return rc;
! 905: }
! 906:
! 907: /*
! 908: ** There is no "best-index". This virtual table always does a linear
! 909: ** scan of the binary VFS log file.
! 910: */
! 911: static int vlogBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo){
! 912: pIdxInfo->estimatedCost = 10.0;
! 913: return SQLITE_OK;
! 914: }
! 915:
! 916: /*
! 917: ** Disconnect from or destroy a vfslog virtual table.
! 918: */
! 919: static int vlogDisconnect(sqlite3_vtab *pVtab){
! 920: VfslogVtab *p = (VfslogVtab *)pVtab;
! 921: if( p->pFd->pMethods ){
! 922: p->pFd->pMethods->xClose(p->pFd);
! 923: p->pFd->pMethods = 0;
! 924: }
! 925: sqlite3_free(p);
! 926: return SQLITE_OK;
! 927: }
! 928:
! 929: /*
! 930: ** Open a new vfslog cursor.
! 931: */
! 932: static int vlogOpen(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor){
! 933: VfslogCsr *pCsr; /* Newly allocated cursor object */
! 934:
! 935: pCsr = sqlite3_malloc(sizeof(VfslogCsr));
! 936: if( !pCsr ) return SQLITE_NOMEM;
! 937: memset(pCsr, 0, sizeof(VfslogCsr));
! 938: *ppCursor = &pCsr->base;
! 939: return SQLITE_OK;
! 940: }
! 941:
! 942: /*
! 943: ** Close a vfslog cursor.
! 944: */
! 945: static int vlogClose(sqlite3_vtab_cursor *pCursor){
! 946: VfslogCsr *p = (VfslogCsr *)pCursor;
! 947: int i;
! 948: for(i=0; i<p->nFile; i++){
! 949: sqlite3_free(p->azFile[i]);
! 950: }
! 951: sqlite3_free(p->azFile);
! 952: sqlite3_free(p->zTransient);
! 953: sqlite3_free(p);
! 954: return SQLITE_OK;
! 955: }
! 956:
! 957: /*
! 958: ** Move a vfslog cursor to the next entry in the file.
! 959: */
! 960: static int vlogNext(sqlite3_vtab_cursor *pCursor){
! 961: VfslogCsr *pCsr = (VfslogCsr *)pCursor;
! 962: VfslogVtab *p = (VfslogVtab *)pCursor->pVtab;
! 963: int rc = SQLITE_OK;
! 964: int nRead;
! 965:
! 966: sqlite3_free(pCsr->zTransient);
! 967: pCsr->zTransient = 0;
! 968:
! 969: nRead = 24;
! 970: if( pCsr->iOffset+nRead<=p->nByte ){
! 971: int eEvent;
! 972: rc = p->pFd->pMethods->xRead(p->pFd, pCsr->aBuf, nRead, pCsr->iOffset);
! 973:
! 974: eEvent = get32bits(pCsr->aBuf);
! 975: if( (rc==SQLITE_OK)
! 976: && (eEvent==OS_OPEN || eEvent==OS_DELETE || eEvent==OS_ACCESS)
! 977: ){
! 978: char buf[4];
! 979: rc = p->pFd->pMethods->xRead(p->pFd, buf, 4, pCsr->iOffset+nRead);
! 980: nRead += 4;
! 981: if( rc==SQLITE_OK ){
! 982: int nStr = get32bits((unsigned char *)buf);
! 983: char *zStr = sqlite3_malloc(nStr+1);
! 984: rc = p->pFd->pMethods->xRead(p->pFd, zStr, nStr, pCsr->iOffset+nRead);
! 985: zStr[nStr] = '\0';
! 986: nRead += nStr;
! 987:
! 988: if( eEvent==OS_OPEN ){
! 989: int iFileid = get32bits(&pCsr->aBuf[4]);
! 990: if( iFileid>=pCsr->nFile ){
! 991: int nNew = sizeof(pCsr->azFile[0])*(iFileid+1);
! 992: pCsr->azFile = (char **)sqlite3_realloc(pCsr->azFile, nNew);
! 993: nNew -= sizeof(pCsr->azFile[0])*pCsr->nFile;
! 994: memset(&pCsr->azFile[pCsr->nFile], 0, nNew);
! 995: pCsr->nFile = iFileid+1;
! 996: }
! 997: sqlite3_free(pCsr->azFile[iFileid]);
! 998: pCsr->azFile[iFileid] = zStr;
! 999: }else{
! 1000: pCsr->zTransient = zStr;
! 1001: }
! 1002: }
! 1003: }
! 1004: }
! 1005:
! 1006: pCsr->iRowid += 1;
! 1007: pCsr->iOffset += nRead;
! 1008: return rc;
! 1009: }
! 1010:
! 1011: static int vlogEof(sqlite3_vtab_cursor *pCursor){
! 1012: VfslogCsr *pCsr = (VfslogCsr *)pCursor;
! 1013: VfslogVtab *p = (VfslogVtab *)pCursor->pVtab;
! 1014: return (pCsr->iOffset>=p->nByte);
! 1015: }
! 1016:
! 1017: static int vlogFilter(
! 1018: sqlite3_vtab_cursor *pCursor,
! 1019: int idxNum, const char *idxStr,
! 1020: int argc, sqlite3_value **argv
! 1021: ){
! 1022: VfslogCsr *pCsr = (VfslogCsr *)pCursor;
! 1023: pCsr->iRowid = 0;
! 1024: pCsr->iOffset = 20;
! 1025: return vlogNext(pCursor);
! 1026: }
! 1027:
! 1028: static int vlogColumn(
! 1029: sqlite3_vtab_cursor *pCursor,
! 1030: sqlite3_context *ctx,
! 1031: int i
! 1032: ){
! 1033: unsigned int val;
! 1034: VfslogCsr *pCsr = (VfslogCsr *)pCursor;
! 1035:
! 1036: assert( i<7 );
! 1037: val = get32bits(&pCsr->aBuf[4*i]);
! 1038:
! 1039: switch( i ){
! 1040: case 0: {
! 1041: sqlite3_result_text(ctx, vfslog_eventname(val), -1, SQLITE_STATIC);
! 1042: break;
! 1043: }
! 1044: case 1: {
! 1045: char *zStr = pCsr->zTransient;
! 1046: if( val!=0 && val<pCsr->nFile ){
! 1047: zStr = pCsr->azFile[val];
! 1048: }
! 1049: sqlite3_result_text(ctx, zStr, -1, SQLITE_TRANSIENT);
! 1050: break;
! 1051: }
! 1052: default:
! 1053: sqlite3_result_int(ctx, val);
! 1054: break;
! 1055: }
! 1056:
! 1057: return SQLITE_OK;
! 1058: }
! 1059:
! 1060: static int vlogRowid(sqlite3_vtab_cursor *pCursor, sqlite_int64 *pRowid){
! 1061: VfslogCsr *pCsr = (VfslogCsr *)pCursor;
! 1062: *pRowid = pCsr->iRowid;
! 1063: return SQLITE_OK;
! 1064: }
! 1065:
! 1066: int sqlite3_vfslog_register(sqlite3 *db){
! 1067: static sqlite3_module vfslog_module = {
! 1068: 0, /* iVersion */
! 1069: vlogConnect, /* xCreate */
! 1070: vlogConnect, /* xConnect */
! 1071: vlogBestIndex, /* xBestIndex */
! 1072: vlogDisconnect, /* xDisconnect */
! 1073: vlogDisconnect, /* xDestroy */
! 1074: vlogOpen, /* xOpen - open a cursor */
! 1075: vlogClose, /* xClose - close a cursor */
! 1076: vlogFilter, /* xFilter - configure scan constraints */
! 1077: vlogNext, /* xNext - advance a cursor */
! 1078: vlogEof, /* xEof - check for end of scan */
! 1079: vlogColumn, /* xColumn - read data */
! 1080: vlogRowid, /* xRowid - read data */
! 1081: 0, /* xUpdate */
! 1082: 0, /* xBegin */
! 1083: 0, /* xSync */
! 1084: 0, /* xCommit */
! 1085: 0, /* xRollback */
! 1086: 0, /* xFindMethod */
! 1087: 0, /* xRename */
! 1088: };
! 1089:
! 1090: sqlite3_create_module(db, "vfslog", &vfslog_module, 0);
! 1091: return SQLITE_OK;
! 1092: }
! 1093: #endif /* SQLITE_OMIT_VIRTUALTABLE */
! 1094:
! 1095: /**************************************************************************
! 1096: ***************************************************************************
! 1097: ** Tcl interface starts here.
! 1098: */
! 1099:
! 1100: #if defined(SQLITE_TEST) || defined(TCLSH)
! 1101:
! 1102: #include <tcl.h>
! 1103:
! 1104: static int test_vfslog(
! 1105: void *clientData,
! 1106: Tcl_Interp *interp,
! 1107: int objc,
! 1108: Tcl_Obj *CONST objv[]
! 1109: ){
! 1110: struct SqliteDb { sqlite3 *db; };
! 1111: sqlite3 *db;
! 1112: Tcl_CmdInfo cmdInfo;
! 1113: int rc = SQLITE_ERROR;
! 1114:
! 1115: static const char *strs[] = { "annotate", "finalize", "new", "register", 0 };
! 1116: enum VL_enum { VL_ANNOTATE, VL_FINALIZE, VL_NEW, VL_REGISTER };
! 1117: int iSub;
! 1118:
! 1119: if( objc<2 ){
! 1120: Tcl_WrongNumArgs(interp, 1, objv, "SUB-COMMAND ...");
! 1121: return TCL_ERROR;
! 1122: }
! 1123: if( Tcl_GetIndexFromObj(interp, objv[1], strs, "sub-command", 0, &iSub) ){
! 1124: return TCL_ERROR;
! 1125: }
! 1126:
! 1127: switch( (enum VL_enum)iSub ){
! 1128: case VL_ANNOTATE: {
! 1129: int rc;
! 1130: char *zVfs;
! 1131: char *zMsg;
! 1132: if( objc!=4 ){
! 1133: Tcl_WrongNumArgs(interp, 3, objv, "VFS");
! 1134: return TCL_ERROR;
! 1135: }
! 1136: zVfs = Tcl_GetString(objv[2]);
! 1137: zMsg = Tcl_GetString(objv[3]);
! 1138: rc = sqlite3_vfslog_annotate(zVfs, zMsg);
! 1139: if( rc!=SQLITE_OK ){
! 1140: Tcl_AppendResult(interp, "failed", 0);
! 1141: return TCL_ERROR;
! 1142: }
! 1143: break;
! 1144: }
! 1145: case VL_FINALIZE: {
! 1146: int rc;
! 1147: char *zVfs;
! 1148: if( objc!=3 ){
! 1149: Tcl_WrongNumArgs(interp, 2, objv, "VFS");
! 1150: return TCL_ERROR;
! 1151: }
! 1152: zVfs = Tcl_GetString(objv[2]);
! 1153: rc = sqlite3_vfslog_finalize(zVfs);
! 1154: if( rc!=SQLITE_OK ){
! 1155: Tcl_AppendResult(interp, "failed", 0);
! 1156: return TCL_ERROR;
! 1157: }
! 1158: break;
! 1159: };
! 1160:
! 1161: case VL_NEW: {
! 1162: int rc;
! 1163: char *zVfs;
! 1164: char *zParent;
! 1165: char *zLog;
! 1166: if( objc!=5 ){
! 1167: Tcl_WrongNumArgs(interp, 2, objv, "VFS PARENT LOGFILE");
! 1168: return TCL_ERROR;
! 1169: }
! 1170: zVfs = Tcl_GetString(objv[2]);
! 1171: zParent = Tcl_GetString(objv[3]);
! 1172: zLog = Tcl_GetString(objv[4]);
! 1173: if( *zParent=='\0' ) zParent = 0;
! 1174: rc = sqlite3_vfslog_new(zVfs, zParent, zLog);
! 1175: if( rc!=SQLITE_OK ){
! 1176: Tcl_AppendResult(interp, "failed", 0);
! 1177: return TCL_ERROR;
! 1178: }
! 1179: break;
! 1180: };
! 1181:
! 1182: case VL_REGISTER: {
! 1183: char *zDb;
! 1184: if( objc!=3 ){
! 1185: Tcl_WrongNumArgs(interp, 2, objv, "DB");
! 1186: return TCL_ERROR;
! 1187: }
! 1188: #ifdef SQLITE_OMIT_VIRTUALTABLE
! 1189: Tcl_AppendResult(interp, "vfslog not available because of "
! 1190: "SQLITE_OMIT_VIRTUALTABLE", (void*)0);
! 1191: return TCL_ERROR;
! 1192: #else
! 1193: zDb = Tcl_GetString(objv[2]);
! 1194: if( Tcl_GetCommandInfo(interp, zDb, &cmdInfo) ){
! 1195: db = ((struct SqliteDb*)cmdInfo.objClientData)->db;
! 1196: rc = sqlite3_vfslog_register(db);
! 1197: }
! 1198: if( rc!=SQLITE_OK ){
! 1199: Tcl_AppendResult(interp, "bad sqlite3 handle: ", zDb, (void*)0);
! 1200: return TCL_ERROR;
! 1201: }
! 1202: break;
! 1203: #endif
! 1204: }
! 1205: }
! 1206:
! 1207: return TCL_OK;
! 1208: }
! 1209:
! 1210: int SqlitetestOsinst_Init(Tcl_Interp *interp){
! 1211: Tcl_CreateObjCommand(interp, "vfslog", test_vfslog, 0, 0);
! 1212: return TCL_OK;
! 1213: }
! 1214:
! 1215: #endif /* SQLITE_TEST */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to test_osinst.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / src