1/*
2** 2010 July 12
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 an implementation of the "dbstat" virtual table.
14**
15** The dbstat virtual table is used to extract low-level storage
16** information from an SQLite database in order to implement the
17** "sqlite3_analyzer" utility. See the ../tool/spaceanal.tcl script
18** for an example implementation.
19**
20** Additional information is available on the "dbstat.html" page of the
21** official SQLite documentation.
22*/
23
24#include "sqliteInt.h" /* Requires access to internal data structures */
25#if (defined(SQLITE_ENABLE_DBSTAT_VTAB) || defined(SQLITE_TEST)) \
26 && !defined(SQLITE_OMIT_VIRTUALTABLE)
27
28/*
29** The pager and btree modules arrange objects in memory so that there are
30** always approximately 200 bytes of addressable memory following each page
31** buffer. This way small buffer overreads caused by corrupt database pages
32** do not cause undefined behaviour. This module pads each page buffer
33** by the following number of bytes for the same purpose.
34*/
35#define DBSTAT_PAGE_PADDING_BYTES 256
36
37/*
38** Page paths:
39**
40** The value of the 'path' column describes the path taken from the
41** root-node of the b-tree structure to each page. The value of the
42** root-node path is '/'.
43**
44** The value of the path for the left-most child page of the root of
45** a b-tree is '/000/'. (Btrees store content ordered from left to right
46** so the pages to the left have smaller keys than the pages to the right.)
47** The next to left-most child of the root page is
48** '/001', and so on, each sibling page identified by a 3-digit hex
49** value. The children of the 451st left-most sibling have paths such
50** as '/1c2/000/, '/1c2/001/' etc.
51**
52** Overflow pages are specified by appending a '+' character and a
53** six-digit hexadecimal value to the path to the cell they are linked
54** from. For example, the three overflow pages in a chain linked from
55** the left-most cell of the 450th child of the root page are identified
56** by the paths:
57**
58** '/1c2/000+000000' // First page in overflow chain
59** '/1c2/000+000001' // Second page in overflow chain
60** '/1c2/000+000002' // Third page in overflow chain
61**
62** If the paths are sorted using the BINARY collation sequence, then
63** the overflow pages associated with a cell will appear earlier in the
64** sort-order than its child page:
65**
66** '/1c2/000/' // Left-most child of 451st child of root
67*/
68static const char zDbstatSchema[] =
69 "CREATE TABLE x("
70 " name TEXT," /* 0 Name of table or index */
71 " path TEXT," /* 1 Path to page from root (NULL for agg) */
72 " pageno INTEGER," /* 2 Page number (page count for aggregates) */
73 " pagetype TEXT," /* 3 'internal', 'leaf', 'overflow', or NULL */
74 " ncell INTEGER," /* 4 Cells on page (0 for overflow) */
75 " payload INTEGER," /* 5 Bytes of payload on this page */
76 " unused INTEGER," /* 6 Bytes of unused space on this page */
77 " mx_payload INTEGER," /* 7 Largest payload size of all cells */
78 " pgoffset INTEGER," /* 8 Offset of page in file (NULL for agg) */
79 " pgsize INTEGER," /* 9 Size of the page (sum for aggregate) */
80 " schema TEXT HIDDEN," /* 10 Database schema being analyzed */
81 " aggregate BOOLEAN HIDDEN" /* 11 aggregate info for each table */
82 ")"
83;
84
85/* Forward reference to data structured used in this module */
86typedef struct StatTable StatTable;
87typedef struct StatCursor StatCursor;
88typedef struct StatPage StatPage;
89typedef struct StatCell StatCell;
90
91/* Size information for a single cell within a btree page */
92struct StatCell {
93 int nLocal; /* Bytes of local payload */
94 u32 iChildPg; /* Child node (or 0 if this is a leaf) */
95 int nOvfl; /* Entries in aOvfl[] */
96 u32 *aOvfl; /* Array of overflow page numbers */
97 int nLastOvfl; /* Bytes of payload on final overflow page */
98 int iOvfl; /* Iterates through aOvfl[] */
99};
100
101/* Size information for a single btree page */
102struct StatPage {
103 u32 iPgno; /* Page number */
104 u8 *aPg; /* Page buffer from sqlite3_malloc() */
105 int iCell; /* Current cell */
106 char *zPath; /* Path to this page */
107
108 /* Variables populated by statDecodePage(): */
109 u8 flags; /* Copy of flags byte */
110 int nCell; /* Number of cells on page */
111 int nUnused; /* Number of unused bytes on page */
112 StatCell *aCell; /* Array of parsed cells */
113 u32 iRightChildPg; /* Right-child page number (or 0) */
114 int nMxPayload; /* Largest payload of any cell on the page */
115};
116
117/* The cursor for scanning the dbstat virtual table */
118struct StatCursor {
119 sqlite3_vtab_cursor base; /* base class. MUST BE FIRST! */
120 sqlite3_stmt *pStmt; /* Iterates through set of root pages */
121 u8 isEof; /* After pStmt has returned SQLITE_DONE */
122 u8 isAgg; /* Aggregate results for each table */
123 int iDb; /* Schema used for this query */
124
125 StatPage aPage[32]; /* Pages in path to current page */
126 int iPage; /* Current entry in aPage[] */
127
128 /* Values to return. */
129 u32 iPageno; /* Value of 'pageno' column */
130 char *zName; /* Value of 'name' column */
131 char *zPath; /* Value of 'path' column */
132 char *zPagetype; /* Value of 'pagetype' column */
133 int nPage; /* Number of pages in current btree */
134 int nCell; /* Value of 'ncell' column */
135 int nMxPayload; /* Value of 'mx_payload' column */
136 i64 nUnused; /* Value of 'unused' column */
137 i64 nPayload; /* Value of 'payload' column */
138 i64 iOffset; /* Value of 'pgOffset' column */
139 i64 szPage; /* Value of 'pgSize' column */
140};
141
142/* An instance of the DBSTAT virtual table */
143struct StatTable {
144 sqlite3_vtab base; /* base class. MUST BE FIRST! */
145 sqlite3 *db; /* Database connection that owns this vtab */
146 int iDb; /* Index of database to analyze */
147};
148
149#ifndef get2byte
150# define get2byte(x) ((x)[0]<<8 | (x)[1])
151#endif
152
153/*
154** Connect to or create a new DBSTAT virtual table.
155*/
156static int statConnect(
157 sqlite3 *db,
158 void *pAux,
159 int argc, const char *const*argv,
160 sqlite3_vtab **ppVtab,
161 char **pzErr
162){
163 StatTable *pTab = 0;
164 int rc = SQLITE_OK;
165 int iDb;
166
167 if( argc>=4 ){
168 Token nm;
169 sqlite3TokenInit(&nm, (char*)argv[3]);
170 iDb = sqlite3FindDb(db, &nm);
171 if( iDb<0 ){
172 *pzErr = sqlite3_mprintf("no such database: %s", argv[3]);
173 return SQLITE_ERROR;
174 }
175 }else{
176 iDb = 0;
177 }
178 sqlite3_vtab_config(db, SQLITE_VTAB_DIRECTONLY);
179 rc = sqlite3_declare_vtab(db, zDbstatSchema);
180 if( rc==SQLITE_OK ){
181 pTab = (StatTable *)sqlite3_malloc64(sizeof(StatTable));
182 if( pTab==0 ) rc = SQLITE_NOMEM_BKPT;
183 }
184
185 assert( rc==SQLITE_OK || pTab==0 );
186 if( rc==SQLITE_OK ){
187 memset(pTab, 0, sizeof(StatTable));
188 pTab->db = db;
189 pTab->iDb = iDb;
190 }
191
192 *ppVtab = (sqlite3_vtab*)pTab;
193 return rc;
194}
195
196/*
197** Disconnect from or destroy the DBSTAT virtual table.
198*/
199static int statDisconnect(sqlite3_vtab *pVtab){
200 sqlite3_free(pVtab);
201 return SQLITE_OK;
202}
203
204/*
205** Compute the best query strategy and return the result in idxNum.
206**
207** idxNum-Bit Meaning
208** ---------- ----------------------------------------------
209** 0x01 There is a schema=? term in the WHERE clause
210** 0x02 There is a name=? term in the WHERE clause
211** 0x04 There is an aggregate=? term in the WHERE clause
212** 0x08 Output should be ordered by name and path
213*/
214static int statBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo){
215 int i;
216 int iSchema = -1;
217 int iName = -1;
218 int iAgg = -1;
219
220 /* Look for a valid schema=? constraint. If found, change the idxNum to
221 ** 1 and request the value of that constraint be sent to xFilter. And
222 ** lower the cost estimate to encourage the constrained version to be
223 ** used.
224 */
225 for(i=0; i<pIdxInfo->nConstraint; i++){
226 if( pIdxInfo->aConstraint[i].op!=SQLITE_INDEX_CONSTRAINT_EQ ) continue;
227 if( pIdxInfo->aConstraint[i].usable==0 ){
228 /* Force DBSTAT table should always be the right-most table in a join */
229 return SQLITE_CONSTRAINT;
230 }
231 switch( pIdxInfo->aConstraint[i].iColumn ){
232 case 0: { /* name */
233 iName = i;
234 break;
235 }
236 case 10: { /* schema */
237 iSchema = i;
238 break;
239 }
240 case 11: { /* aggregate */
241 iAgg = i;
242 break;
243 }
244 }
245 }
246 i = 0;
247 if( iSchema>=0 ){
248 pIdxInfo->aConstraintUsage[iSchema].argvIndex = ++i;
249 pIdxInfo->aConstraintUsage[iSchema].omit = 1;
250 pIdxInfo->idxNum |= 0x01;
251 }
252 if( iName>=0 ){
253 pIdxInfo->aConstraintUsage[iName].argvIndex = ++i;
254 pIdxInfo->idxNum |= 0x02;
255 }
256 if( iAgg>=0 ){
257 pIdxInfo->aConstraintUsage[iAgg].argvIndex = ++i;
258 pIdxInfo->idxNum |= 0x04;
259 }
260 pIdxInfo->estimatedCost = 1.0;
261
262 /* Records are always returned in ascending order of (name, path).
263 ** If this will satisfy the client, set the orderByConsumed flag so that
264 ** SQLite does not do an external sort.
265 */
266 if( ( pIdxInfo->nOrderBy==1
267 && pIdxInfo->aOrderBy[0].iColumn==0
268 && pIdxInfo->aOrderBy[0].desc==0
269 ) ||
270 ( pIdxInfo->nOrderBy==2
271 && pIdxInfo->aOrderBy[0].iColumn==0
272 && pIdxInfo->aOrderBy[0].desc==0
273 && pIdxInfo->aOrderBy[1].iColumn==1
274 && pIdxInfo->aOrderBy[1].desc==0
275 )
276 ){
277 pIdxInfo->orderByConsumed = 1;
278 pIdxInfo->idxNum |= 0x08;
279 }
280
281 return SQLITE_OK;
282}
283
284/*
285** Open a new DBSTAT cursor.
286*/
287static int statOpen(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor){
288 StatTable *pTab = (StatTable *)pVTab;
289 StatCursor *pCsr;
290
291 pCsr = (StatCursor *)sqlite3_malloc64(sizeof(StatCursor));
292 if( pCsr==0 ){
293 return SQLITE_NOMEM_BKPT;
294 }else{
295 memset(pCsr, 0, sizeof(StatCursor));
296 pCsr->base.pVtab = pVTab;
297 pCsr->iDb = pTab->iDb;
298 }
299
300 *ppCursor = (sqlite3_vtab_cursor *)pCsr;
301 return SQLITE_OK;
302}
303
304static void statClearCells(StatPage *p){
305 int i;
306 if( p->aCell ){
307 for(i=0; i<p->nCell; i++){
308 sqlite3_free(p->aCell[i].aOvfl);
309 }
310 sqlite3_free(p->aCell);
311 }
312 p->nCell = 0;
313 p->aCell = 0;
314}
315
316static void statClearPage(StatPage *p){
317 u8 *aPg = p->aPg;
318 statClearCells(p);
319 sqlite3_free(p->zPath);
320 memset(p, 0, sizeof(StatPage));
321 p->aPg = aPg;
322}
323
324static void statResetCsr(StatCursor *pCsr){
325 int i;
326 /* In some circumstances, specifically if an OOM has occurred, the call
327 ** to sqlite3_reset() may cause the pager to be reset (emptied). It is
328 ** important that statClearPage() is called to free any page refs before
329 ** this happens. dbsqlfuzz 9ed3e4e3816219d3509d711636c38542bf3f40b1. */
330 for(i=0; i<ArraySize(pCsr->aPage); i++){
331 statClearPage(&pCsr->aPage[i]);
332 sqlite3_free(pCsr->aPage[i].aPg);
333 pCsr->aPage[i].aPg = 0;
334 }
335 sqlite3_reset(pCsr->pStmt);
336 pCsr->iPage = 0;
337 sqlite3_free(pCsr->zPath);
338 pCsr->zPath = 0;
339 pCsr->isEof = 0;
340}
341
342/* Resize the space-used counters inside of the cursor */
343static void statResetCounts(StatCursor *pCsr){
344 pCsr->nCell = 0;
345 pCsr->nMxPayload = 0;
346 pCsr->nUnused = 0;
347 pCsr->nPayload = 0;
348 pCsr->szPage = 0;
349 pCsr->nPage = 0;
350}
351
352/*
353** Close a DBSTAT cursor.
354*/
355static int statClose(sqlite3_vtab_cursor *pCursor){
356 StatCursor *pCsr = (StatCursor *)pCursor;
357 statResetCsr(pCsr);
358 sqlite3_finalize(pCsr->pStmt);
359 sqlite3_free(pCsr);
360 return SQLITE_OK;
361}
362
363/*
364** For a single cell on a btree page, compute the number of bytes of
365** content (payload) stored on that page. That is to say, compute the
366** number of bytes of content not found on overflow pages.
367*/
368static int getLocalPayload(
369 int nUsable, /* Usable bytes per page */
370 u8 flags, /* Page flags */
371 int nTotal /* Total record (payload) size */
372){
373 int nLocal;
374 int nMinLocal;
375 int nMaxLocal;
376
377 if( flags==0x0D ){ /* Table leaf node */
378 nMinLocal = (nUsable - 12) * 32 / 255 - 23;
379 nMaxLocal = nUsable - 35;
380 }else{ /* Index interior and leaf nodes */
381 nMinLocal = (nUsable - 12) * 32 / 255 - 23;
382 nMaxLocal = (nUsable - 12) * 64 / 255 - 23;
383 }
384
385 nLocal = nMinLocal + (nTotal - nMinLocal) % (nUsable - 4);
386 if( nLocal>nMaxLocal ) nLocal = nMinLocal;
387 return nLocal;
388}
389
390/* Populate the StatPage object with information about the all
391** cells found on the page currently under analysis.
392*/
393static int statDecodePage(Btree *pBt, StatPage *p){
394 int nUnused;
395 int iOff;
396 int nHdr;
397 int isLeaf;
398 int szPage;
399
400 u8 *aData = p->aPg;
401 u8 *aHdr = &aData[p->iPgno==1 ? 100 : 0];
402
403 p->flags = aHdr[0];
404 if( p->flags==0x0A || p->flags==0x0D ){
405 isLeaf = 1;
406 nHdr = 8;
407 }else if( p->flags==0x05 || p->flags==0x02 ){
408 isLeaf = 0;
409 nHdr = 12;
410 }else{
411 goto statPageIsCorrupt;
412 }
413 if( p->iPgno==1 ) nHdr += 100;
414 p->nCell = get2byte(&aHdr[3]);
415 p->nMxPayload = 0;
416 szPage = sqlite3BtreeGetPageSize(pBt);
417
418 nUnused = get2byte(&aHdr[5]) - nHdr - 2*p->nCell;
419 nUnused += (int)aHdr[7];
420 iOff = get2byte(&aHdr[1]);
421 while( iOff ){
422 int iNext;
423 if( iOff>=szPage ) goto statPageIsCorrupt;
424 nUnused += get2byte(&aData[iOff+2]);
425 iNext = get2byte(&aData[iOff]);
426 if( iNext<iOff+4 && iNext>0 ) goto statPageIsCorrupt;
427 iOff = iNext;
428 }
429 p->nUnused = nUnused;
430 p->iRightChildPg = isLeaf ? 0 : sqlite3Get4byte(&aHdr[8]);
431
432 if( p->nCell ){
433 int i; /* Used to iterate through cells */
434 int nUsable; /* Usable bytes per page */
435
436 sqlite3BtreeEnter(pBt);
437 nUsable = szPage - sqlite3BtreeGetReserveNoMutex(pBt);
438 sqlite3BtreeLeave(pBt);
439 p->aCell = sqlite3_malloc64((p->nCell+1) * sizeof(StatCell));
440 if( p->aCell==0 ) return SQLITE_NOMEM_BKPT;
441 memset(p->aCell, 0, (p->nCell+1) * sizeof(StatCell));
442
443 for(i=0; i<p->nCell; i++){
444 StatCell *pCell = &p->aCell[i];
445
446 iOff = get2byte(&aData[nHdr+i*2]);
447 if( iOff<nHdr || iOff>=szPage ) goto statPageIsCorrupt;
448 if( !isLeaf ){
449 pCell->iChildPg = sqlite3Get4byte(&aData[iOff]);
450 iOff += 4;
451 }
452 if( p->flags==0x05 ){
453 /* A table interior node. nPayload==0. */
454 }else{
455 u32 nPayload; /* Bytes of payload total (local+overflow) */
456 int nLocal; /* Bytes of payload stored locally */
457 iOff += getVarint32(&aData[iOff], nPayload);
458 if( p->flags==0x0D ){
459 u64 dummy;
460 iOff += sqlite3GetVarint(&aData[iOff], &dummy);
461 }
462 if( nPayload>(u32)p->nMxPayload ) p->nMxPayload = nPayload;
463 nLocal = getLocalPayload(nUsable, p->flags, nPayload);
464 if( nLocal<0 ) goto statPageIsCorrupt;
465 pCell->nLocal = nLocal;
466 assert( nPayload>=(u32)nLocal );
467 assert( nLocal<=(nUsable-35) );
468 if( nPayload>(u32)nLocal ){
469 int j;
470 int nOvfl = ((nPayload - nLocal) + nUsable-4 - 1) / (nUsable - 4);
471 if( iOff+nLocal+4>nUsable || nPayload>0x7fffffff ){
472 goto statPageIsCorrupt;
473 }
474 pCell->nLastOvfl = (nPayload-nLocal) - (nOvfl-1) * (nUsable-4);
475 pCell->nOvfl = nOvfl;
476 pCell->aOvfl = sqlite3_malloc64(sizeof(u32)*nOvfl);
477 if( pCell->aOvfl==0 ) return SQLITE_NOMEM_BKPT;
478 pCell->aOvfl[0] = sqlite3Get4byte(&aData[iOff+nLocal]);
479 for(j=1; j<nOvfl; j++){
480 int rc;
481 u32 iPrev = pCell->aOvfl[j-1];
482 DbPage *pPg = 0;
483 rc = sqlite3PagerGet(sqlite3BtreePager(pBt), iPrev, &pPg, 0);
484 if( rc!=SQLITE_OK ){
485 assert( pPg==0 );
486 return rc;
487 }
488 pCell->aOvfl[j] = sqlite3Get4byte(sqlite3PagerGetData(pPg));
489 sqlite3PagerUnref(pPg);
490 }
491 }
492 }
493 }
494 }
495
496 return SQLITE_OK;
497
498statPageIsCorrupt:
499 p->flags = 0;
500 statClearCells(p);
501 return SQLITE_OK;
502}
503
504/*
505** Populate the pCsr->iOffset and pCsr->szPage member variables. Based on
506** the current value of pCsr->iPageno.
507*/
508static void statSizeAndOffset(StatCursor *pCsr){
509 StatTable *pTab = (StatTable *)((sqlite3_vtab_cursor *)pCsr)->pVtab;
510 Btree *pBt = pTab->db->aDb[pTab->iDb].pBt;
511 Pager *pPager = sqlite3BtreePager(pBt);
512 sqlite3_file *fd;
513 sqlite3_int64 x[2];
514
515 /* If connected to a ZIPVFS backend, find the page size and
516 ** offset from ZIPVFS.
517 */
518 fd = sqlite3PagerFile(pPager);
519 x[0] = pCsr->iPageno;
520 if( sqlite3OsFileControl(fd, 230440, &x)==SQLITE_OK ){
521 pCsr->iOffset = x[0];
522 pCsr->szPage += x[1];
523 }else{
524 /* Not ZIPVFS: The default page size and offset */
525 pCsr->szPage += sqlite3BtreeGetPageSize(pBt);
526 pCsr->iOffset = (i64)pCsr->szPage * (pCsr->iPageno - 1);
527 }
528}
529
530/*
531** Load a copy of the page data for page iPg into the buffer belonging
532** to page object pPg. Allocate the buffer if necessary. Return SQLITE_OK
533** if successful, or an SQLite error code otherwise.
534*/
535static int statGetPage(
536 Btree *pBt, /* Load page from this b-tree */
537 u32 iPg, /* Page number to load */
538 StatPage *pPg /* Load page into this object */
539){
540 int pgsz = sqlite3BtreeGetPageSize(pBt);
541 DbPage *pDbPage = 0;
542 int rc;
543
544 if( pPg->aPg==0 ){
545 pPg->aPg = (u8*)sqlite3_malloc(pgsz + DBSTAT_PAGE_PADDING_BYTES);
546 if( pPg->aPg==0 ){
547 return SQLITE_NOMEM_BKPT;
548 }
549 memset(&pPg->aPg[pgsz], 0, DBSTAT_PAGE_PADDING_BYTES);
550 }
551
552 rc = sqlite3PagerGet(sqlite3BtreePager(pBt), iPg, &pDbPage, 0);
553 if( rc==SQLITE_OK ){
554 const u8 *a = sqlite3PagerGetData(pDbPage);
555 memcpy(pPg->aPg, a, pgsz);
556 sqlite3PagerUnref(pDbPage);
557 }
558
559 return rc;
560}
561
562/*
563** Move a DBSTAT cursor to the next entry. Normally, the next
564** entry will be the next page, but in aggregated mode (pCsr->isAgg!=0),
565** the next entry is the next btree.
566*/
567static int statNext(sqlite3_vtab_cursor *pCursor){
568 int rc;
569 int nPayload;
570 char *z;
571 StatCursor *pCsr = (StatCursor *)pCursor;
572 StatTable *pTab = (StatTable *)pCursor->pVtab;
573 Btree *pBt = pTab->db->aDb[pCsr->iDb].pBt;
574 Pager *pPager = sqlite3BtreePager(pBt);
575
576 sqlite3_free(pCsr->zPath);
577 pCsr->zPath = 0;
578
579statNextRestart:
580 if( pCsr->iPage<0 ){
581 /* Start measuring space on the next btree */
582 statResetCounts(pCsr);
583 rc = sqlite3_step(pCsr->pStmt);
584 if( rc==SQLITE_ROW ){
585 int nPage;
586 u32 iRoot = (u32)sqlite3_column_int64(pCsr->pStmt, 1);
587 sqlite3PagerPagecount(pPager, &nPage);
588 if( nPage==0 ){
589 pCsr->isEof = 1;
590 return sqlite3_reset(pCsr->pStmt);
591 }
592 rc = statGetPage(pBt, iRoot, &pCsr->aPage[0]);
593 pCsr->aPage[0].iPgno = iRoot;
594 pCsr->aPage[0].iCell = 0;
595 if( !pCsr->isAgg ){
596 pCsr->aPage[0].zPath = z = sqlite3_mprintf("/");
597 if( z==0 ) rc = SQLITE_NOMEM_BKPT;
598 }
599 pCsr->iPage = 0;
600 pCsr->nPage = 1;
601 }else{
602 pCsr->isEof = 1;
603 return sqlite3_reset(pCsr->pStmt);
604 }
605 }else{
606 /* Continue analyzing the btree previously started */
607 StatPage *p = &pCsr->aPage[pCsr->iPage];
608 if( !pCsr->isAgg ) statResetCounts(pCsr);
609 while( p->iCell<p->nCell ){
610 StatCell *pCell = &p->aCell[p->iCell];
611 while( pCell->iOvfl<pCell->nOvfl ){
612 int nUsable, iOvfl;
613 sqlite3BtreeEnter(pBt);
614 nUsable = sqlite3BtreeGetPageSize(pBt) -
615 sqlite3BtreeGetReserveNoMutex(pBt);
616 sqlite3BtreeLeave(pBt);
617 pCsr->nPage++;
618 statSizeAndOffset(pCsr);
619 if( pCell->iOvfl<pCell->nOvfl-1 ){
620 pCsr->nPayload += nUsable - 4;
621 }else{
622 pCsr->nPayload += pCell->nLastOvfl;
623 pCsr->nUnused += nUsable - 4 - pCell->nLastOvfl;
624 }
625 iOvfl = pCell->iOvfl;
626 pCell->iOvfl++;
627 if( !pCsr->isAgg ){
628 pCsr->zName = (char *)sqlite3_column_text(pCsr->pStmt, 0);
629 pCsr->iPageno = pCell->aOvfl[iOvfl];
630 pCsr->zPagetype = "overflow";
631 pCsr->zPath = z = sqlite3_mprintf(
632 "%s%.3x+%.6x", p->zPath, p->iCell, iOvfl
633 );
634 return z==0 ? SQLITE_NOMEM_BKPT : SQLITE_OK;
635 }
636 }
637 if( p->iRightChildPg ) break;
638 p->iCell++;
639 }
640
641 if( !p->iRightChildPg || p->iCell>p->nCell ){
642 statClearPage(p);
643 pCsr->iPage--;
644 if( pCsr->isAgg && pCsr->iPage<0 ){
645 /* label-statNext-done: When computing aggregate space usage over
646 ** an entire btree, this is the exit point from this function */
647 return SQLITE_OK;
648 }
649 goto statNextRestart; /* Tail recursion */
650 }
651 pCsr->iPage++;
652 if( pCsr->iPage>=ArraySize(pCsr->aPage) ){
653 statResetCsr(pCsr);
654 return SQLITE_CORRUPT_BKPT;
655 }
656 assert( p==&pCsr->aPage[pCsr->iPage-1] );
657
658 if( p->iCell==p->nCell ){
659 p[1].iPgno = p->iRightChildPg;
660 }else{
661 p[1].iPgno = p->aCell[p->iCell].iChildPg;
662 }
663 rc = statGetPage(pBt, p[1].iPgno, &p[1]);
664 pCsr->nPage++;
665 p[1].iCell = 0;
666 if( !pCsr->isAgg ){
667 p[1].zPath = z = sqlite3_mprintf("%s%.3x/", p->zPath, p->iCell);
668 if( z==0 ) rc = SQLITE_NOMEM_BKPT;
669 }
670 p->iCell++;
671 }
672
673
674 /* Populate the StatCursor fields with the values to be returned
675 ** by the xColumn() and xRowid() methods.
676 */
677 if( rc==SQLITE_OK ){
678 int i;
679 StatPage *p = &pCsr->aPage[pCsr->iPage];
680 pCsr->zName = (char *)sqlite3_column_text(pCsr->pStmt, 0);
681 pCsr->iPageno = p->iPgno;
682
683 rc = statDecodePage(pBt, p);
684 if( rc==SQLITE_OK ){
685 statSizeAndOffset(pCsr);
686
687 switch( p->flags ){
688 case 0x05: /* table internal */
689 case 0x02: /* index internal */
690 pCsr->zPagetype = "internal";
691 break;
692 case 0x0D: /* table leaf */
693 case 0x0A: /* index leaf */
694 pCsr->zPagetype = "leaf";
695 break;
696 default:
697 pCsr->zPagetype = "corrupted";
698 break;
699 }
700 pCsr->nCell += p->nCell;
701 pCsr->nUnused += p->nUnused;
702 if( p->nMxPayload>pCsr->nMxPayload ) pCsr->nMxPayload = p->nMxPayload;
703 if( !pCsr->isAgg ){
704 pCsr->zPath = z = sqlite3_mprintf("%s", p->zPath);
705 if( z==0 ) rc = SQLITE_NOMEM_BKPT;
706 }
707 nPayload = 0;
708 for(i=0; i<p->nCell; i++){
709 nPayload += p->aCell[i].nLocal;
710 }
711 pCsr->nPayload += nPayload;
712
713 /* If computing aggregate space usage by btree, continue with the
714 ** next page. The loop will exit via the return at label-statNext-done
715 */
716 if( pCsr->isAgg ) goto statNextRestart;
717 }
718 }
719
720 return rc;
721}
722
723static int statEof(sqlite3_vtab_cursor *pCursor){
724 StatCursor *pCsr = (StatCursor *)pCursor;
725 return pCsr->isEof;
726}
727
728/* Initialize a cursor according to the query plan idxNum using the
729** arguments in argv[0]. See statBestIndex() for a description of the
730** meaning of the bits in idxNum.
731*/
732static int statFilter(
733 sqlite3_vtab_cursor *pCursor,
734 int idxNum, const char *idxStr,
735 int argc, sqlite3_value **argv
736){
737 StatCursor *pCsr = (StatCursor *)pCursor;
738 StatTable *pTab = (StatTable*)(pCursor->pVtab);
739 sqlite3_str *pSql; /* Query of btrees to analyze */
740 char *zSql; /* String value of pSql */
741 int iArg = 0; /* Count of argv[] parameters used so far */
742 int rc = SQLITE_OK; /* Result of this operation */
743 const char *zName = 0; /* Only provide analysis of this table */
744
745 statResetCsr(pCsr);
746 sqlite3_finalize(pCsr->pStmt);
747 pCsr->pStmt = 0;
748 if( idxNum & 0x01 ){
749 /* schema=? constraint is present. Get its value */
750 const char *zDbase = (const char*)sqlite3_value_text(argv[iArg++]);
751 pCsr->iDb = sqlite3FindDbName(pTab->db, zDbase);
752 if( pCsr->iDb<0 ){
753 pCsr->iDb = 0;
754 pCsr->isEof = 1;
755 return SQLITE_OK;
756 }
757 }else{
758 pCsr->iDb = pTab->iDb;
759 }
760 if( idxNum & 0x02 ){
761 /* name=? constraint is present */
762 zName = (const char*)sqlite3_value_text(argv[iArg++]);
763 }
764 if( idxNum & 0x04 ){
765 /* aggregate=? constraint is present */
766 pCsr->isAgg = sqlite3_value_double(argv[iArg++])!=0.0;
767 }else{
768 pCsr->isAgg = 0;
769 }
770 pSql = sqlite3_str_new(pTab->db);
771 sqlite3_str_appendf(pSql,
772 "SELECT * FROM ("
773 "SELECT 'sqlite_schema' AS name,1 AS rootpage,'table' AS type"
774 " UNION ALL "
775 "SELECT name,rootpage,type"
776 " FROM \"%w\".sqlite_schema WHERE rootpage!=0)",
777 pTab->db->aDb[pCsr->iDb].zDbSName);
778 if( zName ){
779 sqlite3_str_appendf(pSql, "WHERE name=%Q", zName);
780 }
781 if( idxNum & 0x08 ){
782 sqlite3_str_appendf(pSql, " ORDER BY name");
783 }
784 zSql = sqlite3_str_finish(pSql);
785 if( zSql==0 ){
786 return SQLITE_NOMEM_BKPT;
787 }else{
788 rc = sqlite3_prepare_v2(pTab->db, zSql, -1, &pCsr->pStmt, 0);
789 sqlite3_free(zSql);
790 }
791
792 if( rc==SQLITE_OK ){
793 pCsr->iPage = -1;
794 rc = statNext(pCursor);
795 }
796 return rc;
797}
798
799static int statColumn(
800 sqlite3_vtab_cursor *pCursor,
801 sqlite3_context *ctx,
802 int i
803){
804 StatCursor *pCsr = (StatCursor *)pCursor;
805 switch( i ){
806 case 0: /* name */
807 sqlite3_result_text(ctx, pCsr->zName, -1, SQLITE_TRANSIENT);
808 break;
809 case 1: /* path */
810 if( !pCsr->isAgg ){
811 sqlite3_result_text(ctx, pCsr->zPath, -1, SQLITE_TRANSIENT);
812 }
813 break;
814 case 2: /* pageno */
815 if( pCsr->isAgg ){
816 sqlite3_result_int64(ctx, pCsr->nPage);
817 }else{
818 sqlite3_result_int64(ctx, pCsr->iPageno);
819 }
820 break;
821 case 3: /* pagetype */
822 if( !pCsr->isAgg ){
823 sqlite3_result_text(ctx, pCsr->zPagetype, -1, SQLITE_STATIC);
824 }
825 break;
826 case 4: /* ncell */
827 sqlite3_result_int(ctx, pCsr->nCell);
828 break;
829 case 5: /* payload */
830 sqlite3_result_int(ctx, pCsr->nPayload);
831 break;
832 case 6: /* unused */
833 sqlite3_result_int(ctx, pCsr->nUnused);
834 break;
835 case 7: /* mx_payload */
836 sqlite3_result_int(ctx, pCsr->nMxPayload);
837 break;
838 case 8: /* pgoffset */
839 if( !pCsr->isAgg ){
840 sqlite3_result_int64(ctx, pCsr->iOffset);
841 }
842 break;
843 case 9: /* pgsize */
844 sqlite3_result_int(ctx, pCsr->szPage);
845 break;
846 case 10: { /* schema */
847 sqlite3 *db = sqlite3_context_db_handle(ctx);
848 int iDb = pCsr->iDb;
849 sqlite3_result_text(ctx, db->aDb[iDb].zDbSName, -1, SQLITE_STATIC);
850 break;
851 }
852 default: { /* aggregate */
853 sqlite3_result_int(ctx, pCsr->isAgg);
854 break;
855 }
856 }
857 return SQLITE_OK;
858}
859
860static int statRowid(sqlite3_vtab_cursor *pCursor, sqlite_int64 *pRowid){
861 StatCursor *pCsr = (StatCursor *)pCursor;
862 *pRowid = pCsr->iPageno;
863 return SQLITE_OK;
864}
865
866/*
867** Invoke this routine to register the "dbstat" virtual table module
868*/
869int sqlite3DbstatRegister(sqlite3 *db){
870 static sqlite3_module dbstat_module = {
871 0, /* iVersion */
872 statConnect, /* xCreate */
873 statConnect, /* xConnect */
874 statBestIndex, /* xBestIndex */
875 statDisconnect, /* xDisconnect */
876 statDisconnect, /* xDestroy */
877 statOpen, /* xOpen - open a cursor */
878 statClose, /* xClose - close a cursor */
879 statFilter, /* xFilter - configure scan constraints */
880 statNext, /* xNext - advance a cursor */
881 statEof, /* xEof - check for end of scan */
882 statColumn, /* xColumn - read data */
883 statRowid, /* xRowid - read data */
884 0, /* xUpdate */
885 0, /* xBegin */
886 0, /* xSync */
887 0, /* xCommit */
888 0, /* xRollback */
889 0, /* xFindMethod */
890 0, /* xRename */
891 0, /* xSavepoint */
892 0, /* xRelease */
893 0, /* xRollbackTo */
894 0 /* xShadowName */
895 };
896 return sqlite3_create_module(db, "dbstat", &dbstat_module, 0);
897}
898#elif defined(SQLITE_ENABLE_DBSTAT_VTAB)
899int sqlite3DbstatRegister(sqlite3 *db){ return SQLITE_OK; }
900#endif /* SQLITE_ENABLE_DBSTAT_VTAB */
901