db_dump185.c
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:9k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /*-
  2.  * See the file LICENSE for redistribution information.
  3.  *
  4.  * Copyright (c) 1996-2002
  5.  * Sleepycat Software.  All rights reserved.
  6.  */
  7. #ifndef lint
  8. static char copyright[] =
  9.     "Copyright (c) 1996-2002nSleepycat Software Inc.  All rights reserved.n";
  10. static char revid[] =
  11.     "$Id: db_dump185.c,v 11.17 2002/08/08 03:50:35 bostic Exp $";
  12. #endif
  13. #include <sys/types.h>
  14. #include <ctype.h>
  15. #include <errno.h>
  16. #include <fcntl.h>
  17. #include <stdio.h>
  18. #include <stdlib.h>
  19. #include <string.h>
  20. #include <db.h>
  21. /* Hash Table Information */
  22. typedef struct hashhdr185 { /* Disk resident portion */
  23. int magic; /* Magic NO for hash tables */
  24. int version; /* Version ID */
  25. u_int32_t lorder; /* Byte Order */
  26. int bsize; /* Bucket/Page Size */
  27. int bshift; /* Bucket shift */
  28. int dsize; /* Directory Size */
  29. int ssize; /* Segment Size */
  30. int sshift; /* Segment shift */
  31. int ovfl_point; /* Where overflow pages are being
  32.  * allocated */
  33. int last_freed; /* Last overflow page freed */
  34. int max_bucket; /* ID of Maximum bucket in use */
  35. int high_mask; /* Mask to modulo into entire table */
  36. int low_mask; /* Mask to modulo into lower half of
  37.  * table */
  38. int ffactor; /* Fill factor */
  39. int nkeys; /* Number of keys in hash table */
  40. } HASHHDR185;
  41. typedef struct htab185  { /* Memory resident data structure */
  42. HASHHDR185 hdr; /* Header */
  43. } HTAB185;
  44. /* Hash Table Information */
  45. typedef struct hashhdr186 { /* Disk resident portion */
  46. int32_t magic; /* Magic NO for hash tables */
  47. int32_t version; /* Version ID */
  48. int32_t lorder; /* Byte Order */
  49. int32_t bsize; /* Bucket/Page Size */
  50. int32_t bshift; /* Bucket shift */
  51. int32_t ovfl_point; /* Where overflow pages are being allocated */
  52. int32_t last_freed; /* Last overflow page freed */
  53. int32_t max_bucket; /* ID of Maximum bucket in use */
  54. int32_t high_mask; /* Mask to modulo into entire table */
  55. int32_t low_mask; /* Mask to modulo into lower half of table */
  56. int32_t ffactor; /* Fill factor */
  57. int32_t nkeys; /* Number of keys in hash table */
  58. int32_t hdrpages; /* Size of table header */
  59. int32_t h_charkey; /* value of hash(CHARKEY) */
  60. #define NCACHED 32 /* number of bit maps and spare points */
  61. int32_t spares[NCACHED];/* spare pages for overflow */
  62. /* address of overflow page bitmaps */
  63. u_int16_t bitmaps[NCACHED];
  64. } HASHHDR186;
  65. typedef struct htab186  { /* Memory resident data structure */
  66. void *unused[2];
  67. HASHHDR186 hdr; /* Header */
  68. } HTAB186;
  69. typedef struct _epgno {
  70. u_int32_t pgno; /* the page number */
  71. u_int16_t index; /* the index on the page */
  72. } EPGNO;
  73. typedef struct _epg {
  74. void *page; /* the (pinned) page */
  75. u_int16_t index; /* the index on the page */
  76. } EPG;
  77. typedef struct _cursor {
  78. EPGNO  pg; /* B: Saved tree reference. */
  79. DBT  key; /* B: Saved key, or key.data == NULL. */
  80. u_int32_t rcursor; /* R: recno cursor (1-based) */
  81. #define CURS_ACQUIRE 0x01 /*  B: Cursor needs to be reacquired. */
  82. #define CURS_AFTER 0x02 /*  B: Unreturned cursor after key. */
  83. #define CURS_BEFORE 0x04 /*  B: Unreturned cursor before key. */
  84. #define CURS_INIT 0x08 /* RB: Cursor initialized. */
  85. u_int8_t flags;
  86. } CURSOR;
  87. /* The in-memory btree/recno data structure. */
  88. typedef struct _btree {
  89. void  *bt_mp; /* memory pool cookie */
  90. void  *bt_dbp; /* pointer to enclosing DB */
  91. EPG   bt_cur; /* current (pinned) page */
  92. void  *bt_pinned; /* page pinned across calls */
  93. CURSOR   bt_cursor; /* cursor */
  94. EPGNO   bt_stack[50]; /* stack of parent pages */
  95. EPGNO  *bt_sp; /* current stack pointer */
  96. DBT   bt_rkey; /* returned key */
  97. DBT   bt_rdata; /* returned data */
  98. int   bt_fd; /* tree file descriptor */
  99. u_int32_t bt_free; /* next free page */
  100. u_int32_t bt_psize; /* page size */
  101. u_int16_t bt_ovflsize; /* cut-off for key/data overflow */
  102. int   bt_lorder; /* byte order */
  103. /* sorted order */
  104. enum { NOT, BACK, FORWARD } bt_order;
  105. EPGNO   bt_last; /* last insert */
  106. /* B: key comparison function */
  107. int (*bt_cmp) __P((DBT *, DBT *));
  108. /* B: prefix comparison function */
  109. size_t (*bt_pfx) __P((DBT *, DBT *));
  110. /* R: recno input function */
  111. int (*bt_irec) __P((struct _btree *, u_int32_t));
  112. FILE  *bt_rfp; /* R: record FILE pointer */
  113. int   bt_rfd; /* R: record file descriptor */
  114. void  *bt_cmap; /* R: current point in mapped space */
  115. void  *bt_smap; /* R: start of mapped space */
  116. void  *bt_emap; /* R: end of mapped space */
  117. size_t   bt_msize; /* R: size of mapped region. */
  118. u_int32_t bt_nrecs; /* R: number of records */
  119. size_t   bt_reclen; /* R: fixed record length */
  120. u_char   bt_bval; /* R: delimiting byte/pad character */
  121. /*
  122.  * NB:
  123.  * B_NODUPS and R_RECNO are stored on disk, and may not be changed.
  124.  */
  125. #define B_INMEM 0x00001 /* in-memory tree */
  126. #define B_METADIRTY 0x00002 /* need to write metadata */
  127. #define B_MODIFIED 0x00004 /* tree modified */
  128. #define B_NEEDSWAP 0x00008 /* if byte order requires swapping */
  129. #define B_RDONLY 0x00010 /* read-only tree */
  130. #define B_NODUPS 0x00020 /* no duplicate keys permitted */
  131. #define R_RECNO 0x00080 /* record oriented tree */
  132. #define R_CLOSEFP 0x00040 /* opened a file pointer */
  133. #define R_EOF 0x00100 /* end of input file reached. */
  134. #define R_FIXLEN 0x00200 /* fixed length records */
  135. #define R_MEMMAPPED 0x00400 /* memory mapped file. */
  136. #define R_INMEM 0x00800 /* in-memory file */
  137. #define R_MODIFIED 0x01000 /* modified file */
  138. #define R_RDONLY 0x02000 /* read-only file */
  139. #define B_DB_LOCK 0x04000 /* DB_LOCK specified. */
  140. #define B_DB_SHMEM 0x08000 /* DB_SHMEM specified. */
  141. #define B_DB_TXN 0x10000 /* DB_TXN specified. */
  142. u_int32_t flags;
  143. } BTREE;
  144. void db_btree __P((DB *, int));
  145. void db_hash __P((DB *, int));
  146. void dbt_dump __P((DBT *));
  147. void dbt_print __P((DBT *));
  148. int main __P((int, char *[]));
  149. int usage __P((void));
  150. int
  151. main(argc, argv)
  152. int argc;
  153. char *argv[];
  154. {
  155. extern char *optarg;
  156. extern int optind;
  157. DB *dbp;
  158. DBT key, data;
  159. int ch, pflag, rval;
  160. pflag = 0;
  161. while ((ch = getopt(argc, argv, "f:p")) != EOF)
  162. switch (ch) {
  163. case 'f':
  164. if (freopen(optarg, "w", stdout) == NULL) {
  165. fprintf(stderr, "db_dump185: %s: %sn",
  166.     optarg, strerror(errno));
  167. return (EXIT_FAILURE);
  168. }
  169. break;
  170. case 'p':
  171. pflag = 1;
  172. break;
  173. case '?':
  174. default:
  175. return (usage());
  176. }
  177. argc -= optind;
  178. argv += optind;
  179. if (argc != 1)
  180. return (usage());
  181. if ((dbp = dbopen(argv[0], O_RDONLY, 0, DB_BTREE, NULL)) == NULL) {
  182. if ((dbp =
  183.     dbopen(argv[0], O_RDONLY, 0, DB_HASH, NULL)) == NULL) {
  184. fprintf(stderr,
  185.     "db_dump185: %s: %sn", argv[0], strerror(errno));
  186. return (EXIT_FAILURE);
  187. }
  188. db_hash(dbp, pflag);
  189. } else
  190. db_btree(dbp, pflag);
  191. /*
  192.  * !!!
  193.  * DB 1.85 DBTs are a subset of DB 2.0 DBTs, so we just use the
  194.  * new dump/print routines.
  195.  */
  196. if (pflag)
  197. while (!(rval = dbp->seq(dbp, &key, &data, R_NEXT))) {
  198. dbt_print(&key);
  199. dbt_print(&data);
  200. }
  201. else
  202. while (!(rval = dbp->seq(dbp, &key, &data, R_NEXT))) {
  203. dbt_dump(&key);
  204. dbt_dump(&data);
  205. }
  206. if (rval == -1) {
  207. fprintf(stderr, "db_dump185: seq: %sn", strerror(errno));
  208. return (EXIT_FAILURE);
  209. }
  210. return (EXIT_SUCCESS);
  211. }
  212. /*
  213.  * db_hash --
  214.  * Dump out hash header information.
  215.  */
  216. void
  217. db_hash(dbp, pflag)
  218. DB *dbp;
  219. int pflag;
  220. {
  221. HTAB185 *hash185p;
  222. HTAB186 *hash186p;
  223. printf("format=%sn", pflag ? "print" : "bytevalue");
  224. printf("type=hashn");
  225. /* DB 1.85 was version 2, DB 1.86 was version 3. */
  226. hash185p = dbp->internal;
  227. if (hash185p->hdr.version > 2) {
  228. hash186p = dbp->internal;
  229. printf("h_ffactor=%lun", (u_long)hash186p->hdr.ffactor);
  230. if (hash186p->hdr.lorder != 0)
  231. printf("db_lorder=%lun", (u_long)hash186p->hdr.lorder);
  232. printf("db_pagesize=%lun", (u_long)hash186p->hdr.bsize);
  233. } else {
  234. printf("h_ffactor=%lun", (u_long)hash185p->hdr.ffactor);
  235. if (hash185p->hdr.lorder != 0)
  236. printf("db_lorder=%lun", (u_long)hash185p->hdr.lorder);
  237. printf("db_pagesize=%lun", (u_long)hash185p->hdr.bsize);
  238. }
  239. printf("HEADER=ENDn");
  240. }
  241. /*
  242.  * db_btree --
  243.  * Dump out btree header information.
  244.  */
  245. void
  246. db_btree(dbp, pflag)
  247. DB *dbp;
  248. int pflag;
  249. {
  250. BTREE *btp;
  251. btp = dbp->internal;
  252. printf("format=%sn", pflag ? "print" : "bytevalue");
  253. printf("type=btreen");
  254. #ifdef NOT_AVAILABLE_IN_185
  255. printf("bt_minkey=%lun", (u_long)XXX);
  256. printf("bt_maxkey=%lun", (u_long)XXX);
  257. #endif
  258. if (btp->bt_lorder != 0)
  259. printf("db_lorder=%lun", (u_long)btp->bt_lorder);
  260. printf("db_pagesize=%lun", (u_long)btp->bt_psize);
  261. if (!(btp->flags & B_NODUPS))
  262. printf("duplicates=1n");
  263. printf("HEADER=ENDn");
  264. }
  265. static char hex[] = "0123456789abcdef";
  266. /*
  267.  * dbt_dump --
  268.  * Write out a key or data item using byte values.
  269.  */
  270. void
  271. dbt_dump(dbtp)
  272. DBT *dbtp;
  273. {
  274. size_t len;
  275. u_int8_t *p;
  276. for (len = dbtp->size, p = dbtp->data; len--; ++p)
  277. (void)printf("%c%c",
  278.     hex[(*p & 0xf0) >> 4], hex[*p & 0x0f]);
  279. printf("n");
  280. }
  281. /*
  282.  * dbt_print --
  283.  * Write out a key or data item using printable characters.
  284.  */
  285. void
  286. dbt_print(dbtp)
  287. DBT *dbtp;
  288. {
  289. size_t len;
  290. u_int8_t *p;
  291. for (len = dbtp->size, p = dbtp->data; len--; ++p)
  292. if (isprint((int)*p)) {
  293. if (*p == '\')
  294. (void)printf("\");
  295. (void)printf("%c", *p);
  296. } else
  297. (void)printf("\%c%c",
  298.     hex[(*p & 0xf0) >> 4], hex[*p & 0x0f]);
  299. printf("n");
  300. }
  301. /*
  302.  * usage --
  303.  * Display the usage message.
  304.  */
  305. int
  306. usage()
  307. {
  308. (void)fprintf(stderr, "usage: db_dump185 [-p] [-f file] db_filen");
  309. return (EXIT_FAILURE);
  310. }