SQLite

Changes On Branch osinst
Login

Many hyperlinks are disabled.
Use anonymous login to enable hyperlinks.

Changes In Branch osinst Excluding Merge-Ins

This is equivalent to a diff from c20a3533 to 74d975c6

2021-08-11
18:44
If the special "sqlite_rbu_replace_hack" table is present in an RBU database, use REPLACE instead of INSERT when writing index entries to imposter tables. (check-in: 4b73e151 user: dan tags: rbu-replace-hack)
2019-10-10
15:42
Version number to 3.30.1. (check-in: 12e28cc7 user: drh tags: branch-3.30)
2019-10-08
19:45
Store 64-bit offset values in osinst log files. (Leaf check-in: 74d975c6 user: dan tags: osinst)
2019-10-07
10:29
Avoid attempting to read 0 bytes from a file in the osinst vtab code. (check-in: 1fb76c3e user: dan tags: osinst)
2019-10-05
17:29
Have sqlite3.c automatically turn on osinst logging for all connections. (check-in: eea231f8 user: dan tags: osinst)
14:39
Performance optimization to the lookaside-memory disabling mechanism. (check-in: 17ce1c49 user: drh tags: trunk)
2019-10-04
16:15
Bring the wal2 branch up to date with version 3.30.0 (check-in: 16e1dced user: drh tags: wal2)
16:08
Bring the begin-concurrent-pnu branch up-to-date with version 3.30.0. (check-in: a4d26bcf user: drh tags: begin-concurrent-pnu)
15:52
Bring the begin-concurrent branch up-to-date with the 3.30.0 release. (check-in: abd1b4df user: drh tags: begin-concurrent)
15:41
Bring the apple-osx branch up-to-date with the 3.30.0 release. (check-in: 76b26aca user: drh tags: apple-osx)
15:31
Bring the reuse-schema branch up-to-date with version 3.30.0. (check-in: 6e09afec user: drh tags: reuse-schema)
15:03
Version 3.30.0 (check-in: c20a3533 user: drh tags: trunk, release, version-3.30.0)
2019-10-03
16:02
Avoid running a couple of tests in affinity2.test as part of the valgrind permutations, as the way floating point computations are simulated by valgrind causes them to fail. (check-in: 7f9a4b60 user: dan tags: trunk)

Changes to Makefile.in.

373
374
375
376
377
378
379


380
381
382
383
384
385
386
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388







+
+







  opcodes.c \
  opcodes.h \
  parse.c \
  parse.h \
  config.h \
  shell.c \
  sqlite3.h

SRC += $(TOP)/src/test_osinst.c

# Source code to the test files.
#
TESTSRC = \
  $(TOP)/src/test1.c \
  $(TOP)/src/test2.c \
  $(TOP)/src/test3.c \
677
678
679
680
681
682
683



684
685
686
687
688
689
690
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695







+
+
+







             $(TOP)/test/ossfuzz.c sqlite3.c $(TLIBS)

sessionfuzz$(TEXE):	$(TOP)/test/sessionfuzz.c sqlite3.c sqlite3.h
	$(LTLINK) -o $@ $(TOP)/test/sessionfuzz.c $(TLIBS)

dbfuzz$(TEXE):	$(TOP)/test/dbfuzz.c sqlite3.c sqlite3.h
	$(LTLINK) -o $@ $(DBFUZZ_OPT) $(TOP)/test/dbfuzz.c sqlite3.c $(TLIBS)

osinst2sql$(TEXE):	$(TOP)/tool/osinst2sql.c sqlite3.c sqlite3.h
	$(LTLINK) -o $@ $(TOP)/tool/osinst2sql.c sqlite3.c $(TLIBS)

DBFUZZ2_OPTS = \
  -DSQLITE_THREADSAFE=0 \
  -DSQLITE_OMIT_LOAD_EXTENSION \
  -DSQLITE_ENABLE_DESERIALIZE \
  -DSQLITE_DEBUG \
  -DSQLITE_ENABLE_DBSTAT_VTAB \

Changes to Makefile.msc.

1342
1343
1344
1345
1346
1347
1348
1349


1350
1351
1352
1353
1354
1355
1356
1342
1343
1344
1345
1346
1347
1348

1349
1350
1351
1352
1353
1354
1355
1356
1357







-
+
+







  $(TOP)\src\vdbetrace.c \
  $(TOP)\src\vtab.c \
  $(TOP)\src\wal.c \
  $(TOP)\src\walker.c \
  $(TOP)\src\where.c \
  $(TOP)\src\wherecode.c \
  $(TOP)\src\whereexpr.c \
  $(TOP)\src\window.c
  $(TOP)\src\window.c \
  $(TOP)\src\test_osinst.c

# Core miscellaneous files.
#
SRC03 = \
  $(TOP)\src\parse.y

# Core header files, part 1.
1466
1467
1468
1469
1470
1471
1472
1473

1474
1475
1476
1477
1478
1479
1480
1467
1468
1469
1470
1471
1472
1473

1474
1475
1476
1477
1478
1479
1480
1481







-
+







  $(SQLITETCLDECLSH)
!ELSE
SRC12 =
!ENDIF

# All source code files.
#
SRC = $(SRC00) $(SRC01) $(SRC03) $(SRC04) $(SRC05) $(SRC06) $(SRC07) $(SRC08) $(SRC09) $(SRC10) $(SRC11)
SRC = $(SRC00) $(SRC01) $(SRC03) $(SRC04) $(SRC05) $(SRC06) $(SRC07) $(SRC08) $(SRC09) $(SRC10) $(SRC11) 

# Source code to the test files.
#
TESTSRC = \
  $(TOP)\src\test1.c \
  $(TOP)\src\test2.c \
  $(TOP)\src\test3.c \
1768
1769
1770
1771
1772
1773
1774



1775
1776
1777
1778
1779
1780
1781
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785







+
+
+








fuzzershell.exe:	$(TOP)\tool\fuzzershell.c $(SQLITE3C) $(SQLITE3H)
	$(LTLINK) $(NO_WARN) $(FUZZERSHELL_COMPILE_OPTS) $(TOP)\tool\fuzzershell.c $(SQLITE3C) /link $(LDFLAGS) $(LTLINKOPTS)

dbfuzz.exe:	$(TOP)\test\dbfuzz.c $(SQLITE3C) $(SQLITE3H)
	$(LTLINK) $(NO_WARN) $(DBFUZZ_COMPILE_OPTS) $(TOP)\test\dbfuzz.c $(SQLITE3C) /link $(LDFLAGS) $(LTLINKOPTS)

osinst2sql.exe:	$(TOP)\tool\osinst2sql.c $(SQLITE3C) $(SQLITE3H)
	$(LTLINK) $(NO_WARN) $(TOP)\tool\osinst2sql.c $(SQLITE3C) /link $(LDFLAGS) $(LTLINKOPTS)

fuzzcheck.exe:	$(FUZZCHECK_SRC) $(SQLITE3C) $(SQLITE3H)
	$(LTLINK) $(NO_WARN) $(FUZZCHECK_OPTS) $(FUZZCHECK_SRC) $(SQLITE3C) /link $(LDFLAGS) $(LTLINKOPTS)

ossshell.exe:	$(OSSSHELL_SRC) $(SQLITE3C) $(SQLITE3H)
	$(LTLINK) $(NO_WARN) $(FUZZCHECK_OPTS) $(OSSSHELL_SRC) $(SQLITE3C) /link $(LDFLAGS) $(LTLINKOPTS)

sessionfuzz.exe:	zlib $(TOP)\test\sessionfuzz.c $(SQLITE3C) $(SQLITE3H)

Changes to main.mk.

293
294
295
296
297
298
299


300
301
302
303
304
305
306
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308







+
+







  opcodes.c \
  opcodes.h \
  parse.c \
  parse.h \
  shell.c \
  sqlite3.h

SRC += $(TOP)/src/test_osinst.c


# Source code to the test files.
#
TESTSRC = \
  $(TOP)/ext/expert/sqlite3expert.c \
  $(TOP)/ext/expert/test_expert.c \
  $(TOP)/ext/fts3/fts3_term.c \
575
576
577
578
579
580
581





582
583
584
585
586
587
588
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595







+
+
+
+
+







	  $(FUZZERSHELL_OPT) $(TOP)/tool/fuzzershell.c sqlite3.c \
	  $(TLIBS) $(THREADLIB)

dbfuzz$(EXE):	$(TOP)/test/dbfuzz.c sqlite3.c sqlite3.h
	$(TCCX) -o dbfuzz$(EXE) -DSQLITE_THREADSAFE=0 -DSQLITE_OMIT_LOAD_EXTENSION \
	  $(DBFUZZ_OPT) $(TOP)/test/dbfuzz.c sqlite3.c \
	  $(TLIBS) $(THREADLIB)

osinst2sql$(EXE): $(TOP)/tool/osinst2sql.c sqlite3.c sqlite3.h
	$(TCCX) -o osinst2sql$(EXE) -DSQLITE_THREADSAFE=0 -DSQLITE_OMIT_LOAD_EXTENSION \
	  $(DBFUZZ_OPT) $(TOP)/tool/osinst2sql.c sqlite3.c \
	  $(TLIBS) $(THREADLIB)

DBFUZZ2_OPTS = \
  -DSQLITE_THREADSAFE=0 \
  -DSQLITE_OMIT_LOAD_EXTENSION \
  -DSQLITE_ENABLE_DESERIALIZE \
  -DSQLITE_DEBUG \
  -DSQLITE_ENABLE_DBSTAT_VTAB \

Changes to src/main.c.

1143
1144
1145
1146
1147
1148
1149





1150
1151
1152
1153
1154
1155
1156
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161







+
+
+
+
+







** version forces the connection to become a zombie if there are
** unclosed resources, and arranges for deallocation when the last
** prepare statement or sqlite3_backup closes.
*/
int sqlite3_close(sqlite3 *db){ return sqlite3Close(db,0); }
int sqlite3_close_v2(sqlite3 *db){ return sqlite3Close(db,1); }

#ifdef SQLITE_ENABLE_OSINST
int sqlite3_vfslog_new(const char*,const char*,const char*,sqlite3_vfs**);
int sqlite3_vfslog_finalize(const char*);
#endif


/*
** Close the mutex on database connection db.
**
** Furthermore, if database connection db is a zombie (meaning that there
** has been a prior call to sqlite3_close(db) or sqlite3_close_v2(db)) and
** every sqlite3_stmt has now been finalized and every sqlite3_backup has
1247
1248
1249
1250
1251
1252
1253







1254
1255
1256
1257
1258
1259
1260
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272







+
+
+
+
+
+
+







  sqlite3CloseExtensions(db);
#if SQLITE_USER_AUTHENTICATION
  sqlite3_free(db->auth.zAuthUser);
  sqlite3_free(db->auth.zAuthPW);
#endif

  db->magic = SQLITE_MAGIC_ERROR;

#ifdef SQLITE_ENABLE_OSINST
  if( db->pOsinstVfs ){
    sqlite3_vfslog_finalize(db->pOsinstVfs->zName);
    db->pOsinstVfs = 0;
  }
#endif

  /* The temp-database schema is allocated differently from the other schema
  ** objects (using sqliteMalloc() directly, instead of sqlite3BtreeSchema()).
  ** So it needs to be freed here. Todo: Why not roll the temp schema into
  ** the same sqliteMalloc() as the one that allocates the database 
  ** structure?
  */
3183
3184
3185
3186
3187
3188
3189



















3190
3191
3192
3193
3194
3195

3196
3197
3198
3199
3200
3201
3202
3195
3196
3197
3198
3199
3200
3201
3202
3203
3204
3205
3206
3207
3208
3209
3210
3211
3212
3213
3214
3215
3216
3217
3218
3219
3220
3221
3222
3223
3224
3225
3226
3227
3228
3229
3230
3231
3232
3233
3234







+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+






+







  testcase( (1<<(flags&7))==0x04 ); /* READWRITE */
  testcase( (1<<(flags&7))==0x40 ); /* READWRITE | CREATE */
  if( ((1<<(flags&7)) & 0x46)==0 ){
    rc = SQLITE_MISUSE_BKPT;  /* IMP: R-65497-44594 */
  }else{
    rc = sqlite3ParseUri(zVfs, zFilename, &flags, &db->pVfs, &zOpen, &zErrMsg);
  }
#ifdef SQLITE_ENABLE_OSINST
  /* If this is not a temporary or ":memory:" database, create an osinst
  ** VFS to use. */
  assert( db->pVfs );
  if( rc==SQLITE_OK && zOpen && zOpen[0] && strcmp(":memory:", zOpen) ){
    u32 iVal = 0;
    char *zLog = 0;
    sqlite3_randomness(sizeof(iVal), (void*)&iVal);
    zLog = sqlite3_mprintf("%s-osinst-%08x", zOpen, iVal);
    if( zLog==0 ){
      rc = SQLITE_NOMEM_BKPT;
    }else{
      sqlite3_vfs *pVfs = 0;
      rc = sqlite3_vfslog_new(zLog, db->pVfs->zName, zLog, &pVfs);
      sqlite3_free(zLog);
      db->pOsinstVfs = db->pVfs = pVfs;
    }
  }
#endif
  if( rc!=SQLITE_OK ){
    if( rc==SQLITE_NOMEM ) sqlite3OomFault(db);
    sqlite3ErrorWithMsg(db, rc, zErrMsg ? "%s" : 0, zErrMsg);
    sqlite3_free(zErrMsg);
    goto opendb_out;
  }


  /* Open the backend database driver */
  rc = sqlite3BtreeOpen(db->pVfs, zOpen, db, &db->aDb[0].pBt, 0,
                        flags | SQLITE_OPEN_MAIN_DB);
  if( rc!=SQLITE_OK ){
    if( rc==SQLITE_IOERR_NOMEM ){
      rc = SQLITE_NOMEM_BKPT;

Changes to src/sqliteInt.h.

11
12
13
14
15
16
17


18
19
20
21
22
23
24
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26







+
+







*************************************************************************
** Internal interface definitions for SQLite.
**
*/
#ifndef SQLITEINT_H
#define SQLITEINT_H

#define SQLITE_ENABLE_OSINST 1

/* Special Comments:
**
** Some comments have special meaning to the tools that measure test
** coverage:
**
**    NO_TEST                     - The branches on this line are not
**                                  measured by branch coverage.  This is
1483
1484
1485
1486
1487
1488
1489



1490
1491
1492
1493
1494
1495
1496
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501







+
+
+







  void *pUnlockArg;                     /* Argument to xUnlockNotify */
  void (*xUnlockNotify)(void **, int);  /* Unlock notify callback */
  sqlite3 *pNextBlocked;        /* Next in list of all blocked connections */
#endif
#ifdef SQLITE_USER_AUTHENTICATION
  sqlite3_userauth auth;        /* User authentication information */
#endif
#ifdef SQLITE_ENABLE_OSINST
  sqlite3_vfs *pOsinstVfs;      /* osinst VFS to finalize, if any */
#endif
};

/*
** A macro to discover the encoding of a database.
*/
#define SCHEMA_ENC(db) ((db)->aDb[0].pSchema->enc)
#define ENC(db)        ((db)->enc)

Changes to src/test_osinst.c.

58
59
60
61
62
63
64

65
66
67
68
69
70
71
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72







+







**       CREATE VIRTUAL TABLE v USING vfslog('vfs.log');
**
**   creates a virtual table with 6 columns, as follows:
**
**       CREATE TABLE v(
**         event    TEXT,             // "xOpen", "xRead" etc.
**         file     TEXT,             // Name of file this call applies to
**         time     INTEGER,          // Timestamp
**         clicks   INTEGER,          // Time spent in call
**         rc       INTEGER,          // Return value
**         size     INTEGER,          // Bytes read or written
**         offset   INTEGER           // File offset read or written
**       );
*/

243
244
245
246
247
248
249
250


251
252
253
254
255
256
257

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
327

328
329
330
331
332


333
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


456
457
458
459

460
461
462
463
464


465
466
467
468

469
470
471
472
473


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
244
245
246
247
248
249
250

251
252
253
254
255
256
257
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
327
328

329
330
331
332


333
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


456
457
458
459
460

461
462
463
464


465
466
467
468
469

470
471
472
473


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







-
+
+






-
+







-
-
+
+













-
+



-
-
+
+













-
+



-
-
+
+








-
+



-
-
+
+








-
+



-
-
+
+








-
+



-
-
+
+








-
+



-
-
+
+








-
+



-
-
+
+








-
+



-
-
+
+




















-
+



-
-
+
+








-
+



-
-
+
+





-
+



-
-
+
+










-
+



-
-
+
+



-
+



-
-
+
+



-
+



-
-
+
+















-
+










-
+

-
+











-
+


-
-
+
+















-
+


-
-
+
+







}
#else
static sqlite3_uint64 vfslog_time(){
  return 0;
}
#endif

static void vfslog_call(sqlite3_vfs *, int, int, sqlite3_int64, int, int, int);
static void vfslog_call(
sqlite3_vfs *, int, int, sqlite3_uint64, sqlite3_int64, int, int, sqlite_int64);
static void vfslog_string(sqlite3_vfs *, const char *);

/*
** Close an vfslog-file.
*/
static int vfslogClose(sqlite3_file *pFile){
  sqlite3_uint64 t;
  sqlite3_uint64 t, t2;
  int rc = SQLITE_OK;
  VfslogFile *p = (VfslogFile *)pFile;

  t = vfslog_time();
  if( p->pReal->pMethods ){
    rc = p->pReal->pMethods->xClose(p->pReal);
  }
  t = vfslog_time() - t;
  vfslog_call(p->pVfslog, OS_CLOSE, p->iFileId, t, rc, 0, 0);
  t2 = vfslog_time() - t;
  vfslog_call(p->pVfslog, OS_CLOSE, p->iFileId, t, t2, rc, 0, 0);
  return rc;
}

/*
** Read data from an vfslog-file.
*/
static int vfslogRead(
  sqlite3_file *pFile, 
  void *zBuf, 
  int iAmt, 
  sqlite_int64 iOfst
){
  int rc;
  sqlite3_uint64 t;
  sqlite3_uint64 t, t2;
  VfslogFile *p = (VfslogFile *)pFile;
  t = vfslog_time();
  rc = p->pReal->pMethods->xRead(p->pReal, zBuf, iAmt, iOfst);
  t = vfslog_time() - t;
  vfslog_call(p->pVfslog, OS_READ, p->iFileId, t, rc, iAmt, (int)iOfst);
  t2 = vfslog_time() - t;
  vfslog_call(p->pVfslog, OS_READ, p->iFileId, t, t2, rc, iAmt, iOfst);
  return rc;
}

/*
** Write data to an vfslog-file.
*/
static int vfslogWrite(
  sqlite3_file *pFile,
  const void *z,
  int iAmt,
  sqlite_int64 iOfst
){
  int rc;
  sqlite3_uint64 t;
  sqlite3_uint64 t, t2;
  VfslogFile *p = (VfslogFile *)pFile;
  t = vfslog_time();
  rc = p->pReal->pMethods->xWrite(p->pReal, z, iAmt, iOfst);
  t = vfslog_time() - t;
  vfslog_call(p->pVfslog, OS_WRITE, p->iFileId, t, rc, iAmt, (int)iOfst);
  t2 = vfslog_time() - t;
  vfslog_call(p->pVfslog, OS_WRITE, p->iFileId, t, t2, rc, iAmt, iOfst);
  return rc;
}

/*
** Truncate an vfslog-file.
*/
static int vfslogTruncate(sqlite3_file *pFile, sqlite_int64 size){
  int rc;
  sqlite3_uint64 t;
  sqlite3_uint64 t, t2;
  VfslogFile *p = (VfslogFile *)pFile;
  t = vfslog_time();
  rc = p->pReal->pMethods->xTruncate(p->pReal, size);
  t = vfslog_time() - t;
  vfslog_call(p->pVfslog, OS_TRUNCATE, p->iFileId, t, rc, 0, (int)size);
  t2 = vfslog_time() - t;
  vfslog_call(p->pVfslog, OS_TRUNCATE, p->iFileId, t, t2, rc, 0, size);
  return rc;
}

/*
** Sync an vfslog-file.
*/
static int vfslogSync(sqlite3_file *pFile, int flags){
  int rc;
  sqlite3_uint64 t;
  sqlite3_uint64 t, t2;
  VfslogFile *p = (VfslogFile *)pFile;
  t = vfslog_time();
  rc = p->pReal->pMethods->xSync(p->pReal, flags);
  t = vfslog_time() - t;
  vfslog_call(p->pVfslog, OS_SYNC, p->iFileId, t, rc, flags, 0);
  t2 = vfslog_time() - t;
  vfslog_call(p->pVfslog, OS_SYNC, p->iFileId, t, t2, rc, flags, 0);
  return rc;
}

/*
** Return the current file-size of an vfslog-file.
*/
static int vfslogFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){
  int rc;
  sqlite3_uint64 t;
  sqlite3_uint64 t, t2;
  VfslogFile *p = (VfslogFile *)pFile;
  t = vfslog_time();
  rc = p->pReal->pMethods->xFileSize(p->pReal, pSize);
  t = vfslog_time() - t;
  vfslog_call(p->pVfslog, OS_FILESIZE, p->iFileId, t, rc, 0, (int)*pSize);
  t2 = vfslog_time() - t;
  vfslog_call(p->pVfslog, OS_FILESIZE, p->iFileId, t, t2, rc, 0, *pSize);
  return rc;
}

/*
** Lock an vfslog-file.
*/
static int vfslogLock(sqlite3_file *pFile, int eLock){
  int rc;
  sqlite3_uint64 t;
  sqlite3_uint64 t, t2;
  VfslogFile *p = (VfslogFile *)pFile;
  t = vfslog_time();
  rc = p->pReal->pMethods->xLock(p->pReal, eLock);
  t = vfslog_time() - t;
  vfslog_call(p->pVfslog, OS_LOCK, p->iFileId, t, rc, eLock, 0);
  t2 = vfslog_time() - t;
  vfslog_call(p->pVfslog, OS_LOCK, p->iFileId, t, t2, rc, eLock, 0);
  return rc;
}

/*
** Unlock an vfslog-file.
*/
static int vfslogUnlock(sqlite3_file *pFile, int eLock){
  int rc;
  sqlite3_uint64 t;
  sqlite3_uint64 t, t2;
  VfslogFile *p = (VfslogFile *)pFile;
  t = vfslog_time();
  rc = p->pReal->pMethods->xUnlock(p->pReal, eLock);
  t = vfslog_time() - t;
  vfslog_call(p->pVfslog, OS_UNLOCK, p->iFileId, t, rc, eLock, 0);
  t2 = vfslog_time() - t;
  vfslog_call(p->pVfslog, OS_UNLOCK, p->iFileId, t, t2, rc, eLock, 0);
  return rc;
}

/*
** Check if another file-handle holds a RESERVED lock on an vfslog-file.
*/
static int vfslogCheckReservedLock(sqlite3_file *pFile, int *pResOut){
  int rc;
  sqlite3_uint64 t;
  sqlite3_uint64 t, t2;
  VfslogFile *p = (VfslogFile *)pFile;
  t = vfslog_time();
  rc = p->pReal->pMethods->xCheckReservedLock(p->pReal, pResOut);
  t = vfslog_time() - t;
  vfslog_call(p->pVfslog, OS_CHECKRESERVEDLOCK, p->iFileId, t, rc, *pResOut, 0);
  t2 = vfslog_time() - t;
  vfslog_call(p->pVfslog, OS_CHECKRESERVEDLOCK, p->iFileId, t,t2,rc,*pResOut,0);
  return rc;
}

/*
** File control method. For custom operations on an vfslog-file.
*/
static int vfslogFileControl(sqlite3_file *pFile, int op, void *pArg){
  VfslogFile *p = (VfslogFile *)pFile;
  int rc = p->pReal->pMethods->xFileControl(p->pReal, op, pArg);
  if( op==SQLITE_FCNTL_VFSNAME && rc==SQLITE_OK ){
    *(char**)pArg = sqlite3_mprintf("vfslog/%z", *(char**)pArg);
  }
  return rc;
}

/*
** Return the sector-size in bytes for an vfslog-file.
*/
static int vfslogSectorSize(sqlite3_file *pFile){
  int rc;
  sqlite3_uint64 t;
  sqlite3_uint64 t, t2;
  VfslogFile *p = (VfslogFile *)pFile;
  t = vfslog_time();
  rc = p->pReal->pMethods->xSectorSize(p->pReal);
  t = vfslog_time() - t;
  vfslog_call(p->pVfslog, OS_SECTORSIZE, p->iFileId, t, rc, 0, 0);
  t2 = vfslog_time() - t;
  vfslog_call(p->pVfslog, OS_SECTORSIZE, p->iFileId, t, t2, rc, 0, 0);
  return rc;
}

/*
** Return the device characteristic flags supported by an vfslog-file.
*/
static int vfslogDeviceCharacteristics(sqlite3_file *pFile){
  int rc;
  sqlite3_uint64 t;
  sqlite3_uint64 t, t2;
  VfslogFile *p = (VfslogFile *)pFile;
  t = vfslog_time();
  rc = p->pReal->pMethods->xDeviceCharacteristics(p->pReal);
  t = vfslog_time() - t;
  vfslog_call(p->pVfslog, OS_DEVCHAR, p->iFileId, t, rc, 0, 0);
  t2 = vfslog_time() - t;
  vfslog_call(p->pVfslog, OS_DEVCHAR, p->iFileId, t, t2, rc, 0, 0);
  return rc;
}

static int vfslogShmLock(sqlite3_file *pFile, int ofst, int n, int flags){
  int rc;
  sqlite3_uint64 t;
  sqlite3_uint64 t, t2;
  VfslogFile *p = (VfslogFile *)pFile;
  t = vfslog_time();
  rc = p->pReal->pMethods->xShmLock(p->pReal, ofst, n, flags);
  t = vfslog_time() - t;
  vfslog_call(p->pVfslog, OS_SHMLOCK, p->iFileId, t, rc, 0, 0);
  t2 = vfslog_time() - t;
  vfslog_call(p->pVfslog, OS_SHMLOCK, p->iFileId, t, t2, rc, 0, 0);
  return rc;
}
static int vfslogShmMap(
  sqlite3_file *pFile, 
  int iRegion, 
  int szRegion, 
  int isWrite, 
  volatile void **pp
){
  int rc;
  sqlite3_uint64 t;
  sqlite3_uint64 t, t2;
  VfslogFile *p = (VfslogFile *)pFile;
  t = vfslog_time();
  rc = p->pReal->pMethods->xShmMap(p->pReal, iRegion, szRegion, isWrite, pp);
  t = vfslog_time() - t;
  vfslog_call(p->pVfslog, OS_SHMMAP, p->iFileId, t, rc, 0, 0);
  t2 = vfslog_time() - t;
  vfslog_call(p->pVfslog, OS_SHMMAP, p->iFileId, t, t2, rc, 0, 0);
  return rc;
}
static void vfslogShmBarrier(sqlite3_file *pFile){
  sqlite3_uint64 t;
  sqlite3_uint64 t, t2;
  VfslogFile *p = (VfslogFile *)pFile;
  t = vfslog_time();
  p->pReal->pMethods->xShmBarrier(p->pReal);
  t = vfslog_time() - t;
  vfslog_call(p->pVfslog, OS_SHMBARRIER, p->iFileId, t, SQLITE_OK, 0, 0);
  t2 = vfslog_time() - t;
  vfslog_call(p->pVfslog, OS_SHMBARRIER, p->iFileId, t, t2, SQLITE_OK, 0, 0);
}
static int vfslogShmUnmap(sqlite3_file *pFile, int deleteFlag){
  int rc;
  sqlite3_uint64 t;
  sqlite3_uint64 t, t2;
  VfslogFile *p = (VfslogFile *)pFile;
  t = vfslog_time();
  rc = p->pReal->pMethods->xShmUnmap(p->pReal, deleteFlag);
  t = vfslog_time() - t;
  vfslog_call(p->pVfslog, OS_SHMUNMAP, p->iFileId, t, rc, 0, 0);
  t2 = vfslog_time() - t;
  vfslog_call(p->pVfslog, OS_SHMUNMAP, p->iFileId, t, t2, rc, 0, 0);
  return rc;
}


/*
** Open an vfslog file handle.
*/
static int vfslogOpen(
  sqlite3_vfs *pVfs,
  const char *zName,
  sqlite3_file *pFile,
  int flags,
  int *pOutFlags
){
  int rc;
  sqlite3_uint64 t;
  sqlite3_uint64 t, t2;
  VfslogFile *p = (VfslogFile *)pFile;
  VfslogVfs *pLog = (VfslogVfs *)pVfs;

  pFile->pMethods = &vfslog_io_methods;
  p->pReal = (sqlite3_file *)&p[1];
  p->pVfslog = pVfs;
  p->iFileId = ++pLog->iNextFileId;

  t = vfslog_time();
  rc = REALVFS(pVfs)->xOpen(REALVFS(pVfs), zName, p->pReal, flags, pOutFlags);
  t = vfslog_time() - t;
  t2 = vfslog_time() - t;

  vfslog_call(pVfs, OS_OPEN, p->iFileId, t, rc, 0, 0);
  vfslog_call(pVfs, OS_OPEN, p->iFileId, t, t2, rc, 0, 0);
  vfslog_string(pVfs, zName);
  return rc;
}

/*
** Delete the file located at zPath. If the dirSync argument is true,
** ensure the file-system modifications are synced to disk before
** returning.
*/
static int vfslogDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){
  int rc;
  sqlite3_uint64 t;
  sqlite3_uint64 t, t2;
  t = vfslog_time();
  rc = REALVFS(pVfs)->xDelete(REALVFS(pVfs), zPath, dirSync);
  t = vfslog_time() - t;
  vfslog_call(pVfs, OS_DELETE, 0, t, rc, dirSync, 0);
  t2 = vfslog_time() - t;
  vfslog_call(pVfs, OS_DELETE, 0, t, t2, rc, dirSync, 0);
  vfslog_string(pVfs, zPath);
  return rc;
}

/*
** Test for access permissions. Return true if the requested permission
** is available, or false otherwise.
*/
static int vfslogAccess(
  sqlite3_vfs *pVfs, 
  const char *zPath, 
  int flags, 
  int *pResOut
){
  int rc;
  sqlite3_uint64 t;
  sqlite3_uint64 t, t2;
  t = vfslog_time();
  rc = REALVFS(pVfs)->xAccess(REALVFS(pVfs), zPath, flags, pResOut);
  t = vfslog_time() - t;
  vfslog_call(pVfs, OS_ACCESS, 0, t, rc, flags, *pResOut);
  t2 = vfslog_time() - t;
  vfslog_call(pVfs, OS_ACCESS, 0, t, t2, rc, flags, (sqlite3_int64)*pResOut);
  vfslog_string(pVfs, zPath);
  return rc;
}

/*
** Populate buffer zOut with the full canonical pathname corresponding
** to the pathname in zPath. zOut is guaranteed to point to a buffer
638
639
640
641
642
643
644
645

646
647
648
649
650
651







652
653
654
655

656
657
658
659

660
661
662
663

664
665
666
667
668
669
670
671
672
673









674
675
676
677
678
679
680
681
682
683
684

685
686
687
688
689
690
691
640
641
642
643
644
645
646

647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668

669
670
671
672

673
674
675
676







677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695

696
697
698
699
700
701
702
703







-
+






+
+
+
+
+
+
+




+



-
+



-
+



-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+










-
+







#ifdef SQLITE_TEST
  sqlite3_io_error_pending = pending;
  sqlite3_io_error_persist = persist;
  sqlite3_diskfull_pending = diskfull;
#endif
}

static void put32bits(unsigned char *p, unsigned int v){
static void vfslogPut32bits(unsigned char *p, unsigned int v){
  p[0] = v>>24;
  p[1] = (unsigned char)(v>>16);
  p[2] = (unsigned char)(v>>8);
  p[3] = (unsigned char)v;
}

static void vfslogPut64bits(unsigned char *p, sqlite3_int64 v){
  vfslogPut32bits(p, (v >> 32) & 0xFFFFFFFF);
  vfslogPut32bits(&p[4], v & 0xFFFFFFFF);
}

#define VFSLOG_RECORD_SIZE 36

static void vfslog_call(
  sqlite3_vfs *pVfs,
  int eEvent,
  int iFileid,
  sqlite3_uint64 tStamp,
  sqlite3_int64 nClick,
  int return_code,
  int size,
  int offset
  sqlite3_int64 offset
){
  VfslogVfs *p = (VfslogVfs *)pVfs;
  unsigned char *zRec;
  if( (24+p->nBuf)>sizeof(p->aBuf) ){
  if( (VFSLOG_RECORD_SIZE+p->nBuf)>sizeof(p->aBuf) ){
    vfslog_flush(p);
  }
  zRec = (unsigned char *)&p->aBuf[p->nBuf];
  put32bits(&zRec[0], eEvent);
  put32bits(&zRec[4], iFileid);
  put32bits(&zRec[8], (unsigned int)(nClick&0xffff));
  put32bits(&zRec[12], return_code);
  put32bits(&zRec[16], size);
  put32bits(&zRec[20], offset);
  p->nBuf += 24;
  vfslogPut32bits(&zRec[0], eEvent);
  vfslogPut32bits(&zRec[4], iFileid);
  vfslogPut64bits(&zRec[8], (sqlite3_int64)tStamp);
  vfslogPut32bits(&zRec[16], (unsigned int)(nClick&0xffffffff));
  vfslogPut32bits(&zRec[20], return_code);
  vfslogPut32bits(&zRec[24], size);
  vfslogPut64bits(&zRec[28], offset);

  p->nBuf += VFSLOG_RECORD_SIZE;
}

static void vfslog_string(sqlite3_vfs *pVfs, const char *zStr){
  VfslogVfs *p = (VfslogVfs *)pVfs;
  unsigned char *zRec;
  int nStr = zStr ? (int)strlen(zStr) : 0;
  if( (4+nStr+p->nBuf)>sizeof(p->aBuf) ){
    vfslog_flush(p);
  }
  zRec = (unsigned char *)&p->aBuf[p->nBuf];
  put32bits(&zRec[0], nStr);
  vfslogPut32bits(&zRec[0], nStr);
  if( zStr ){
    memcpy(&zRec[4], zStr, nStr);
  }
  p->nBuf += (4 + nStr);
}

static void vfslog_finalize(VfslogVfs *p){
706
707
708
709
710
711
712
713


714
715
716
717
718
719
720
718
719
720
721
722
723
724

725
726
727
728
729
730
731
732
733







-
+
+







  vfslog_finalize((VfslogVfs *)pVfs);
  return SQLITE_OK;
}

int sqlite3_vfslog_new(
  const char *zVfs,               /* New VFS name */
  const char *zParentVfs,         /* Parent VFS name (or NULL) */
  const char *zLog                /* Log file name */
  const char *zLog,               /* Log file name */
  sqlite3_vfs **ppVfs             /* OUT: New VFS object */
){
  VfslogVfs *p;
  sqlite3_vfs *pParent;
  int nByte;
  int flags;
  int rc;
  char *zFile;
743
744
745
746
747
748
749
750


751
752
753
754
755
756
757
758
759

760
761
762
763
764

765
766
767
768
769
770
771
756
757
758
759
760
761
762

763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778

779
780
781
782
783
784
785
786







-
+
+









+




-
+







  flags = SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE|SQLITE_OPEN_MASTER_JOURNAL;
  pParent->xDelete(pParent, zFile, 0);
  rc = pParent->xOpen(pParent, zFile, p->pLog, flags, &flags);
  if( rc==SQLITE_OK ){
    memcpy(p->aBuf, "sqlite_ostrace1.....", 20);
    p->iOffset = 0;
    p->nBuf = 20;
    rc = sqlite3_vfs_register((sqlite3_vfs *)p, 1);
    rc = sqlite3_vfs_register((sqlite3_vfs *)p, 0);
    if( ppVfs ) *ppVfs = (sqlite3_vfs*)p;
  }
  if( rc ){
    vfslog_finalize(p);
  }
  return rc;
}

int sqlite3_vfslog_annotate(const char *zVfs, const char *zMsg){
  sqlite3_vfs *pVfs;
  sqlite3_uint64 t = vfslog_time();
  pVfs = sqlite3_vfs_find(zVfs);
  if( !pVfs || pVfs->xOpen!=vfslogOpen ){
    return SQLITE_ERROR;
  } 
  vfslog_call(pVfs, OS_ANNOTATE, 0, 0, 0, 0, 0);
  vfslog_call(pVfs, OS_ANNOTATE, 0, t, 0, 0, 0, 0);
  vfslog_string(pVfs, zMsg);
  return SQLITE_OK;
}

static const char *vfslog_eventname(int eEvent){
  const char *zEvent = 0;

895
896
897
898
899
900
901
902

903
904
905
906
907
908
909
910
911
912
913
914
915
916

917
918
919
920
921
922
923
924







-
+








  flags = SQLITE_OPEN_READWRITE|SQLITE_OPEN_MASTER_JOURNAL;
  rc = pVfs->xOpen(pVfs, p->zFile, p->pFd, flags, &flags);

  if( rc==SQLITE_OK ){
    p->pFd->pMethods->xFileSize(p->pFd, &p->nByte);
    sqlite3_declare_vtab(db, 
        "CREATE TABLE xxx(event, file, click, rc, size, offset)"
        "CREATE TABLE xxx(event, file, time, click, rc, size, offset)"
    );
    *ppVtab = &p->base;
  }else{
    sqlite3_free(p);
  }

  return rc;
967
968
969
970
971
972
973
974

975
976
977
978
979
980
981
982
983
984
985
986
987
988

989


990
991
992
993
994
995
996
982
983
984
985
986
987
988

989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004

1005
1006
1007
1008
1009
1010
1011
1012
1013







-
+














+
-
+
+







  VfslogVtab *p = (VfslogVtab *)pCursor->pVtab;
  int rc = SQLITE_OK;
  int nRead;

  sqlite3_free(pCsr->zTransient);
  pCsr->zTransient = 0;

  nRead = 24;
  nRead = VFSLOG_RECORD_SIZE;
  if( pCsr->iOffset+nRead<=p->nByte ){
    int eEvent;
    rc = p->pFd->pMethods->xRead(p->pFd, pCsr->aBuf, nRead, pCsr->iOffset);

    eEvent = get32bits(pCsr->aBuf);
    if( (rc==SQLITE_OK)
     && (eEvent==OS_OPEN || eEvent==OS_DELETE || eEvent==OS_ACCESS) 
    ){
      char buf[4];
      rc = p->pFd->pMethods->xRead(p->pFd, buf, 4, pCsr->iOffset+nRead);
      nRead += 4;
      if( rc==SQLITE_OK ){
        int nStr = get32bits((unsigned char *)buf);
        char *zStr = sqlite3_malloc(nStr+1);
        if( nStr>0 ){
        rc = p->pFd->pMethods->xRead(p->pFd, zStr, nStr, pCsr->iOffset+nRead);
          rc = p->pFd->pMethods->xRead(p->pFd, zStr, nStr, pCsr->iOffset+nRead);
        }
        zStr[nStr] = '\0';
        nRead += nStr;

        if( eEvent==OS_OPEN ){
          int iFileid = get32bits(&pCsr->aBuf[4]);
          if( iFileid>=pCsr->nFile ){
            int nNew = sizeof(pCsr->azFile[0])*(iFileid+1);
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045

1046
1047
1048
1049

1050
1051
1052
1053
1054
1055
1056
















1057


1058
1059

1060
1061
1062
1063
1064
1065
1066
1048
1049
1050
1051
1052
1053
1054

1055
1056
1057

1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089

1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101







-



-



+




+







+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
+
+


+







}

static int vlogColumn(
  sqlite3_vtab_cursor *pCursor, 
  sqlite3_context *ctx, 
  int i
){
  unsigned int val;
  VfslogCsr *pCsr = (VfslogCsr *)pCursor;

  assert( i<7 );
  val = get32bits(&pCsr->aBuf[4*i]);

  switch( i ){
    case 0: {
      unsigned int val = get32bits(&pCsr->aBuf[0]);
      sqlite3_result_text(ctx, vfslog_eventname(val), -1, SQLITE_STATIC);
      break;
    }
    case 1: {
      unsigned int val = get32bits(&pCsr->aBuf[4]);
      char *zStr = pCsr->zTransient;
      if( val!=0 && val<(unsigned)pCsr->nFile ){
        zStr = pCsr->azFile[val];
      }
      sqlite3_result_text(ctx, zStr, -1, SQLITE_TRANSIENT);
      break;
    }
    case 2: {
      unsigned int v1 = get32bits(&pCsr->aBuf[8]);
      unsigned int v2 = get32bits(&pCsr->aBuf[12]);
      sqlite3_result_int64(
        ctx,(((sqlite3_int64)v1) << 32) + (sqlite3_int64)v2
      );
      break;
    }
    case 6: {
      unsigned int v1 = get32bits(&pCsr->aBuf[28]);
      unsigned int v2 = get32bits(&pCsr->aBuf[32]);
      sqlite3_result_int64(
        ctx,(((sqlite3_int64)v1) << 32) + (sqlite3_int64)v2
      );
      break;
    }
    default:
    default: {
      unsigned int val = get32bits(&pCsr->aBuf[4*(i+1)]);
      sqlite3_result_int(ctx, val);
      break;
    }
  }

  return SQLITE_OK;
}

static int vlogRowid(sqlite3_vtab_cursor *pCursor, sqlite_int64 *pRowid){
  VfslogCsr *pCsr = (VfslogCsr *)pCursor;
1176
1177
1178
1179
1180
1181
1182
1183

1184
1185
1186
1187

1188
1189
1190
1191
1192
1193
1194
1211
1212
1213
1214
1215
1216
1217

1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230







-
+




+







        Tcl_WrongNumArgs(interp, 2, objv, "VFS PARENT LOGFILE");
        return TCL_ERROR;
      }
      zVfs = Tcl_GetString(objv[2]);
      zParent = Tcl_GetString(objv[3]);
      zLog = Tcl_GetString(objv[4]);
      if( *zParent=='\0' ) zParent = 0;
      rc = sqlite3_vfslog_new(zVfs, zParent, zLog);
      rc = sqlite3_vfslog_new(zVfs, zParent, zLog, 0);
      if( rc!=SQLITE_OK ){
        Tcl_AppendResult(interp, "failed", 0);
        return TCL_ERROR;
      }
      sqlite3_vfs_register(sqlite3_vfs_find(zVfs), 1);
      break;
    };

    case VL_REGISTER: {
      char *zDb;
      if( objc!=3 ){
        Tcl_WrongNumArgs(interp, 2, objv, "DB");

Changes to tool/mksqlite3c.tcl.

399
400
401
402
403
404
405


406
407
408
409
410
411
412
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414







+
+







   fts3_icu.c
   sqlite3rbu.c
   dbstat.c
   dbpage.c
   sqlite3session.c
   fts5.c
   stmt.c

   test_osinst.c
} {
  copy_file tsrc/$file
}

# Synthesize an alternative sqlite3_sourceid() implementation that
# that tries to detects changes in the amalgamation source text
# and modify returns a modified source-id if changes are detected.

Added tool/osinst2sql.c.



























































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
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
/*
******************************************************************************
*/

#include <sqlite3.h>

#include <assert.h>
#include <stdio.h>

int sqlite3_vfslog_register(sqlite3 *db);
 
static int xCallback(void *pUnused, int nArg, char **azArg, char **azName){
  char *zPrint = 0;

  assert( nArg==7 );
  zPrint = sqlite3_mprintf(
      "INSERT INTO osinst VALUES(%Q, %Q, %s, %s, %s, %s, %s);",
      azArg[0], azArg[1], azArg[2], azArg[3], azArg[4], azArg[5], azArg[6]
  );
  printf("%s\n", zPrint);
  sqlite3_free(zPrint);
  return SQLITE_OK;
}

int main(int argc, char **argv){
  sqlite3 *db = 0;
  int i;

  sqlite3_open("", &db);
  sqlite3_vfslog_register(db);

  printf("BEGIN;\n");
  printf("CREATE TABLE IF NOT EXISTS osinst(\n");
  printf("    event    TEXT,      -- xOpen, xRead etc.\n");
  printf("    file     TEXT,      -- Name of file this call applies to\n");
  printf("    time     INTEGER,   -- Timestamp\n");
  printf("    clicks   INTEGER,   -- Time spent in call\n");
  printf("    rc       INTEGER,   -- Return value\n");
  printf("    size     INTEGER,   -- Bytes read or written\n");
  printf("    offset   INTEGER    -- File offset read or written\n");
  printf(");\n");

  for(i=1; i<argc; i++){
    char *zSql = 0;
    sqlite3_exec(db, "DROP TABLE IF EXISTS osinst;", 0, 0, 0);
    zSql = sqlite3_mprintf(
        "CREATE VIRTUAL TABLE osinst USING vfslog(%Q)", argv[i]
    );
    sqlite3_exec(db, zSql, 0, 0, 0);
    sqlite3_free(zSql);

    sqlite3_exec(db, "SELECT * FROM osinst", xCallback, 0, 0);
  }

  printf("COMMIT;\n");
  sqlite3_close(db);
  return 0;
}