Many hyperlinks are disabled.
Use anonymous login
to enable hyperlinks.
Overview
Comment: | Fix problems in test_sqllog.c. Clarify the experimental SQLITE_CONFIG_SQLLOG interface. Handle at least the more likely error conditions in test_sqllog.c. |
---|---|
Downloads: | Tarball | ZIP archive |
Timelines: | family | ancestors | descendants | both | sqllog |
Files: | files | file ages | folders |
SHA1: |
429c5b2056d7b7c644ca53bc97b8e0b9 |
User & Date: | dan 2012-11-27 10:56:39.734 |
Context
2012-11-27
| ||
16:39 | Get SQLLOG working on windows. Fix a couple of compiler warnings. (Closed-Leaf check-in: b3809c937b user: drh tags: sqllog) | |
10:56 | Fix problems in test_sqllog.c. Clarify the experimental SQLITE_CONFIG_SQLLOG interface. Handle at least the more likely error conditions in test_sqllog.c. (check-in: 429c5b2056 user: dan tags: sqllog) | |
2012-11-26
| ||
19:50 | Add an option to register global hooks used for logging all SQL executed by an application. (check-in: cd501bbccf user: dan tags: sqllog) | |
Changes
Changes to src/main.c.
︙ | ︙ | |||
130 131 132 133 134 135 136 | ** must be complete. So isInit must not be set until the very end ** of this routine. */ if( sqlite3GlobalConfig.isInit ) return SQLITE_OK; #ifdef SQLITE_ENABLE_SQLLOG { | | | 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 | ** must be complete. So isInit must not be set until the very end ** of this routine. */ if( sqlite3GlobalConfig.isInit ) return SQLITE_OK; #ifdef SQLITE_ENABLE_SQLLOG { extern void sqlite3_init_sqllog(void); sqlite3_init_sqllog(); } #endif /* Make sure the mutex subsystem is initialized. If unable to ** initialize the mutex subsystem, return early with the error. ** If the system is so sick that we are unable to allocate a mutex, |
︙ | ︙ | |||
833 834 835 836 837 838 839 | "statements or unfinished backups"); sqlite3_mutex_leave(db->mutex); return SQLITE_BUSY; } #ifdef SQLITE_ENABLE_SQLLOG if( sqlite3GlobalConfig.xSqllog ){ | > | | 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 | "statements or unfinished backups"); sqlite3_mutex_leave(db->mutex); return SQLITE_BUSY; } #ifdef SQLITE_ENABLE_SQLLOG if( sqlite3GlobalConfig.xSqllog ){ /* Closing the handle. Fourth parameter is passed the value 2. */ sqlite3GlobalConfig.xSqllog(sqlite3GlobalConfig.pSqllogArg, db, 0, 2); } #endif /* Convert the connection into a zombie and then close it. */ db->magic = SQLITE_MAGIC_ZOMBIE; sqlite3LeaveMutexAndCloseZombie(db); |
︙ | ︙ | |||
2471 2472 2473 2474 2475 2476 2477 | db = 0; }else if( rc!=SQLITE_OK ){ db->magic = SQLITE_MAGIC_SICK; } *ppDb = db; #ifdef SQLITE_ENABLE_SQLLOG if( sqlite3GlobalConfig.xSqllog ){ | > > | < < | 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 | db = 0; }else if( rc!=SQLITE_OK ){ db->magic = SQLITE_MAGIC_SICK; } *ppDb = db; #ifdef SQLITE_ENABLE_SQLLOG if( sqlite3GlobalConfig.xSqllog ){ /* Opening a db handle. Fourth parameter is passed 0. */ void *pArg = sqlite3GlobalConfig.pSqllogArg; sqlite3GlobalConfig.xSqllog(pArg, db, zFilename, 0); } #endif return sqlite3ApiExit(0, rc); } /* ** Open a new database handle. |
︙ | ︙ |
Changes to src/sqlite.h.in.
︙ | ︙ | |||
1595 1596 1597 1598 1599 1600 1601 | ** </dl> ** ** [[SQLITE_CONFIG_SQLLOG]] ** <dt>SQLITE_CONFIG_SQLLOG ** <dd>This option is only available if sqlite is compiled with the ** SQLITE_ENABLE_SQLLOG pre-processor macro defined. The first argument should ** be a pointer to a function of type void(*)(void*,sqlite3*,const char*, int). | | > > > > > > > > | 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 | ** </dl> ** ** [[SQLITE_CONFIG_SQLLOG]] ** <dt>SQLITE_CONFIG_SQLLOG ** <dd>This option is only available if sqlite is compiled with the ** SQLITE_ENABLE_SQLLOG pre-processor macro defined. The first argument should ** be a pointer to a function of type void(*)(void*,sqlite3*,const char*, int). ** The second should be of type (void*). The callback is invoked by the library ** in three separate circumstances, identified by the value passed as the ** fourth parameter. If the fourth parameter is 0, then the database connection ** passed as the second argument has just been opened. The third argument ** points to a buffer containing the name of the main database file. If the ** fourth parameter is 1, then the SQL statement that the third parameter ** points to has just been executed. Or, if the fourth parameter is 2, then ** the connection being passed as the second parameter is being closed. The ** third parameter is passed NULL In this case. ** </dl> */ #define SQLITE_CONFIG_SINGLETHREAD 1 /* nil */ #define SQLITE_CONFIG_MULTITHREAD 2 /* nil */ #define SQLITE_CONFIG_SERIALIZED 3 /* nil */ #define SQLITE_CONFIG_MALLOC 4 /* sqlite3_mem_methods* */ #define SQLITE_CONFIG_GETMALLOC 5 /* sqlite3_mem_methods* */ |
︙ | ︙ |
Changes to src/test_sqllog.c.
︙ | ︙ | |||
44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 | ** ** sqllog_N.sql - A list of SQL statements executed by a single ** connection. N may be any integer. ** ** sqllog.idx - An index mapping from integer N to a database ** file name - indicating the full path of the ** database from which sqllog_N.db was copied. */ #include "sqlite3.h" #include "stdio.h" #include "stdlib.h" #include "string.h" #include "assert.h" #define ENVIRONMENT_VARIABLE1_NAME "SQLITE_SQLLOG_DIR" #define ENVIRONMENT_VARIABLE2_NAME "SQLITE_SQLLOG_REUSE_FILES" /* Assume that all database and database file names are shorted than this. */ #define SQLLOG_NAMESZ 512 | > > > > > > > > > > > > > > | 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 | ** ** sqllog_N.sql - A list of SQL statements executed by a single ** connection. N may be any integer. ** ** sqllog.idx - An index mapping from integer N to a database ** file name - indicating the full path of the ** database from which sqllog_N.db was copied. ** ** ERROR HANDLING: ** ** This module attempts to make a best effort to continue logging if an ** IO or other error is encountered. For example, if a log file cannot ** be opened logs are not collected for that connection, but other ** logging proceeds as expected. Errors are logged by calling sqlite3_log(). */ #include "sqlite3.h" #include "stdio.h" #include "stdlib.h" #include "string.h" #include "assert.h" #include "sys/types.h" #include "unistd.h" static int getProcessId(void){ return (int)getpid(); } #define ENVIRONMENT_VARIABLE1_NAME "SQLITE_SQLLOG_DIR" #define ENVIRONMENT_VARIABLE2_NAME "SQLITE_SQLLOG_REUSE_FILES" /* Assume that all database and database file names are shorted than this. */ #define SQLLOG_NAMESZ 512 |
︙ | ︙ | |||
78 79 80 81 82 83 84 | struct SLGlobal { /* Protected by MUTEX_STATIC_MASTER */ sqlite3_mutex *mutex; /* Recursive mutex */ int nConn; /* Size of aConn[] array */ /* Protected by SLGlobal.mutex */ int bReuse; /* True to avoid extra copies of db files */ | | | 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 | struct SLGlobal { /* Protected by MUTEX_STATIC_MASTER */ sqlite3_mutex *mutex; /* Recursive mutex */ int nConn; /* Size of aConn[] array */ /* Protected by SLGlobal.mutex */ int bReuse; /* True to avoid extra copies of db files */ char zPrefix[SQLLOG_NAMESZ]; /* Prefix for all created files */ char zIdx[SQLLOG_NAMESZ]; /* Full path to *.idx file */ int iNextLog; /* Used to allocate file names */ int iNextDb; /* Used to allocate database file names */ int bRec; /* True if testSqllog() is called rec. */ int iClock; /* Clock value */ struct SLConn aConn[MAX_CONNECTIONS]; } sqllogglobal; |
︙ | ︙ | |||
131 132 133 134 135 136 137 | */ static char *sqllogFindFile(const char *zFile){ char *zRet = 0; FILE *fd = 0; /* Open the index file for reading */ fd = fopen(sqllogglobal.zIdx, "r"); | > > > | > > > > | > | | | | | | | | > | | > | | | | | | | | > > > > > | | 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 | */ static char *sqllogFindFile(const char *zFile){ char *zRet = 0; FILE *fd = 0; /* Open the index file for reading */ fd = fopen(sqllogglobal.zIdx, "r"); if( fd==0 ){ sqlite3_log(SQLITE_IOERR, "sqllogFindFile(): error in fopen()"); return 0; } /* Loop through each entry in the index file. If zFile is not NULL and the ** entry is a match, then set zRet to point to the filename of the existing ** copy and break out of the loop. */ while( feof(fd)==0 ){ char zLine[SQLLOG_NAMESZ*2+5]; if( fgets(zLine, sizeof(zLine), fd) ){ int n; char *z; zLine[sizeof(zLine)-1] = '\0'; z = zLine; while( *z>='0' && *z<='9' ) z++; while( *z==' ' ) z++; n = strlen(z); while( n>0 && sqllog_isspace(z[n-1]) ) n--; if( n==strlen(zFile) && 0==memcmp(zFile, z, n) ){ char zBuf[16]; memset(zBuf, 0, sizeof(zBuf)); z = zLine; while( *z>='0' && *z<='9' ){ zBuf[z-zLine] = *z; z++; } zRet = sqlite3_mprintf("%s_%s.db", sqllogglobal.zPrefix, zBuf); break; } } } if( ferror(fd) ){ sqlite3_log(SQLITE_IOERR, "sqllogFindFile(): error reading index file"); } fclose(fd); return zRet; } static int sqllogFindAttached( struct SLConn *p, /* Database connection */ const char *zSearch, /* Name to search for (or NULL) */ char *zName, /* OUT: Name of attached database */ char *zFile /* OUT: Name of attached file */ ){ sqlite3_stmt *pStmt; int rc; |
︙ | ︙ | |||
197 198 199 200 201 202 203 204 205 206 207 208 209 210 | ){ break; } } rc = sqlite3_finalize(pStmt); } sqllogglobal.bRec = 0; } /* ** Parameter zSearch is the name of a database attached to the database ** connection associated with the first argument. This function creates ** a backup of this database in the logs directory. | > > > > > | 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 | ){ break; } } rc = sqlite3_finalize(pStmt); } sqllogglobal.bRec = 0; if( rc!=SQLITE_OK ){ sqlite3_log(rc, "sqllogFindAttached(): error in \"PRAGMA database_list\""); } return rc; } /* ** Parameter zSearch is the name of a database attached to the database ** connection associated with the first argument. This function creates ** a backup of this database in the logs directory. |
︙ | ︙ | |||
224 225 226 227 228 229 230 231 | ** The SLGlobal.mutex mutex is always held when this function is called. */ static void sqllogCopydb(struct SLConn *p, const char *zSearch, int bLog){ char zName[SQLLOG_NAMESZ]; /* Attached database name */ char zFile[SQLLOG_NAMESZ]; /* Database file name */ char *zFree; char *zInit = 0; | > | > > < | | > > > | | > | | > > > > | | 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 | ** The SLGlobal.mutex mutex is always held when this function is called. */ static void sqllogCopydb(struct SLConn *p, const char *zSearch, int bLog){ char zName[SQLLOG_NAMESZ]; /* Attached database name */ char zFile[SQLLOG_NAMESZ]; /* Database file name */ char *zFree; char *zInit = 0; int rc; rc = sqllogFindAttached(p, zSearch, zName, zFile); if( rc!=SQLITE_OK ) return; if( zFile[0]=='\0' ){ zInit = sqlite3_mprintf(""); }else{ if( sqllogglobal.bReuse ){ zInit = sqllogFindFile(zFile); }else{ zInit = 0; } if( zInit==0 ){ int rc; sqlite3 *copy = 0; int iDb; /* Generate a file-name to use for the copy of this database */ iDb = sqllogglobal.iNextDb++; zInit = sqlite3_mprintf("%s_%d.db", sqllogglobal.zPrefix, iDb); /* Create the backup */ assert( sqllogglobal.bRec==0 ); sqllogglobal.bRec = 1; rc = sqlite3_open(zInit, ©); if( rc==SQLITE_OK ){ sqlite3_backup *pBak; sqlite3_exec(copy, "PRAGMA synchronous = 0", 0, 0, 0); pBak = sqlite3_backup_init(copy, "main", p->db, zName); if( pBak ){ sqlite3_backup_step(pBak, -1); rc = sqlite3_backup_finish(pBak); }else{ rc = sqlite3_errcode(copy); } sqlite3_close(copy); } sqllogglobal.bRec = 0; if( rc==SQLITE_OK ){ /* Write an entry into the database index file */ FILE *fd = fopen(sqllogglobal.zIdx, "a"); if( fd ){ fprintf(fd, "%d %s\n", iDb, zFile); fclose(fd); } }else{ sqlite3_log(rc, "sqllogCopydb(): error backing up database"); } } } if( bLog ){ zFree = sqlite3_mprintf("ATTACH '%q' AS '%q'; -- clock=%d\n", zInit, zName, sqllogglobal.iClock++ ); }else{ zFree = sqlite3_mprintf("-- Main database is '%q'\n", zInit); } fprintf(p->fd, "%s", zFree); sqlite3_free(zFree); |
︙ | ︙ | |||
290 291 292 293 294 295 296 | ** The SLGlobal.mutex mutex is always held when this function is called. */ static void sqllogOpenlog(struct SLConn *p){ /* If the log file has not yet been opened, open it now. */ if( p->fd==0 ){ char *zLog; | | | | | | | | | < > > > | < | < < | < < | | | < < < | < < | | | | | | 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 | ** The SLGlobal.mutex mutex is always held when this function is called. */ static void sqllogOpenlog(struct SLConn *p){ /* If the log file has not yet been opened, open it now. */ if( p->fd==0 ){ char *zLog; /* If it is still NULL, have global.zPrefix point to a copy of ** environment variable $ENVIRONMENT_VARIABLE1_NAME. */ if( sqllogglobal.zPrefix[0]==0 ){ FILE *fd; char *zVar = getenv(ENVIRONMENT_VARIABLE1_NAME); if( zVar==0 || strlen(zVar)+10>=(sizeof(sqllogglobal.zPrefix)) ) return; sprintf(sqllogglobal.zPrefix, "%s/sqllog_%d", zVar, getProcessId()); sprintf(sqllogglobal.zIdx, "%s.idx", sqllogglobal.zPrefix); if( getenv(ENVIRONMENT_VARIABLE2_NAME) ){ sqllogglobal.bReuse = atoi(getenv(ENVIRONMENT_VARIABLE2_NAME)); } fd = fopen(sqllogglobal.zIdx, "w"); if( fd ) fclose(fd); } /* Open the log file */ zLog = sqlite3_mprintf("%s_%d.sql", sqllogglobal.zPrefix, p->iLog); p->fd = fopen(zLog, "w"); sqlite3_free(zLog); if( p->fd==0 ){ sqlite3_log(SQLITE_IOERR, "sqllogOpenlog(): Failed to open log file"); } } } /* ** This function is called if the SQLLOG callback is invoked to report ** execution of an SQL statement. Parameter p is the connection the statement ** was executed by and parameter zSql is the text of the statement itself. */ static void testSqllogStmt(struct SLConn *p, const char *zSql){ const char *zFirst; /* Pointer to first token in zSql */ int nFirst; /* Size of token zFirst in bytes */ sqllogTokenize(zSql, &zFirst, &nFirst); if( nFirst!=6 || 0!=sqlite3_strnicmp("ATTACH", zFirst, 6) ){ /* Not an ATTACH statement. Write this directly to the log. */ fprintf(p->fd, "%s; -- clock=%d\n", zSql, sqllogglobal.iClock++); }else{ /* This is an ATTACH statement. Copy the database. */ sqllogCopydb(p, 0, 1); } } /* ** The SQLITE_CONFIG_SQLLOG callback registered by sqlite3_init_sqllog(). */ static void testSqllog(void *pCtx, sqlite3 *db, const char *zSql, int eType){ struct SLConn *p; sqlite3_mutex *master = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER); assert( eType==0 || eType==1 || eType==2 ); assert( (eType==2)==(zSql==0) ); /* This is a database open command. */ if( eType==0 ){ sqlite3_mutex_enter(master); if( sqllogglobal.mutex==0 ){ sqllogglobal.mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_RECURSIVE); } p = &sqllogglobal.aConn[sqllogglobal.nConn++]; p->fd = 0; p->db = db; p->iLog = sqllogglobal.iNextLog++; sqlite3_mutex_leave(master); /* Open the log and take a copy of the main database file */ sqlite3_mutex_enter(sqllogglobal.mutex); if( sqllogglobal.bRec==0 ){ sqllogOpenlog(p); if( p->fd ) sqllogCopydb(p, "main", 0); } sqlite3_mutex_leave(sqllogglobal.mutex); } else{ int i; for(i=0; i<sqllogglobal.nConn; i++){ p = &sqllogglobal.aConn[i]; if( p->db==db ) break; } if( i==sqllogglobal.nConn ) return; /* A database handle close command */ if( eType==2 ){ sqlite3_mutex_enter(master); if( p->fd ) fclose(p->fd); p->db = 0; p->fd = 0; sqllogglobal.nConn--; if( sqllogglobal.nConn==0 ){ sqlite3_mutex_free(sqllogglobal.mutex); sqllogglobal.mutex = 0; }else{ int nShift = &sqllogglobal.aConn[sqllogglobal.nConn] - p; if( nShift>0 ){ memmove(p, &p[1], nShift*sizeof(struct SLConn)); } } sqlite3_mutex_leave(master); /* An ordinary SQL command. */ }else if( p->fd ){ sqlite3_mutex_enter(sqllogglobal.mutex); if( sqllogglobal.bRec==0 ){ testSqllogStmt(p, zSql); } sqlite3_mutex_leave(sqllogglobal.mutex); } } } /* |
︙ | ︙ |