Index: third_party/sqlite/sqlite-src-3080704/tool/showdb.c |
diff --git a/third_party/sqlite/sqlite-src-3080704/tool/showdb.c b/third_party/sqlite/sqlite-src-3080704/tool/showdb.c |
deleted file mode 100644 |
index 82b8c9f14f98353e6400490126f641c25d99fc77..0000000000000000000000000000000000000000 |
--- a/third_party/sqlite/sqlite-src-3080704/tool/showdb.c |
+++ /dev/null |
@@ -1,1061 +0,0 @@ |
-/* |
-** A utility for printing all or part of an SQLite database file. |
-*/ |
-#include <stdio.h> |
-#include <ctype.h> |
-#include <sys/types.h> |
-#include <sys/stat.h> |
-#include <fcntl.h> |
- |
-#if !defined(_MSC_VER) |
-#include <unistd.h> |
-#else |
-#include <io.h> |
-#endif |
- |
-#include <stdlib.h> |
-#include <string.h> |
-#include "sqlite3.h" |
- |
- |
-static int pagesize = 1024; /* Size of a database page */ |
-static int db = -1; /* File descriptor for reading the DB */ |
-static int mxPage = 0; /* Last page number */ |
-static int perLine = 16; /* HEX elements to print per line */ |
- |
-typedef long long int i64; /* Datatype for 64-bit integers */ |
- |
- |
-/* |
-** Convert the var-int format into i64. Return the number of bytes |
-** in the var-int. Write the var-int value into *pVal. |
-*/ |
-static int decodeVarint(const unsigned char *z, i64 *pVal){ |
- i64 v = 0; |
- int i; |
- for(i=0; i<8; i++){ |
- v = (v<<7) + (z[i]&0x7f); |
- if( (z[i]&0x80)==0 ){ *pVal = v; return i+1; } |
- } |
- v = (v<<8) + (z[i]&0xff); |
- *pVal = v; |
- return 9; |
-} |
- |
-/* |
-** Extract a big-endian 32-bit integer |
-*/ |
-static unsigned int decodeInt32(const unsigned char *z){ |
- return (z[0]<<24) + (z[1]<<16) + (z[2]<<8) + z[3]; |
-} |
- |
-/* Report an out-of-memory error and die. |
-*/ |
-static void out_of_memory(void){ |
- fprintf(stderr,"Out of memory...\n"); |
- exit(1); |
-} |
- |
-/* |
-** Read content from the file. |
-** |
-** Space to hold the content is obtained from malloc() and needs to be |
-** freed by the caller. |
-*/ |
-static unsigned char *getContent(int ofst, int nByte){ |
- unsigned char *aData; |
- aData = malloc(nByte+32); |
- if( aData==0 ) out_of_memory(); |
- memset(aData, 0, nByte+32); |
- lseek(db, ofst, SEEK_SET); |
- if( read(db, aData, nByte)<nByte ) memset(aData, 0, nByte); |
- return aData; |
-} |
- |
-/* |
-** Print a range of bytes as hex and as ascii. |
-*/ |
-static unsigned char *print_byte_range( |
- int ofst, /* First byte in the range of bytes to print */ |
- int nByte, /* Number of bytes to print */ |
- int printOfst /* Add this amount to the index on the left column */ |
-){ |
- unsigned char *aData; |
- int i, j; |
- const char *zOfstFmt; |
- |
- if( ((printOfst+nByte)&~0xfff)==0 ){ |
- zOfstFmt = " %03x: "; |
- }else if( ((printOfst+nByte)&~0xffff)==0 ){ |
- zOfstFmt = " %04x: "; |
- }else if( ((printOfst+nByte)&~0xfffff)==0 ){ |
- zOfstFmt = " %05x: "; |
- }else if( ((printOfst+nByte)&~0xffffff)==0 ){ |
- zOfstFmt = " %06x: "; |
- }else{ |
- zOfstFmt = " %08x: "; |
- } |
- |
- aData = getContent(ofst, nByte); |
- for(i=0; i<nByte; i += perLine){ |
- fprintf(stdout, zOfstFmt, i+printOfst); |
- for(j=0; j<perLine; j++){ |
- if( i+j>nByte ){ |
- fprintf(stdout, " "); |
- }else{ |
- fprintf(stdout,"%02x ", aData[i+j]); |
- } |
- } |
- for(j=0; j<perLine; j++){ |
- if( i+j>nByte ){ |
- fprintf(stdout, " "); |
- }else{ |
- fprintf(stdout,"%c", isprint(aData[i+j]) ? aData[i+j] : '.'); |
- } |
- } |
- fprintf(stdout,"\n"); |
- } |
- return aData; |
-} |
- |
-/* |
-** Print an entire page of content as hex |
-*/ |
-static void print_page(int iPg){ |
- int iStart; |
- unsigned char *aData; |
- iStart = (iPg-1)*pagesize; |
- fprintf(stdout, "Page %d: (offsets 0x%x..0x%x)\n", |
- iPg, iStart, iStart+pagesize-1); |
- aData = print_byte_range(iStart, pagesize, 0); |
- free(aData); |
-} |
- |
- |
-/* Print a line of decode output showing a 4-byte integer. |
-*/ |
-static void print_decode_line( |
- unsigned char *aData, /* Content being decoded */ |
- int ofst, int nByte, /* Start and size of decode */ |
- const char *zMsg /* Message to append */ |
-){ |
- int i, j; |
- int val = aData[ofst]; |
- char zBuf[100]; |
- sprintf(zBuf, " %03x: %02x", ofst, aData[ofst]); |
- i = (int)strlen(zBuf); |
- for(j=1; j<4; j++){ |
- if( j>=nByte ){ |
- sprintf(&zBuf[i], " "); |
- }else{ |
- sprintf(&zBuf[i], " %02x", aData[ofst+j]); |
- val = val*256 + aData[ofst+j]; |
- } |
- i += (int)strlen(&zBuf[i]); |
- } |
- sprintf(&zBuf[i], " %9d", val); |
- printf("%s %s\n", zBuf, zMsg); |
-} |
- |
-/* |
-** Decode the database header. |
-*/ |
-static void print_db_header(void){ |
- unsigned char *aData; |
- aData = print_byte_range(0, 100, 0); |
- printf("Decoded:\n"); |
- print_decode_line(aData, 16, 2, "Database page size"); |
- print_decode_line(aData, 18, 1, "File format write version"); |
- print_decode_line(aData, 19, 1, "File format read version"); |
- print_decode_line(aData, 20, 1, "Reserved space at end of page"); |
- print_decode_line(aData, 24, 4, "File change counter"); |
- print_decode_line(aData, 28, 4, "Size of database in pages"); |
- print_decode_line(aData, 32, 4, "Page number of first freelist page"); |
- print_decode_line(aData, 36, 4, "Number of freelist pages"); |
- print_decode_line(aData, 40, 4, "Schema cookie"); |
- print_decode_line(aData, 44, 4, "Schema format version"); |
- print_decode_line(aData, 48, 4, "Default page cache size"); |
- print_decode_line(aData, 52, 4, "Largest auto-vac root page"); |
- print_decode_line(aData, 56, 4, "Text encoding"); |
- print_decode_line(aData, 60, 4, "User version"); |
- print_decode_line(aData, 64, 4, "Incremental-vacuum mode"); |
- print_decode_line(aData, 68, 4, "Application ID"); |
- print_decode_line(aData, 72, 4, "meta[8]"); |
- print_decode_line(aData, 76, 4, "meta[9]"); |
- print_decode_line(aData, 80, 4, "meta[10]"); |
- print_decode_line(aData, 84, 4, "meta[11]"); |
- print_decode_line(aData, 88, 4, "meta[12]"); |
- print_decode_line(aData, 92, 4, "Change counter for version number"); |
- print_decode_line(aData, 96, 4, "SQLite version number"); |
-} |
- |
-/* |
-** Describe cell content. |
-*/ |
-static i64 describeContent( |
- unsigned char *a, /* Cell content */ |
- i64 nLocal, /* Bytes in a[] */ |
- char *zDesc /* Write description here */ |
-){ |
- i64 nDesc = 0; |
- int n, j; |
- i64 i, x, v; |
- const unsigned char *pData; |
- const unsigned char *pLimit; |
- char sep = ' '; |
- |
- pLimit = &a[nLocal]; |
- n = decodeVarint(a, &x); |
- pData = &a[x]; |
- a += n; |
- i = x - n; |
- while( i>0 && pData<=pLimit ){ |
- n = decodeVarint(a, &x); |
- a += n; |
- i -= n; |
- nLocal -= n; |
- zDesc[0] = sep; |
- sep = ','; |
- nDesc++; |
- zDesc++; |
- if( x==0 ){ |
- sprintf(zDesc, "*"); /* NULL is a "*" */ |
- }else if( x>=1 && x<=6 ){ |
- v = (signed char)pData[0]; |
- pData++; |
- switch( x ){ |
- case 6: v = (v<<16) + (pData[0]<<8) + pData[1]; pData += 2; |
- case 5: v = (v<<16) + (pData[0]<<8) + pData[1]; pData += 2; |
- case 4: v = (v<<8) + pData[0]; pData++; |
- case 3: v = (v<<8) + pData[0]; pData++; |
- case 2: v = (v<<8) + pData[0]; pData++; |
- } |
- sprintf(zDesc, "%lld", v); |
- }else if( x==7 ){ |
- sprintf(zDesc, "real"); |
- pData += 8; |
- }else if( x==8 ){ |
- sprintf(zDesc, "0"); |
- }else if( x==9 ){ |
- sprintf(zDesc, "1"); |
- }else if( x>=12 ){ |
- i64 size = (x-12)/2; |
- if( (x&1)==0 ){ |
- sprintf(zDesc, "blob(%lld)", size); |
- }else{ |
- sprintf(zDesc, "txt(%lld)", size); |
- } |
- pData += size; |
- } |
- j = (int)strlen(zDesc); |
- zDesc += j; |
- nDesc += j; |
- } |
- return nDesc; |
-} |
- |
-/* |
-** Compute the local payload size given the total payload size and |
-** the page size. |
-*/ |
-static i64 localPayload(i64 nPayload, char cType){ |
- i64 maxLocal; |
- i64 minLocal; |
- i64 surplus; |
- i64 nLocal; |
- if( cType==13 ){ |
- /* Table leaf */ |
- maxLocal = pagesize-35; |
- minLocal = (pagesize-12)*32/255-23; |
- }else{ |
- maxLocal = (pagesize-12)*64/255-23; |
- minLocal = (pagesize-12)*32/255-23; |
- } |
- if( nPayload>maxLocal ){ |
- surplus = minLocal + (nPayload-minLocal)%(pagesize-4); |
- if( surplus<=maxLocal ){ |
- nLocal = surplus; |
- }else{ |
- nLocal = minLocal; |
- } |
- }else{ |
- nLocal = nPayload; |
- } |
- return nLocal; |
-} |
- |
- |
-/* |
-** Create a description for a single cell. |
-** |
-** The return value is the local cell size. |
-*/ |
-static i64 describeCell( |
- unsigned char cType, /* Page type */ |
- unsigned char *a, /* Cell content */ |
- int showCellContent, /* Show cell content if true */ |
- char **pzDesc /* Store description here */ |
-){ |
- int i; |
- i64 nDesc = 0; |
- int n = 0; |
- int leftChild; |
- i64 nPayload; |
- i64 rowid; |
- i64 nLocal; |
- static char zDesc[1000]; |
- i = 0; |
- if( cType<=5 ){ |
- leftChild = ((a[0]*256 + a[1])*256 + a[2])*256 + a[3]; |
- a += 4; |
- n += 4; |
- sprintf(zDesc, "lx: %d ", leftChild); |
- nDesc = strlen(zDesc); |
- } |
- if( cType!=5 ){ |
- i = decodeVarint(a, &nPayload); |
- a += i; |
- n += i; |
- sprintf(&zDesc[nDesc], "n: %lld ", nPayload); |
- nDesc += strlen(&zDesc[nDesc]); |
- nLocal = localPayload(nPayload, cType); |
- }else{ |
- nPayload = nLocal = 0; |
- } |
- if( cType==5 || cType==13 ){ |
- i = decodeVarint(a, &rowid); |
- a += i; |
- n += i; |
- sprintf(&zDesc[nDesc], "r: %lld ", rowid); |
- nDesc += strlen(&zDesc[nDesc]); |
- } |
- if( nLocal<nPayload ){ |
- int ovfl; |
- unsigned char *b = &a[nLocal]; |
- ovfl = ((b[0]*256 + b[1])*256 + b[2])*256 + b[3]; |
- sprintf(&zDesc[nDesc], "ov: %d ", ovfl); |
- nDesc += strlen(&zDesc[nDesc]); |
- n += 4; |
- } |
- if( showCellContent && cType!=5 ){ |
- nDesc += describeContent(a, nLocal, &zDesc[nDesc-1]); |
- } |
- *pzDesc = zDesc; |
- return nLocal+n; |
-} |
- |
-/* Print an offset followed by nByte bytes. Add extra white-space |
-** at the end so that subsequent text is aligned. |
-*/ |
-static void printBytes( |
- unsigned char *aData, /* Content being decoded */ |
- unsigned char *aStart, /* Start of content to be printed */ |
- int nByte /* Number of bytes to print */ |
-){ |
- int j; |
- printf(" %03x: ", (int)(aStart-aData)); |
- for(j=0; j<9; j++){ |
- if( j>=nByte ){ |
- printf(" "); |
- }else{ |
- printf("%02x ", aStart[j]); |
- } |
- } |
-} |
- |
- |
-/* |
-** Write a full decode on stdout for the cell at a[ofst]. |
-** Assume the page contains a header of size szPgHdr bytes. |
-*/ |
-static void decodeCell( |
- unsigned char *a, /* Page content (without the page-1 header) */ |
- unsigned pgno, /* Page number */ |
- int iCell, /* Cell index */ |
- int szPgHdr, /* Size of the page header. 0 or 100 */ |
- int ofst /* Cell begins at a[ofst] */ |
-){ |
- int i, j; |
- int leftChild; |
- i64 k; |
- i64 nPayload; |
- i64 rowid; |
- i64 nHdr; |
- i64 iType; |
- i64 nLocal; |
- unsigned char *x = a + ofst; |
- unsigned char *end; |
- unsigned char cType = a[0]; |
- int nCol = 0; |
- int szCol[2000]; |
- int ofstCol[2000]; |
- int typeCol[2000]; |
- |
- printf("Cell[%d]:\n", iCell); |
- if( cType<=5 ){ |
- leftChild = ((x[0]*256 + x[1])*256 + x[2])*256 + x[3]; |
- printBytes(a, x, 4); |
- printf("left child page:: %d\n", leftChild); |
- x += 4; |
- } |
- if( cType!=5 ){ |
- i = decodeVarint(x, &nPayload); |
- printBytes(a, x, i); |
- nLocal = localPayload(nPayload, cType); |
- if( nLocal==nPayload ){ |
- printf("payload-size: %lld\n", nPayload); |
- }else{ |
- printf("payload-size: %lld (%lld local, %lld overflow)\n", |
- nPayload, nLocal, nPayload-nLocal); |
- } |
- x += i; |
- }else{ |
- nPayload = nLocal = 0; |
- } |
- end = x + nLocal; |
- if( cType==5 || cType==13 ){ |
- i = decodeVarint(x, &rowid); |
- printBytes(a, x, i); |
- printf("rowid: %lld\n", rowid); |
- x += i; |
- } |
- if( nLocal>0 ){ |
- i = decodeVarint(x, &nHdr); |
- printBytes(a, x, i); |
- printf("record-header-size: %d\n", (int)nHdr); |
- j = i; |
- nCol = 0; |
- k = nHdr; |
- while( x+j<end && j<nHdr ){ |
- const char *zTypeName; |
- int sz = 0; |
- char zNm[30]; |
- i = decodeVarint(x+j, &iType); |
- printBytes(a, x+j, i); |
- printf("typecode[%d]: %d - ", nCol, (int)iType); |
- switch( iType ){ |
- case 0: zTypeName = "NULL"; sz = 0; break; |
- case 1: zTypeName = "int8"; sz = 1; break; |
- case 2: zTypeName = "int16"; sz = 2; break; |
- case 3: zTypeName = "int24"; sz = 3; break; |
- case 4: zTypeName = "int32"; sz = 4; break; |
- case 5: zTypeName = "int48"; sz = 6; break; |
- case 6: zTypeName = "int64"; sz = 8; break; |
- case 7: zTypeName = "double"; sz = 8; break; |
- case 8: zTypeName = "zero"; sz = 0; break; |
- case 9: zTypeName = "one"; sz = 0; break; |
- case 10: |
- case 11: zTypeName = "error"; sz = 0; break; |
- default: { |
- sz = (int)(iType-12)/2; |
- sprintf(zNm, (iType&1)==0 ? "blob(%d)" : "text(%d)", sz); |
- zTypeName = zNm; |
- break; |
- } |
- } |
- printf("%s\n", zTypeName); |
- szCol[nCol] = sz; |
- ofstCol[nCol] = (int)k; |
- typeCol[nCol] = (int)iType; |
- k += sz; |
- nCol++; |
- j += i; |
- } |
- for(i=0; i<nCol && ofstCol[i]+szCol[i]<=nLocal; i++){ |
- int s = ofstCol[i]; |
- i64 v; |
- const unsigned char *pData; |
- if( szCol[i]==0 ) continue; |
- printBytes(a, x+s, szCol[i]); |
- printf("data[%d]: ", i); |
- pData = x+s; |
- if( typeCol[i]<=7 ){ |
- v = (signed char)pData[0]; |
- for(k=1; k<szCol[i]; k++){ |
- v = (v<<8) + pData[k]; |
- } |
- if( typeCol[i]==7 ){ |
- double r; |
- memcpy(&r, &v, sizeof(r)); |
- printf("%#g\n", r); |
- }else{ |
- printf("%lld\n", v); |
- } |
- }else{ |
- int ii, jj; |
- char zConst[32]; |
- if( (typeCol[i]&1)==0 ){ |
- zConst[0] = 'x'; |
- zConst[1] = '\''; |
- for(ii=2, jj=0; jj<szCol[i] && ii<24; jj++, ii+=2){ |
- sprintf(zConst+ii, "%02x", pData[jj]); |
- } |
- }else{ |
- zConst[0] = '\''; |
- for(ii=1, jj=0; jj<szCol[i] && ii<24; jj++, ii++){ |
- zConst[ii] = isprint(pData[jj]) ? pData[jj] : '.'; |
- } |
- zConst[ii] = 0; |
- } |
- if( jj<szCol[i] ){ |
- memcpy(zConst+ii, "...'", 5); |
- }else{ |
- memcpy(zConst+ii, "'", 2); |
- } |
- printf("%s\n", zConst); |
- } |
- j = ofstCol[i] + szCol[i]; |
- } |
- } |
- if( j<nLocal ){ |
- printBytes(a, x+j, 0); |
- printf("... %lld bytes of content ...\n", nLocal-j); |
- } |
- if( nLocal<nPayload ){ |
- printBytes(a, x+nLocal, 4); |
- printf("overflow-page: %d\n", decodeInt32(x+nLocal)); |
- } |
-} |
- |
- |
-/* |
-** Decode a btree page |
-*/ |
-static void decode_btree_page( |
- unsigned char *a, /* Page content */ |
- int pgno, /* Page number */ |
- int hdrSize, /* Size of the page header. 0 or 100 */ |
- char *zArgs /* Flags to control formatting */ |
-){ |
- const char *zType = "unknown"; |
- int nCell; |
- int i, j; |
- int iCellPtr; |
- int showCellContent = 0; |
- int showMap = 0; |
- int cellToDecode = -2; |
- char *zMap = 0; |
- switch( a[0] ){ |
- case 2: zType = "index interior node"; break; |
- case 5: zType = "table interior node"; break; |
- case 10: zType = "index leaf"; break; |
- case 13: zType = "table leaf"; break; |
- } |
- while( zArgs[0] ){ |
- switch( zArgs[0] ){ |
- case 'c': showCellContent = 1; break; |
- case 'm': showMap = 1; break; |
- case 'd': { |
- if( !isdigit(zArgs[1]) ){ |
- cellToDecode = -1; |
- }else{ |
- cellToDecode = 0; |
- while( isdigit(zArgs[1]) ){ |
- zArgs++; |
- cellToDecode = cellToDecode*10 + zArgs[0] - '0'; |
- } |
- } |
- break; |
- } |
- } |
- zArgs++; |
- } |
- nCell = a[3]*256 + a[4]; |
- iCellPtr = (a[0]==2 || a[0]==5) ? 12 : 8; |
- if( cellToDecode>=nCell ){ |
- printf("Page %d has only %d cells\n", pgno, nCell); |
- return; |
- } |
- printf("Header on btree page %d:\n", pgno); |
- print_decode_line(a, 0, 1, zType); |
- print_decode_line(a, 1, 2, "Offset to first freeblock"); |
- print_decode_line(a, 3, 2, "Number of cells on this page"); |
- print_decode_line(a, 5, 2, "Offset to cell content area"); |
- print_decode_line(a, 7, 1, "Fragmented byte count"); |
- if( a[0]==2 || a[0]==5 ){ |
- print_decode_line(a, 8, 4, "Right child"); |
- } |
- if( cellToDecode==(-2) && nCell>0 ){ |
- printf(" key: lx=left-child n=payload-size r=rowid\n"); |
- } |
- if( showMap ){ |
- zMap = malloc(pagesize); |
- memset(zMap, '.', pagesize); |
- memset(zMap, '1', hdrSize); |
- memset(&zMap[hdrSize], 'H', iCellPtr); |
- memset(&zMap[hdrSize+iCellPtr], 'P', 2*nCell); |
- } |
- for(i=0; i<nCell; i++){ |
- int cofst = iCellPtr + i*2; |
- char *zDesc; |
- i64 n; |
- |
- cofst = a[cofst]*256 + a[cofst+1]; |
- n = describeCell(a[0], &a[cofst-hdrSize], showCellContent, &zDesc); |
- if( showMap ){ |
- char zBuf[30]; |
- memset(&zMap[cofst], '*', (size_t)n); |
- zMap[cofst] = '['; |
- zMap[cofst+n-1] = ']'; |
- sprintf(zBuf, "%d", i); |
- j = (int)strlen(zBuf); |
- if( j<=n-2 ) memcpy(&zMap[cofst+1], zBuf, j); |
- } |
- if( cellToDecode==(-2) ){ |
- printf(" %03x: cell[%d] %s\n", cofst, i, zDesc); |
- }else if( cellToDecode==(-1) || cellToDecode==i ){ |
- decodeCell(a, pgno, i, hdrSize, cofst-hdrSize); |
- } |
- } |
- if( showMap ){ |
- printf("Page map: (H=header P=cell-index 1=page-1-header .=free-space)\n"); |
- for(i=0; i<pagesize; i+=64){ |
- printf(" %03x: %.64s\n", i, &zMap[i]); |
- } |
- free(zMap); |
- } |
-} |
- |
-/* |
-** Decode a freelist trunk page. |
-*/ |
-static void decode_trunk_page( |
- int pgno, /* The page number */ |
- int pagesize, /* Size of each page */ |
- int detail, /* Show leaf pages if true */ |
- int recursive /* Follow the trunk change if true */ |
-){ |
- int n, i; |
- unsigned char *a; |
- while( pgno>0 ){ |
- a = getContent((pgno-1)*pagesize, pagesize); |
- printf("Decode of freelist trunk page %d:\n", pgno); |
- print_decode_line(a, 0, 4, "Next freelist trunk page"); |
- print_decode_line(a, 4, 4, "Number of entries on this page"); |
- if( detail ){ |
- n = (int)decodeInt32(&a[4]); |
- for(i=0; i<n; i++){ |
- unsigned int x = decodeInt32(&a[8+4*i]); |
- char zIdx[10]; |
- sprintf(zIdx, "[%d]", i); |
- printf(" %5s %7u", zIdx, x); |
- if( i%5==4 ) printf("\n"); |
- } |
- if( i%5!=0 ) printf("\n"); |
- } |
- if( !recursive ){ |
- pgno = 0; |
- }else{ |
- pgno = (int)decodeInt32(&a[0]); |
- } |
- free(a); |
- } |
-} |
- |
-/* |
-** A short text comment on the use of each page. |
-*/ |
-static char **zPageUse; |
- |
-/* |
-** Add a comment on the use of a page. |
-*/ |
-static void page_usage_msg(int pgno, const char *zFormat, ...){ |
- va_list ap; |
- char *zMsg; |
- |
- va_start(ap, zFormat); |
- zMsg = sqlite3_vmprintf(zFormat, ap); |
- va_end(ap); |
- if( pgno<=0 || pgno>mxPage ){ |
- printf("ERROR: page %d out of range 1..%d: %s\n", |
- pgno, mxPage, zMsg); |
- sqlite3_free(zMsg); |
- return; |
- } |
- if( zPageUse[pgno]!=0 ){ |
- printf("ERROR: page %d used multiple times:\n", pgno); |
- printf("ERROR: previous: %s\n", zPageUse[pgno]); |
- printf("ERROR: current: %s\n", zMsg); |
- sqlite3_free(zPageUse[pgno]); |
- } |
- zPageUse[pgno] = zMsg; |
-} |
- |
-/* |
-** Find overflow pages of a cell and describe their usage. |
-*/ |
-static void page_usage_cell( |
- unsigned char cType, /* Page type */ |
- unsigned char *a, /* Cell content */ |
- int pgno, /* page containing the cell */ |
- int cellno /* Index of the cell on the page */ |
-){ |
- int i; |
- int n = 0; |
- i64 nPayload; |
- i64 rowid; |
- i64 nLocal; |
- i = 0; |
- if( cType<=5 ){ |
- a += 4; |
- n += 4; |
- } |
- if( cType!=5 ){ |
- i = decodeVarint(a, &nPayload); |
- a += i; |
- n += i; |
- nLocal = localPayload(nPayload, cType); |
- }else{ |
- nPayload = nLocal = 0; |
- } |
- if( cType==5 || cType==13 ){ |
- i = decodeVarint(a, &rowid); |
- a += i; |
- n += i; |
- } |
- if( nLocal<nPayload ){ |
- int ovfl = decodeInt32(a+nLocal); |
- int cnt = 0; |
- while( ovfl && (cnt++)<mxPage ){ |
- page_usage_msg(ovfl, "overflow %d from cell %d of page %d", |
- cnt, cellno, pgno); |
- a = getContent((ovfl-1)*pagesize, 4); |
- ovfl = decodeInt32(a); |
- free(a); |
- } |
- } |
-} |
- |
- |
-/* |
-** Describe the usages of a b-tree page |
-*/ |
-static void page_usage_btree( |
- int pgno, /* Page to describe */ |
- int parent, /* Parent of this page. 0 for root pages */ |
- int idx, /* Which child of the parent */ |
- const char *zName /* Name of the table */ |
-){ |
- unsigned char *a; |
- const char *zType = "corrupt node"; |
- int nCell; |
- int i; |
- int hdr = pgno==1 ? 100 : 0; |
- |
- if( pgno<=0 || pgno>mxPage ) return; |
- a = getContent((pgno-1)*pagesize, pagesize); |
- switch( a[hdr] ){ |
- case 2: zType = "interior node of index"; break; |
- case 5: zType = "interior node of table"; break; |
- case 10: zType = "leaf of index"; break; |
- case 13: zType = "leaf of table"; break; |
- } |
- if( parent ){ |
- page_usage_msg(pgno, "%s [%s], child %d of page %d", |
- zType, zName, idx, parent); |
- }else{ |
- page_usage_msg(pgno, "root %s [%s]", zType, zName); |
- } |
- nCell = a[hdr+3]*256 + a[hdr+4]; |
- if( a[hdr]==2 || a[hdr]==5 ){ |
- int cellstart = hdr+12; |
- unsigned int child; |
- for(i=0; i<nCell; i++){ |
- int ofst; |
- |
- ofst = cellstart + i*2; |
- ofst = a[ofst]*256 + a[ofst+1]; |
- child = decodeInt32(a+ofst); |
- page_usage_btree(child, pgno, i, zName); |
- } |
- child = decodeInt32(a+cellstart-4); |
- page_usage_btree(child, pgno, i, zName); |
- } |
- if( a[hdr]==2 || a[hdr]==10 || a[hdr]==13 ){ |
- int cellstart = hdr + 8 + 4*(a[hdr]<=5); |
- for(i=0; i<nCell; i++){ |
- int ofst; |
- ofst = cellstart + i*2; |
- ofst = a[ofst]*256 + a[ofst+1]; |
- page_usage_cell(a[hdr], a+ofst, pgno, i); |
- } |
- } |
- free(a); |
-} |
- |
-/* |
-** Determine page usage by the freelist |
-*/ |
-static void page_usage_freelist(int pgno){ |
- unsigned char *a; |
- int cnt = 0; |
- int i; |
- int n; |
- int iNext; |
- int parent = 1; |
- |
- while( pgno>0 && pgno<=mxPage && (cnt++)<mxPage ){ |
- page_usage_msg(pgno, "freelist trunk #%d child of %d", cnt, parent); |
- a = getContent((pgno-1)*pagesize, pagesize); |
- iNext = decodeInt32(a); |
- n = decodeInt32(a+4); |
- for(i=0; i<n; i++){ |
- int child = decodeInt32(a + (i*4+8)); |
- page_usage_msg(child, "freelist leaf, child %d of trunk page %d", |
- i, pgno); |
- } |
- free(a); |
- parent = pgno; |
- pgno = iNext; |
- } |
-} |
- |
-/* |
-** Determine pages used as PTRMAP pages |
-*/ |
-static void page_usage_ptrmap(unsigned char *a){ |
- if( a[55] ){ |
- int usable = pagesize - a[20]; |
- int pgno = 2; |
- int perPage = usable/5; |
- while( pgno<=mxPage ){ |
- page_usage_msg(pgno, "PTRMAP page covering %d..%d", |
- pgno+1, pgno+perPage); |
- pgno += perPage + 1; |
- } |
- } |
-} |
- |
-/* |
-** Try to figure out how every page in the database file is being used. |
-*/ |
-static void page_usage_report(const char *zDbName){ |
- int i, j; |
- int rc; |
- sqlite3 *db; |
- sqlite3_stmt *pStmt; |
- unsigned char *a; |
- char zQuery[200]; |
- |
- /* Avoid the pathological case */ |
- if( mxPage<1 ){ |
- printf("empty database\n"); |
- return; |
- } |
- |
- /* Open the database file */ |
- rc = sqlite3_open(zDbName, &db); |
- if( rc ){ |
- printf("cannot open database: %s\n", sqlite3_errmsg(db)); |
- sqlite3_close(db); |
- return; |
- } |
- |
- /* Set up global variables zPageUse[] and mxPage to record page |
- ** usages */ |
- zPageUse = sqlite3_malloc( sizeof(zPageUse[0])*(mxPage+1) ); |
- if( zPageUse==0 ) out_of_memory(); |
- memset(zPageUse, 0, sizeof(zPageUse[0])*(mxPage+1)); |
- |
- /* Discover the usage of each page */ |
- a = getContent(0, 100); |
- page_usage_freelist(decodeInt32(a+32)); |
- page_usage_ptrmap(a); |
- free(a); |
- page_usage_btree(1, 0, 0, "sqlite_master"); |
- sqlite3_exec(db, "PRAGMA writable_schema=ON", 0, 0, 0); |
- for(j=0; j<2; j++){ |
- sqlite3_snprintf(sizeof(zQuery), zQuery, |
- "SELECT type, name, rootpage FROM SQLITE_MASTER WHERE rootpage" |
- " ORDER BY rowid %s", j?"DESC":""); |
- rc = sqlite3_prepare_v2(db, zQuery, -1, &pStmt, 0); |
- if( rc==SQLITE_OK ){ |
- while( sqlite3_step(pStmt)==SQLITE_ROW ){ |
- int pgno = sqlite3_column_int(pStmt, 2); |
- page_usage_btree(pgno, 0, 0, (const char*)sqlite3_column_text(pStmt,1)); |
- } |
- }else{ |
- printf("ERROR: cannot query database: %s\n", sqlite3_errmsg(db)); |
- } |
- rc = sqlite3_finalize(pStmt); |
- if( rc==SQLITE_OK ) break; |
- } |
- sqlite3_close(db); |
- |
- /* Print the report and free memory used */ |
- for(i=1; i<=mxPage; i++){ |
- printf("%5d: %s\n", i, zPageUse[i] ? zPageUse[i] : "???"); |
- sqlite3_free(zPageUse[i]); |
- } |
- sqlite3_free(zPageUse); |
- zPageUse = 0; |
-} |
- |
-/* |
-** Try to figure out how every page in the database file is being used. |
-*/ |
-static void ptrmap_coverage_report(const char *zDbName){ |
- int pgno; |
- unsigned char *aHdr; |
- unsigned char *a; |
- int usable; |
- int perPage; |
- int i; |
- |
- /* Avoid the pathological case */ |
- if( mxPage<1 ){ |
- printf("empty database\n"); |
- return; |
- } |
- |
- /* Make sure PTRMAPs are used in this database */ |
- aHdr = getContent(0, 100); |
- if( aHdr[55]==0 ){ |
- printf("database does not use PTRMAP pages\n"); |
- return; |
- } |
- usable = pagesize - aHdr[20]; |
- perPage = usable/5; |
- free(aHdr); |
- printf("%5d: root of sqlite_master\n", 1); |
- for(pgno=2; pgno<=mxPage; pgno += perPage+1){ |
- printf("%5d: PTRMAP page covering %d..%d\n", pgno, |
- pgno+1, pgno+perPage); |
- a = getContent((pgno-1)*pagesize, usable); |
- for(i=0; i+5<=usable && pgno+1+i/5<=mxPage; i+=5){ |
- const char *zType = "???"; |
- unsigned int iFrom = decodeInt32(&a[i+1]); |
- switch( a[i] ){ |
- case 1: zType = "b-tree root page"; break; |
- case 2: zType = "freelist page"; break; |
- case 3: zType = "first page of overflow"; break; |
- case 4: zType = "later page of overflow"; break; |
- case 5: zType = "b-tree non-root page"; break; |
- } |
- printf("%5d: %s, parent=%u\n", pgno+1+i/5, zType, iFrom); |
- } |
- free(a); |
- } |
-} |
- |
-/* |
-** Print a usage comment |
-*/ |
-static void usage(const char *argv0){ |
- fprintf(stderr, "Usage %s FILENAME ?args...?\n\n", argv0); |
- fprintf(stderr, |
- "args:\n" |
- " dbheader Show database header\n" |
- " pgidx Index of how each page is used\n" |
- " ptrmap Show all PTRMAP page content\n" |
- " NNN..MMM Show hex of pages NNN through MMM\n" |
- " NNN..end Show hex of pages NNN through end of file\n" |
- " NNNb Decode btree page NNN\n" |
- " NNNbc Decode btree page NNN and show content\n" |
- " NNNbm Decode btree page NNN and show a layout map\n" |
- " NNNbdCCC Decode cell CCC on btree page NNN\n" |
- " NNNt Decode freelist trunk page NNN\n" |
- " NNNtd Show leaf freelist pages on the decode\n" |
- " NNNtr Recursively decode freelist starting at NNN\n" |
- ); |
-} |
- |
-int main(int argc, char **argv){ |
- struct stat sbuf; |
- unsigned char zPgSz[2]; |
- if( argc<2 ){ |
- usage(argv[0]); |
- exit(1); |
- } |
- db = open(argv[1], O_RDONLY); |
- if( db<0 ){ |
- fprintf(stderr,"%s: can't open %s\n", argv[0], argv[1]); |
- exit(1); |
- } |
- zPgSz[0] = 0; |
- zPgSz[1] = 0; |
- lseek(db, 16, SEEK_SET); |
- if( read(db, zPgSz, 2)<2 ) memset(zPgSz, 0, 2); |
- pagesize = zPgSz[0]*256 + zPgSz[1]*65536; |
- if( pagesize==0 ) pagesize = 1024; |
- printf("Pagesize: %d\n", pagesize); |
- fstat(db, &sbuf); |
- mxPage = sbuf.st_size/pagesize; |
- printf("Available pages: 1..%d\n", mxPage); |
- if( argc==2 ){ |
- int i; |
- for(i=1; i<=mxPage; i++) print_page(i); |
- }else{ |
- int i; |
- for(i=2; i<argc; i++){ |
- int iStart, iEnd; |
- char *zLeft; |
- if( strcmp(argv[i], "dbheader")==0 ){ |
- print_db_header(); |
- continue; |
- } |
- if( strcmp(argv[i], "pgidx")==0 ){ |
- page_usage_report(argv[1]); |
- continue; |
- } |
- if( strcmp(argv[i], "ptrmap")==0 ){ |
- ptrmap_coverage_report(argv[1]); |
- continue; |
- } |
- if( strcmp(argv[i], "help")==0 ){ |
- usage(argv[0]); |
- continue; |
- } |
- if( !isdigit(argv[i][0]) ){ |
- fprintf(stderr, "%s: unknown option: [%s]\n", argv[0], argv[i]); |
- continue; |
- } |
- iStart = strtol(argv[i], &zLeft, 0); |
- if( zLeft && strcmp(zLeft,"..end")==0 ){ |
- iEnd = mxPage; |
- }else if( zLeft && zLeft[0]=='.' && zLeft[1]=='.' ){ |
- iEnd = strtol(&zLeft[2], 0, 0); |
- }else if( zLeft && zLeft[0]=='b' ){ |
- int ofst, nByte, hdrSize; |
- unsigned char *a; |
- if( iStart==1 ){ |
- ofst = hdrSize = 100; |
- nByte = pagesize-100; |
- }else{ |
- hdrSize = 0; |
- ofst = (iStart-1)*pagesize; |
- nByte = pagesize; |
- } |
- a = getContent(ofst, nByte); |
- decode_btree_page(a, iStart, hdrSize, &zLeft[1]); |
- free(a); |
- continue; |
- }else if( zLeft && zLeft[0]=='t' ){ |
- int detail = 0; |
- int recursive = 0; |
- int i; |
- for(i=1; zLeft[i]; i++){ |
- if( zLeft[i]=='r' ) recursive = 1; |
- if( zLeft[i]=='d' ) detail = 1; |
- } |
- decode_trunk_page(iStart, pagesize, detail, recursive); |
- continue; |
- }else{ |
- iEnd = iStart; |
- } |
- if( iStart<1 || iEnd<iStart || iEnd>mxPage ){ |
- fprintf(stderr, |
- "Page argument should be LOWER?..UPPER?. Range 1 to %d\n", |
- mxPage); |
- exit(1); |
- } |
- while( iStart<=iEnd ){ |
- print_page(iStart); |
- iStart++; |
- } |
- } |
- } |
- close(db); |
- return 0; |
-} |