Many hyperlinks are disabled.
Use anonymous login
to enable hyperlinks.
Overview
Comment: | Add support for the SQLITE_SQLLOG_CONDITIONAL environment variable to the logging code in test_sqllog.c. When defined, logging is only performed if the "<database>-sqllog" file is present in the file system when the main database is opened. |
---|---|
Downloads: | Tarball | ZIP archive |
Timelines: | family | ancestors | descendants | both | trunk |
Files: | files | file ages | folders |
SHA1: |
cab8126be9f63dd596719b12704ba77c |
User & Date: | dan 2015-11-12 20:12:51.646 |
Context
2015-11-12
| ||
21:42 | Add a space before each line of error output in the test scripts so that all errors can be conveniently located in logs by doing "grep '^ '". (check-in: 9d532fb50d user: drh tags: trunk) | |
20:12 | Add support for the SQLITE_SQLLOG_CONDITIONAL environment variable to the logging code in test_sqllog.c. When defined, logging is only performed if the "<database>-sqllog" file is present in the file system when the main database is opened. (check-in: cab8126be9 user: dan tags: trunk) | |
16:44 | Enhance the "PRAGMA cache_spill" statement to accept an integer argument which is the threshold at which spilling will begin. (check-in: f79d264db2 user: drh tags: trunk) | |
Changes
Changes to src/main.c.
︙ | ︙ | |||
216 217 218 219 220 221 222 223 224 225 226 227 228 229 | ** methods. The sqlite3_pcache_methods.xInit() all is embedded in the ** call to sqlite3PcacheInitialize(). */ sqlite3_mutex_enter(sqlite3GlobalConfig.pInitMutex); if( sqlite3GlobalConfig.isInit==0 && sqlite3GlobalConfig.inProgress==0 ){ FuncDefHash *pHash = &GLOBAL(FuncDefHash, sqlite3GlobalFunctions); sqlite3GlobalConfig.inProgress = 1; memset(pHash, 0, sizeof(sqlite3GlobalFunctions)); sqlite3RegisterGlobalFunctions(); if( sqlite3GlobalConfig.isPCacheInit==0 ){ rc = sqlite3PcacheInitialize(); } if( rc==SQLITE_OK ){ sqlite3GlobalConfig.isPCacheInit = 1; | > > > > > > | 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 | ** methods. The sqlite3_pcache_methods.xInit() all is embedded in the ** call to sqlite3PcacheInitialize(). */ sqlite3_mutex_enter(sqlite3GlobalConfig.pInitMutex); if( sqlite3GlobalConfig.isInit==0 && sqlite3GlobalConfig.inProgress==0 ){ FuncDefHash *pHash = &GLOBAL(FuncDefHash, sqlite3GlobalFunctions); sqlite3GlobalConfig.inProgress = 1; #ifdef SQLITE_INIT_SQLLOG { extern void SQLITE_INIT_SQLLOG(void); SQLITE_INIT_SQLLOG(); } #endif memset(pHash, 0, sizeof(sqlite3GlobalFunctions)); sqlite3RegisterGlobalFunctions(); if( sqlite3GlobalConfig.isPCacheInit==0 ){ rc = sqlite3PcacheInitialize(); } if( rc==SQLITE_OK ){ sqlite3GlobalConfig.isPCacheInit = 1; |
︙ | ︙ |
Changes to src/sqliteInt.h.
︙ | ︙ | |||
523 524 525 526 527 528 529 530 531 532 533 534 535 536 | ** number of pages. A negative number N translations means that a buffer ** of -1024*N bytes is allocated and used for as many pages as it will hold. */ #ifndef SQLITE_DEFAULT_PCACHE_INITSZ # define SQLITE_DEFAULT_PCACHE_INITSZ 100 #endif /* ** GCC does not define the offsetof() macro so we'll have to do it ** ourselves. */ #ifndef offsetof #define offsetof(STRUCTURE,FIELD) ((int)((char*)&((STRUCTURE*)0)->FIELD)) | > > > > > > > > | 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 | ** number of pages. A negative number N translations means that a buffer ** of -1024*N bytes is allocated and used for as many pages as it will hold. */ #ifndef SQLITE_DEFAULT_PCACHE_INITSZ # define SQLITE_DEFAULT_PCACHE_INITSZ 100 #endif /* ** If SQLITE_INIT_SQLLOG is defined, then SQLITE_ENABLE_SQLLOG is ** automatically defined as well. */ #if defined(SQLITE_INIT_SQLLOG) && !defined(SQLITE_ENABLE_SQLLOG) # define SQLITE_ENABLE_SQLLOG 1 #endif /* ** GCC does not define the offsetof() macro so we'll have to do it ** ourselves. */ #ifndef offsetof #define offsetof(STRUCTURE,FIELD) ((int)((char*)&((STRUCTURE*)0)->FIELD)) |
︙ | ︙ |
Changes to src/test1.c.
︙ | ︙ | |||
2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 | } if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; sqlite3_stmt_scanstatus_reset(pStmt); return TCL_OK; } #endif /* ** Usage: sqlite3_next_stmt DB STMT ** ** Return the next statment in sequence after STMT. */ static int test_next_stmt( void * clientData, | > > > > > > > > > > > > > > > > > > > > > > | 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 | } if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR; sqlite3_stmt_scanstatus_reset(pStmt); return TCL_OK; } #endif #ifdef SQLITE_ENABLE_SQLLOG /* ** Usage: sqlite3_config_sqllog ** ** Zero the SQLITE_CONFIG_SQLLOG configuration */ static int test_config_sqllog( void * clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[] ){ sqlite3_stmt *pStmt; /* First argument */ if( objc!=1 ){ Tcl_WrongNumArgs(interp, 1, objv, ""); return TCL_ERROR; } sqlite3_config(SQLITE_CONFIG_SQLLOG, 0, 0); return TCL_OK; } #endif /* ** Usage: sqlite3_next_stmt DB STMT ** ** Return the next statment in sequence after STMT. */ static int test_next_stmt( void * clientData, |
︙ | ︙ | |||
7032 7033 7034 7035 7036 7037 7038 7039 7040 7041 7042 7043 7044 7045 | { "sqlite3_user_change", test_user_change, 0 }, { "sqlite3_user_delete", test_user_delete, 0 }, #endif #ifdef SQLITE_ENABLE_STMT_SCANSTATUS { "sqlite3_stmt_scanstatus", test_stmt_scanstatus, 0 }, { "sqlite3_stmt_scanstatus_reset", test_stmt_scanstatus_reset, 0 }, #endif }; static int bitmask_size = sizeof(Bitmask)*8; static int longdouble_size = sizeof(LONGDOUBLE_TYPE); int i; extern int sqlite3_sync_count, sqlite3_fullsync_count; extern int sqlite3_opentemp_count; | > > > | 7054 7055 7056 7057 7058 7059 7060 7061 7062 7063 7064 7065 7066 7067 7068 7069 7070 | { "sqlite3_user_change", test_user_change, 0 }, { "sqlite3_user_delete", test_user_delete, 0 }, #endif #ifdef SQLITE_ENABLE_STMT_SCANSTATUS { "sqlite3_stmt_scanstatus", test_stmt_scanstatus, 0 }, { "sqlite3_stmt_scanstatus_reset", test_stmt_scanstatus_reset, 0 }, #endif #ifdef SQLITE_ENABLE_SQLLOG { "sqlite3_config_sqllog", test_config_sqllog, 0 }, #endif }; static int bitmask_size = sizeof(Bitmask)*8; static int longdouble_size = sizeof(LONGDOUBLE_TYPE); int i; extern int sqlite3_sync_count, sqlite3_fullsync_count; extern int sqlite3_opentemp_count; |
︙ | ︙ |
Changes to src/test_config.c.
︙ | ︙ | |||
652 653 654 655 656 657 658 659 660 661 662 663 664 665 | #endif #ifdef YYTRACKMAXSTACKDEPTH Tcl_SetVar2(interp, "sqlite_options", "yytrackmaxstackdepth", "1", TCL_GLOBAL_ONLY); #else Tcl_SetVar2(interp, "sqlite_options", "yytrackmaxstackdepth", "0", TCL_GLOBAL_ONLY); #endif #define LINKVAR(x) { \ static const int cv_ ## x = SQLITE_ ## x; \ Tcl_LinkVar(interp, "SQLITE_" #x, (char *)&(cv_ ## x), \ TCL_LINK_INT | TCL_LINK_READ_ONLY); } LINKVAR( MAX_LENGTH ); | > > > > > > | 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 | #endif #ifdef YYTRACKMAXSTACKDEPTH Tcl_SetVar2(interp, "sqlite_options", "yytrackmaxstackdepth", "1", TCL_GLOBAL_ONLY); #else Tcl_SetVar2(interp, "sqlite_options", "yytrackmaxstackdepth", "0", TCL_GLOBAL_ONLY); #endif #ifdef SQLITE_ENABLE_SQLLOG Tcl_SetVar2(interp, "sqlite_options", "sqllog", "1", TCL_GLOBAL_ONLY); #else Tcl_SetVar2(interp, "sqlite_options", "sqllog", "0", TCL_GLOBAL_ONLY); #endif #define LINKVAR(x) { \ static const int cv_ ## x = SQLITE_ ## x; \ Tcl_LinkVar(interp, "SQLITE_" #x, (char *)&(cv_ ## x), \ TCL_LINK_INT | TCL_LINK_READ_ONLY); } LINKVAR( MAX_LENGTH ); |
︙ | ︙ |
Changes to src/test_sqllog.c.
︙ | ︙ | |||
42 43 44 45 46 47 48 49 50 51 52 53 54 55 | ** ** Usually, if the application opens the same database file more than once ** (either by attaching it or by using more than one database handle), only ** a single copy is made. This behavior may be overridden (so that a ** separate copy is taken each time the database file is opened or attached) ** by setting the environment variable SQLITE_SQLLOG_REUSE_FILES to 0. ** ** OUTPUT: ** ** The SQLITE_SQLLOG_DIR is populated with three types of files: ** ** sqllog_N.db - Copies of database files. N may be any integer. ** ** sqllog_N.sql - A list of SQL statements executed by a single | > > > > > > | 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 | ** ** Usually, if the application opens the same database file more than once ** (either by attaching it or by using more than one database handle), only ** a single copy is made. This behavior may be overridden (so that a ** separate copy is taken each time the database file is opened or attached) ** by setting the environment variable SQLITE_SQLLOG_REUSE_FILES to 0. ** ** If the environment variable SQLITE_SQLLOG_CONDITIONAL is defined, then ** logging is only done for database connections if a file named ** "<database>-sqllog" exists in the same directly as the main database ** file when it is first opened ("<database>" is replaced by the actual ** name of the main database file). ** ** OUTPUT: ** ** The SQLITE_SQLLOG_DIR is populated with three types of files: ** ** sqllog_N.db - Copies of database files. N may be any integer. ** ** sqllog_N.sql - A list of SQL statements executed by a single |
︙ | ︙ | |||
84 85 86 87 88 89 90 91 92 93 94 95 96 97 | return (int)getpid(); #endif } /* Names of environment variables to be used */ #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 /* Maximum number of simultaneous database connections the process may ** open (if any more are opened an error is logged using sqlite3_log() ** and processing is halted). | > | 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 | return (int)getpid(); #endif } /* Names of environment variables to be used */ #define ENVIRONMENT_VARIABLE1_NAME "SQLITE_SQLLOG_DIR" #define ENVIRONMENT_VARIABLE2_NAME "SQLITE_SQLLOG_REUSE_FILES" #define ENVIRONMENT_VARIABLE3_NAME "SQLITE_SQLLOG_CONDITIONAL" /* Assume that all database and database file names are shorted than this. */ #define SQLLOG_NAMESZ 512 /* Maximum number of simultaneous database connections the process may ** open (if any more are opened an error is logged using sqlite3_log() ** and processing is halted). |
︙ | ︙ | |||
112 113 114 115 116 117 118 119 120 121 122 123 124 125 | */ static 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 */ | > | 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 | */ static struct SLGlobal { /* Protected by MUTEX_STATIC_MASTER */ sqlite3_mutex *mutex; /* Recursive mutex */ int nConn; /* Size of aConn[] array */ /* Protected by SLGlobal.mutex */ int bConditional; /* Only trace if *-sqllog file is present */ 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 */ |
︙ | ︙ | |||
211 212 213 214 215 216 217 | } fclose(fd); return zRet; } static int sqllogFindAttached( | | | > | > | 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 | } fclose(fd); return zRet; } static int sqllogFindAttached( sqlite3 *db, /* 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; /* The "PRAGMA database_list" command returns a list of databases in the ** order that they were attached. So a newly attached database is ** described by the last row returned. */ assert( sqllogglobal.bRec==0 ); sqllogglobal.bRec = 1; rc = sqlite3_prepare_v2(db, "PRAGMA database_list", -1, &pStmt, 0); if( rc==SQLITE_OK ){ while( SQLITE_ROW==sqlite3_step(pStmt) ){ const char *zVal1; int nVal1; const char *zVal2; int nVal2; zVal1 = (const char*)sqlite3_column_text(pStmt, 1); nVal1 = sqlite3_column_bytes(pStmt, 1); if( zName ){ memcpy(zName, zVal1, nVal1+1); } zVal2 = (const char*)sqlite3_column_text(pStmt, 2); nVal2 = sqlite3_column_bytes(pStmt, 2); memcpy(zFile, zVal2, nVal2+1); if( zSearch && strlen(zSearch)==nVal1 && 0==sqlite3_strnicmp(zSearch, zVal1, nVal1) |
︙ | ︙ | |||
281 282 283 284 285 286 287 | 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; | | | 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 | 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->db, zSearch, zName, zFile); if( rc!=SQLITE_OK ) return; if( zFile[0]=='\0' ){ zInit = sqlite3_mprintf(""); }else{ if( sqllogglobal.bReuse ){ zInit = sqllogFindFile(zFile); |
︙ | ︙ | |||
400 401 402 403 404 405 406 407 408 409 410 411 412 413 | /* 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(). ** ** The eType parameter has the following values: ** ** 0: Opening a new database connection. zSql is the name of the | > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 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 | /* 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 database handle passed as the only argument has just been opened. ** Return true if this module should log initial databases and SQL ** statements for this connection, or false otherwise. ** ** If an error occurs, sqlite3_log() is invoked to report it to the user ** and zero returned. */ static int sqllogTraceDb(sqlite3 *db){ int bRet = 1; if( sqllogglobal.bConditional ){ char zFile[SQLLOG_NAMESZ]; /* Attached database name */ int rc = sqllogFindAttached(db, "main", 0, zFile); if( rc==SQLITE_OK ){ int nFile = strlen(zFile); if( (SQLLOG_NAMESZ-nFile)<8 ){ sqlite3_log(SQLITE_IOERR, "sqllogTraceDb(): database name too long (%d bytes)", nFile ); bRet = 0; }else{ memcpy(&zFile[nFile], "-sqllog", 8); bRet = !access(zFile, F_OK); } } } return bRet; } /* ** The SQLITE_CONFIG_SQLLOG callback registered by sqlite3_init_sqllog(). ** ** The eType parameter has the following values: ** ** 0: Opening a new database connection. zSql is the name of the |
︙ | ︙ | |||
435 436 437 438 439 440 441 | /* 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); } | > > > > > > | | | | | | < < < > | | | > | | | | > > > | 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 | /* 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); } sqlite3_mutex_leave(master); sqlite3_mutex_enter(sqllogglobal.mutex); if( sqllogglobal.bRec==0 && sqllogTraceDb(db) ){ sqlite3_mutex_enter(master); 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 */ 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; } /* A database handle close command */ if( eType==2 ){ sqlite3_mutex_enter(master); if( i<sqllogglobal.nConn ){ 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 if( i<sqllogglobal.nConn ){ 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( i<sqllogglobal.nConn && p->fd ){ sqlite3_mutex_enter(sqllogglobal.mutex); if( sqllogglobal.bRec==0 ){ testSqllogStmt(p, zSql); } sqlite3_mutex_leave(sqllogglobal.mutex); } } } /* ** This function is called either before sqlite3_initialized() or by it. ** It checks if the SQLITE_SQLLOG_DIR variable is defined, and if so ** registers an SQLITE_CONFIG_SQLLOG callback to record the applications ** database activity. */ void sqlite3_init_sqllog(void){ if( getenv(ENVIRONMENT_VARIABLE1_NAME) ){ if( SQLITE_OK==sqlite3_config(SQLITE_CONFIG_SQLLOG, testSqllog, 0) ){ memset(&sqllogglobal, 0, sizeof(sqllogglobal)); sqllogglobal.bReuse = 1; if( getenv(ENVIRONMENT_VARIABLE3_NAME) ){ sqllogglobal.bConditional = 1; } } } } |
Added test/sqllog.test.
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 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 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 | # 2015 November 13 # # The author disclaims copyright to this source code. In place of # a legal notice, here is a blessing: # # May you do good and not evil. # May you find forgiveness for yourself and forgive others. # May you share freely, never taking more than you give. # #*********************************************************************** # This file implements regression tests for SQLite library. The # focus of this file is testing the test_sqllog.c module. # set testdir [file dirname $argv0] source $testdir/tester.tcl set testprefix sqllog ifcapable !sqllog { finish_test return } proc readfile {f} { set fd [open $f] set txt [read $fd] close $fd set txt } proc delete_all_sqllog_files {} { forcedelete {*}[glob -nocomplain sqllog_*.sql] forcedelete {*}[glob -nocomplain sqllog_*.db] forcedelete {*}[glob -nocomplain sqllog_*.idx] } proc touch {f} { set fd [open $f w+] close $fd } db close sqlite3_shutdown set ::env(SQLITE_SQLLOG_DIR) [pwd] delete_all_sqllog_files sqlite3 db test.db set a a set b b do_execsql_test 1.0 { CREATE TABLE t1(x, y); INSERT INTO t1 VALUES(1, 2); INSERT INTO t1 VALUES($a, $b); SELECT * FROM t1; } {1 2 a b} db close do_test 1.1 { readfile [lindex [glob sqllog_*.sql] 0] } [string trimleft { /-- Main database is '.*/sqllog_.*_0.db' CREATE TABLE t1\(x, y\);; -- clock=0 INSERT INTO t1 VALUES\(1, 2\);; -- clock=1 INSERT INTO t1 VALUES\('a', 'b'\);; -- clock=2 SELECT . FROM t1;; -- clock=3 /}] do_test 1.2 { file size [lindex [glob sqllog_*_0.db] 0] } 1024 #------------------------------------------------------------------------- catch { db close } sqlite3_shutdown delete_all_sqllog_files forcedelete test.db-sqllog set ::env(SQLITE_SQLLOG_CONDITIONAL) 1 sqlite3 db test.db do_execsql_test 2.1 { INSERT INTO t1 VALUES(4, 5); SELECT * FROM t1; } {1 2 a b 4 5} do_test 2.2 { glob -nocomplain sqllog_* } {} db close touch test.db-sqllog sqlite3 db test.db do_execsql_test 2.3 { INSERT INTO t1 VALUES(6, 7); SELECT * FROM t1; } {1 2 a b 4 5 6 7} db close do_test 2.4 { readfile [lindex [glob sqllog_*.sql] 0] } [string trimleft { /-- Main database is '.*/sqllog_.*_0.db' INSERT INTO t1 VALUES\(6, 7\);; -- clock=0 SELECT . FROM t1;; -- clock=1 /}] catch { db close } sqlite3_shutdown unset ::env(SQLITE_SQLLOG_DIR) unset ::env(SQLITE_SQLLOG_CONDITIONAL) sqlite3_config_sqllog sqlite3_initialize breakpoint finish_test |
Changes to test/trigger7.test.
︙ | ︙ | |||
16 17 18 19 20 21 22 | set testdir [file dirname $argv0] source $testdir/tester.tcl ifcapable {!trigger} { finish_test return } | < | 16 17 18 19 20 21 22 23 24 25 26 27 28 29 | set testdir [file dirname $argv0] source $testdir/tester.tcl ifcapable {!trigger} { finish_test return } # Error messages resulting from qualified trigger names. # do_test trigger7-1.1 { execsql { CREATE TABLE t1(x, y); } |
︙ | ︙ |