1: /*
2: ** A utility for printing all or part of an SQLite database file.
3: */
4: #include <stdio.h>
5: #include <ctype.h>
6: #include <sys/types.h>
7: #include <sys/stat.h>
8: #include <fcntl.h>
9: #include <unistd.h>
10: #include <stdlib.h>
11: #include <string.h>
12:
13:
14: static int pagesize = 1024; /* Size of a database page */
15: static int db = -1; /* File descriptor for reading the DB */
16: static int mxPage = 0; /* Last page number */
17: static int perLine = 16; /* HEX elements to print per line */
18:
19: typedef long long int i64; /* Datatype for 64-bit integers */
20:
21:
22: /*
23: ** Convert the var-int format into i64. Return the number of bytes
24: ** in the var-int. Write the var-int value into *pVal.
25: */
26: static int decodeVarint(const unsigned char *z, i64 *pVal){
27: i64 v = 0;
28: int i;
29: for(i=0; i<8; i++){
30: v = (v<<7) + (z[i]&0x7f);
31: if( (z[i]&0x80)==0 ){ *pVal = v; return i+1; }
32: }
33: v = (v<<8) + (z[i]&0xff);
34: *pVal = v;
35: return 9;
36: }
37:
38: /*
39: ** Extract a big-endian 32-bit integer
40: */
41: static unsigned int decodeInt32(const unsigned char *z){
42: return (z[0]<<24) + (z[1]<<16) + (z[2]<<8) + z[3];
43: }
44:
45: /* Report an out-of-memory error and die.
46: */
47: static void out_of_memory(void){
48: fprintf(stderr,"Out of memory...\n");
49: exit(1);
50: }
51:
52: /*
53: ** Read content from the file.
54: **
55: ** Space to hold the content is obtained from malloc() and needs to be
56: ** freed by the caller.
57: */
58: static unsigned char *getContent(int ofst, int nByte){
59: unsigned char *aData;
60: aData = malloc(nByte+32);
61: if( aData==0 ) out_of_memory();
62: memset(aData, 0, nByte+32);
63: lseek(db, ofst, SEEK_SET);
64: read(db, aData, nByte);
65: return aData;
66: }
67:
68: /*
69: ** Print a range of bytes as hex and as ascii.
70: */
71: static unsigned char *print_byte_range(
72: int ofst, /* First byte in the range of bytes to print */
73: int nByte, /* Number of bytes to print */
74: int printOfst /* Add this amount to the index on the left column */
75: ){
76: unsigned char *aData;
77: int i, j;
78: const char *zOfstFmt;
79:
80: if( ((printOfst+nByte)&~0xfff)==0 ){
81: zOfstFmt = " %03x: ";
82: }else if( ((printOfst+nByte)&~0xffff)==0 ){
83: zOfstFmt = " %04x: ";
84: }else if( ((printOfst+nByte)&~0xfffff)==0 ){
85: zOfstFmt = " %05x: ";
86: }else if( ((printOfst+nByte)&~0xffffff)==0 ){
87: zOfstFmt = " %06x: ";
88: }else{
89: zOfstFmt = " %08x: ";
90: }
91:
92: aData = getContent(ofst, nByte);
93: for(i=0; i<nByte; i += perLine){
94: fprintf(stdout, zOfstFmt, i+printOfst);
95: for(j=0; j<perLine; j++){
96: if( i+j>nByte ){
97: fprintf(stdout, " ");
98: }else{
99: fprintf(stdout,"%02x ", aData[i+j]);
100: }
101: }
102: for(j=0; j<perLine; j++){
103: if( i+j>nByte ){
104: fprintf(stdout, " ");
105: }else{
106: fprintf(stdout,"%c", isprint(aData[i+j]) ? aData[i+j] : '.');
107: }
108: }
109: fprintf(stdout,"\n");
110: }
111: return aData;
112: }
113:
114: /*
115: ** Print an entire page of content as hex
116: */
117: static print_page(int iPg){
118: int iStart;
119: unsigned char *aData;
120: iStart = (iPg-1)*pagesize;
121: fprintf(stdout, "Page %d: (offsets 0x%x..0x%x)\n",
122: iPg, iStart, iStart+pagesize-1);
123: aData = print_byte_range(iStart, pagesize, 0);
124: free(aData);
125: }
126:
127: /* Print a line of decode output showing a 4-byte integer.
128: */
129: static print_decode_line(
130: unsigned char *aData, /* Content being decoded */
131: int ofst, int nByte, /* Start and size of decode */
132: const char *zMsg /* Message to append */
133: ){
134: int i, j;
135: int val = aData[ofst];
136: char zBuf[100];
137: sprintf(zBuf, " %03x: %02x", ofst, aData[ofst]);
138: i = strlen(zBuf);
139: for(j=1; j<4; j++){
140: if( j>=nByte ){
141: sprintf(&zBuf[i], " ");
142: }else{
143: sprintf(&zBuf[i], " %02x", aData[ofst+j]);
144: val = val*256 + aData[ofst+j];
145: }
146: i += strlen(&zBuf[i]);
147: }
148: sprintf(&zBuf[i], " %9d", val);
149: printf("%s %s\n", zBuf, zMsg);
150: }
151:
152: /*
153: ** Decode the database header.
154: */
155: static void print_db_header(void){
156: unsigned char *aData;
157: aData = print_byte_range(0, 100, 0);
158: printf("Decoded:\n");
159: print_decode_line(aData, 16, 2, "Database page size");
160: print_decode_line(aData, 18, 1, "File format write version");
161: print_decode_line(aData, 19, 1, "File format read version");
162: print_decode_line(aData, 20, 1, "Reserved space at end of page");
163: print_decode_line(aData, 24, 4, "File change counter");
164: print_decode_line(aData, 28, 4, "Size of database in pages");
165: print_decode_line(aData, 32, 4, "Page number of first freelist page");
166: print_decode_line(aData, 36, 4, "Number of freelist pages");
167: print_decode_line(aData, 40, 4, "Schema cookie");
168: print_decode_line(aData, 44, 4, "Schema format version");
169: print_decode_line(aData, 48, 4, "Default page cache size");
170: print_decode_line(aData, 52, 4, "Largest auto-vac root page");
171: print_decode_line(aData, 56, 4, "Text encoding");
172: print_decode_line(aData, 60, 4, "User version");
173: print_decode_line(aData, 64, 4, "Incremental-vacuum mode");
174: print_decode_line(aData, 68, 4, "meta[7]");
175: print_decode_line(aData, 72, 4, "meta[8]");
176: print_decode_line(aData, 76, 4, "meta[9]");
177: print_decode_line(aData, 80, 4, "meta[10]");
178: print_decode_line(aData, 84, 4, "meta[11]");
179: print_decode_line(aData, 88, 4, "meta[12]");
180: print_decode_line(aData, 92, 4, "Change counter for version number");
181: print_decode_line(aData, 96, 4, "SQLite version number");
182: }
183:
184: /*
185: ** Describe cell content.
186: */
187: static int describeContent(
188: unsigned char *a, /* Cell content */
189: int nLocal, /* Bytes in a[] */
190: char *zDesc /* Write description here */
191: ){
192: int nDesc = 0;
193: int n, i, j;
194: i64 x, v;
195: const unsigned char *pData;
196: const unsigned char *pLimit;
197: char sep = ' ';
198:
199: pLimit = &a[nLocal];
200: n = decodeVarint(a, &x);
201: pData = &a[x];
202: a += n;
203: i = x - n;
204: while( i>0 && pData<=pLimit ){
205: n = decodeVarint(a, &x);
206: a += n;
207: i -= n;
208: nLocal -= n;
209: zDesc[0] = sep;
210: sep = ',';
211: nDesc++;
212: zDesc++;
213: if( x==0 ){
214: sprintf(zDesc, "*"); /* NULL is a "*" */
215: }else if( x>=1 && x<=6 ){
216: v = (signed char)pData[0];
217: pData++;
218: switch( x ){
219: case 6: v = (v<<16) + (pData[0]<<8) + pData[1]; pData += 2;
220: case 5: v = (v<<16) + (pData[0]<<8) + pData[1]; pData += 2;
221: case 4: v = (v<<8) + pData[0]; pData++;
222: case 3: v = (v<<8) + pData[0]; pData++;
223: case 2: v = (v<<8) + pData[0]; pData++;
224: }
225: sprintf(zDesc, "%lld", v);
226: }else if( x==7 ){
227: sprintf(zDesc, "real");
228: pData += 8;
229: }else if( x==8 ){
230: sprintf(zDesc, "0");
231: }else if( x==9 ){
232: sprintf(zDesc, "1");
233: }else if( x>=12 ){
234: int size = (x-12)/2;
235: if( (x&1)==0 ){
236: sprintf(zDesc, "blob(%d)", size);
237: }else{
238: sprintf(zDesc, "txt(%d)", size);
239: }
240: pData += size;
241: }
242: j = strlen(zDesc);
243: zDesc += j;
244: nDesc += j;
245: }
246: return nDesc;
247: }
248:
249: /*
250: ** Compute the local payload size given the total payload size and
251: ** the page size.
252: */
253: static int localPayload(i64 nPayload, char cType){
254: int maxLocal;
255: int minLocal;
256: int surplus;
257: int nLocal;
258: if( cType==13 ){
259: /* Table leaf */
260: maxLocal = pagesize-35;
261: minLocal = (pagesize-12)*32/255-23;
262: }else{
263: maxLocal = (pagesize-12)*64/255-23;
264: minLocal = (pagesize-12)*32/255-23;
265: }
266: if( nPayload>maxLocal ){
267: surplus = minLocal + (nPayload-minLocal)%(pagesize-4);
268: if( surplus<=maxLocal ){
269: nLocal = surplus;
270: }else{
271: nLocal = minLocal;
272: }
273: }else{
274: nLocal = nPayload;
275: }
276: return nLocal;
277: }
278:
279:
280: /*
281: ** Create a description for a single cell.
282: **
283: ** The return value is the local cell size.
284: */
285: static int describeCell(
286: unsigned char cType, /* Page type */
287: unsigned char *a, /* Cell content */
288: int showCellContent, /* Show cell content if true */
289: char **pzDesc /* Store description here */
290: ){
291: int i;
292: int nDesc = 0;
293: int n = 0;
294: int leftChild;
295: i64 nPayload;
296: i64 rowid;
297: int nLocal;
298: static char zDesc[1000];
299: i = 0;
300: if( cType<=5 ){
301: leftChild = ((a[0]*256 + a[1])*256 + a[2])*256 + a[3];
302: a += 4;
303: n += 4;
304: sprintf(zDesc, "lx: %d ", leftChild);
305: nDesc = strlen(zDesc);
306: }
307: if( cType!=5 ){
308: i = decodeVarint(a, &nPayload);
309: a += i;
310: n += i;
311: sprintf(&zDesc[nDesc], "n: %lld ", nPayload);
312: nDesc += strlen(&zDesc[nDesc]);
313: nLocal = localPayload(nPayload, cType);
314: }else{
315: nPayload = nLocal = 0;
316: }
317: if( cType==5 || cType==13 ){
318: i = decodeVarint(a, &rowid);
319: a += i;
320: n += i;
321: sprintf(&zDesc[nDesc], "r: %lld ", rowid);
322: nDesc += strlen(&zDesc[nDesc]);
323: }
324: if( nLocal<nPayload ){
325: int ovfl;
326: unsigned char *b = &a[nLocal];
327: ovfl = ((b[0]*256 + b[1])*256 + b[2])*256 + b[3];
328: sprintf(&zDesc[nDesc], "ov: %d ", ovfl);
329: nDesc += strlen(&zDesc[nDesc]);
330: n += 4;
331: }
332: if( showCellContent && cType!=5 ){
333: nDesc += describeContent(a, nLocal, &zDesc[nDesc-1]);
334: }
335: *pzDesc = zDesc;
336: return nLocal+n;
337: }
338:
339: /*
340: ** Decode a btree page
341: */
342: static void decode_btree_page(
343: unsigned char *a, /* Page content */
344: int pgno, /* Page number */
345: int hdrSize, /* Size of the page header. 0 or 100 */
346: char *zArgs /* Flags to control formatting */
347: ){
348: const char *zType = "unknown";
349: int nCell;
350: int i, j;
351: int iCellPtr;
352: int showCellContent = 0;
353: int showMap = 0;
354: char *zMap = 0;
355: switch( a[0] ){
356: case 2: zType = "index interior node"; break;
357: case 5: zType = "table interior node"; break;
358: case 10: zType = "index leaf"; break;
359: case 13: zType = "table leaf"; break;
360: }
361: while( zArgs[0] ){
362: switch( zArgs[0] ){
363: case 'c': showCellContent = 1; break;
364: case 'm': showMap = 1; break;
365: }
366: zArgs++;
367: }
368: printf("Decode of btree page %d:\n", pgno);
369: print_decode_line(a, 0, 1, zType);
370: print_decode_line(a, 1, 2, "Offset to first freeblock");
371: print_decode_line(a, 3, 2, "Number of cells on this page");
372: nCell = a[3]*256 + a[4];
373: print_decode_line(a, 5, 2, "Offset to cell content area");
374: print_decode_line(a, 7, 1, "Fragmented byte count");
375: if( a[0]==2 || a[0]==5 ){
376: print_decode_line(a, 8, 4, "Right child");
377: iCellPtr = 12;
378: }else{
379: iCellPtr = 8;
380: }
381: if( nCell>0 ){
382: printf(" key: lx=left-child n=payload-size r=rowid\n");
383: }
384: if( showMap ){
385: zMap = malloc(pagesize);
386: memset(zMap, '.', pagesize);
387: memset(zMap, '1', hdrSize);
388: memset(&zMap[hdrSize], 'H', iCellPtr);
389: memset(&zMap[hdrSize+iCellPtr], 'P', 2*nCell);
390: }
391: for(i=0; i<nCell; i++){
392: int cofst = iCellPtr + i*2;
393: char *zDesc;
394: int n;
395:
396: cofst = a[cofst]*256 + a[cofst+1];
397: n = describeCell(a[0], &a[cofst-hdrSize], showCellContent, &zDesc);
398: if( showMap ){
399: char zBuf[30];
400: memset(&zMap[cofst], '*', n);
401: zMap[cofst] = '[';
402: zMap[cofst+n-1] = ']';
403: sprintf(zBuf, "%d", i);
404: j = strlen(zBuf);
405: if( j<=n-2 ) memcpy(&zMap[cofst+1], zBuf, j);
406: }
407: printf(" %03x: cell[%d] %s\n", cofst, i, zDesc);
408: }
409: if( showMap ){
410: for(i=0; i<pagesize; i+=64){
411: printf(" %03x: %.64s\n", i, &zMap[i]);
412: }
413: free(zMap);
414: }
415: }
416:
417: /*
418: ** Decode a freelist trunk page.
419: */
420: static void decode_trunk_page(
421: int pgno, /* The page number */
422: int pagesize, /* Size of each page */
423: int detail, /* Show leaf pages if true */
424: int recursive /* Follow the trunk change if true */
425: ){
426: int n, i, k;
427: unsigned char *a;
428: while( pgno>0 ){
429: a = getContent((pgno-1)*pagesize, pagesize);
430: printf("Decode of freelist trunk page %d:\n", pgno);
431: print_decode_line(a, 0, 4, "Next freelist trunk page");
432: print_decode_line(a, 4, 4, "Number of entries on this page");
433: if( detail ){
434: n = (int)decodeInt32(&a[4]);
435: for(i=0; i<n; i++){
436: unsigned int x = decodeInt32(&a[8+4*i]);
437: char zIdx[10];
438: sprintf(zIdx, "[%d]", i);
439: printf(" %5s %7u", zIdx, x);
440: if( i%5==4 ) printf("\n");
441: }
442: if( i%5!=0 ) printf("\n");
443: }
444: if( !recursive ){
445: pgno = 0;
446: }else{
447: pgno = (int)decodeInt32(&a[0]);
448: }
449: free(a);
450: }
451: }
452:
453: /*
454: ** Print a usage comment
455: */
456: static void usage(const char *argv0){
457: fprintf(stderr, "Usage %s FILENAME ?args...?\n\n", argv0);
458: fprintf(stderr,
459: "args:\n"
460: " dbheader Show database header\n"
461: " NNN..MMM Show hex of pages NNN through MMM\n"
462: " NNN..end Show hex of pages NNN through end of file\n"
463: " NNNb Decode btree page NNN\n"
464: " NNNbc Decode btree page NNN and show content\n"
465: " NNNbm Decode btree page NNN and show a layout map\n"
466: " NNNt Decode freelist trunk page NNN\n"
467: " NNNtd Show leaf freelist pages on the decode\n"
468: " NNNtr Recurisvely decode freelist starting at NNN\n"
469: );
470: }
471:
472: int main(int argc, char **argv){
473: struct stat sbuf;
474: unsigned char zPgSz[2];
475: if( argc<2 ){
476: usage(argv[0]);
477: exit(1);
478: }
479: db = open(argv[1], O_RDONLY);
480: if( db<0 ){
481: fprintf(stderr,"%s: can't open %s\n", argv[0], argv[1]);
482: exit(1);
483: }
484: zPgSz[0] = 0;
485: zPgSz[1] = 0;
486: lseek(db, 16, SEEK_SET);
487: read(db, zPgSz, 2);
488: pagesize = zPgSz[0]*256 + zPgSz[1]*65536;
489: if( pagesize==0 ) pagesize = 1024;
490: printf("Pagesize: %d\n", pagesize);
491: fstat(db, &sbuf);
492: mxPage = sbuf.st_size/pagesize;
493: printf("Available pages: 1..%d\n", mxPage);
494: if( argc==2 ){
495: int i;
496: for(i=1; i<=mxPage; i++) print_page(i);
497: }else{
498: int i;
499: for(i=2; i<argc; i++){
500: int iStart, iEnd;
501: char *zLeft;
502: if( strcmp(argv[i], "dbheader")==0 ){
503: print_db_header();
504: continue;
505: }
506: if( !isdigit(argv[i][0]) ){
507: fprintf(stderr, "%s: unknown option: [%s]\n", argv[0], argv[i]);
508: continue;
509: }
510: iStart = strtol(argv[i], &zLeft, 0);
511: if( zLeft && strcmp(zLeft,"..end")==0 ){
512: iEnd = mxPage;
513: }else if( zLeft && zLeft[0]=='.' && zLeft[1]=='.' ){
514: iEnd = strtol(&zLeft[2], 0, 0);
515: }else if( zLeft && zLeft[0]=='b' ){
516: int ofst, nByte, hdrSize;
517: unsigned char *a;
518: if( iStart==1 ){
519: ofst = hdrSize = 100;
520: nByte = pagesize-100;
521: }else{
522: hdrSize = 0;
523: ofst = (iStart-1)*pagesize;
524: nByte = pagesize;
525: }
526: a = getContent(ofst, nByte);
527: decode_btree_page(a, iStart, hdrSize, &zLeft[1]);
528: free(a);
529: continue;
530: }else if( zLeft && zLeft[0]=='t' ){
531: unsigned char *a;
532: int detail = 0;
533: int recursive = 0;
534: int i;
535: for(i=1; zLeft[i]; i++){
536: if( zLeft[i]=='r' ) recursive = 1;
537: if( zLeft[i]=='d' ) detail = 1;
538: }
539: decode_trunk_page(iStart, pagesize, detail, recursive);
540: continue;
541: }else{
542: iEnd = iStart;
543: }
544: if( iStart<1 || iEnd<iStart || iEnd>mxPage ){
545: fprintf(stderr,
546: "Page argument should be LOWER?..UPPER?. Range 1 to %d\n",
547: mxPage);
548: exit(1);
549: }
550: while( iStart<=iEnd ){
551: print_page(iStart);
552: iStart++;
553: }
554: }
555: }
556: close(db);
557: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to showdb.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / tool