开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
db_dump.c
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：14k
源码类别：

MySQL数据库

开发平台：

Visual C++

db_dump.c：源码内容
  1. /*-
  2.  * See the file LICENSE for redistribution information.
  3.  *
  4.  * Copyright (c) 1996-2002
  5.  * Sleepycat Software.  All rights reserved.
  6.  */
  8. #include "db_config.h"
  10. #ifndef lint
  11. static const char copyright[] =
  12.     "Copyright (c) 1996-2002nSleepycat Software Inc.  All rights reserved.n";
  13. static const char revid[] =
  14.     "$Id: db_dump.c,v 11.80 2002/08/08 03:50:34 bostic Exp $";
  15. #endif
  17. #ifndef NO_SYSTEM_INCLUDES
  18. #include <sys/types.h>
  20. #include <stdio.h>
  21. #include <stdlib.h>
  22. #include <string.h>
  23. #include <unistd.h>
  24. #endif
  26. #include "db_int.h"
  27. #include "dbinc/db_page.h"
  28. #include "dbinc/db_am.h"
  30. int  db_init __P((DB_ENV *, char *, int, u_int32_t, int *));
  31. int  dump __P((DB *, int, int));
  32. int  dump_sub __P((DB_ENV *, DB *, char *, int, int));
  33. int  is_sub __P((DB *, int *));
  34. int  main __P((int, char *[]));
  35. int  show_subs __P((DB *));
  36. int  usage __P((void));
  37. int  version_check __P((const char *));
  39. int
  40. main(argc, argv)
  41. int argc;
  42. char *argv[];
  43. {
  44. extern char *optarg;
  45. extern int optind;
  46. const char *progname = "db_dump";
  47. DB_ENV *dbenv;
  48. DB *dbp;
  49. u_int32_t cache;
  50. int ch, d_close;
  51. int e_close, exitval, keyflag, lflag, nflag, pflag, private;
  52. int ret, Rflag, rflag, resize, subs;
  53. char *dopt, *home, *passwd, *subname;
  55. if ((ret = version_check(progname)) != 0)
  56. return (ret);
  58. dbp = NULL;
  59. d_close = e_close = exitval = lflag = nflag = pflag = rflag = Rflag = 0;
  60. keyflag = 0;
  61. cache = MEGABYTE;
  62. private = 0;
  63. dopt = home = passwd = subname = NULL;
  64. while ((ch = getopt(argc, argv, "d:f:h:klNpP:rRs:V")) != EOF)
  65. switch (ch) {
  66. case 'd':
  67. dopt = optarg;
  68. break;
  69. case 'f':
  70. if (freopen(optarg, "w", stdout) == NULL) {
  71. fprintf(stderr, "%s: %s: reopen: %sn",
  72.     progname, optarg, strerror(errno));
  73. return (EXIT_FAILURE);
  74. }
  75. break;
  76. case 'h':
  77. home = optarg;
  78. break;
  79. case 'k':
  80. keyflag = 1;
  81. break;
  82. case 'l':
  83. lflag = 1;
  84. break;
  85. case 'N':
  86. nflag = 1;
  87. break;
  88. case 'P':
  89. passwd = strdup(optarg);
  90. memset(optarg, 0, strlen(optarg));
  91. if (passwd == NULL) {
  92. fprintf(stderr, "%s: strdup: %sn",
  93.     progname, strerror(errno));
  94. return (EXIT_FAILURE);
  95. }
  96. break;
  97. case 'p':
  98. pflag = 1;
  99. break;
  100. case 's':
  101. subname = optarg;
  102. break;
  103. case 'R':
  104. Rflag = 1;
  105. /* DB_AGGRESSIVE requires DB_SALVAGE */
  106. /* FALLTHROUGH */
  107. case 'r':
  108. rflag = 1;
  109. break;
  110. case 'V':
  111. printf("%sn", db_version(NULL, NULL, NULL));
  112. return (EXIT_SUCCESS);
  113. case '?':
  114. default:
  115. return (usage());
  116. }
  117. argc -= optind;
  118. argv += optind;
  120. if (argc != 1)
  121. return (usage());
  123. if (dopt != NULL && pflag) {
  124. fprintf(stderr,
  125.     "%s: the -d and -p options may not both be specifiedn",
  126.     progname);
  127. return (EXIT_FAILURE);
  128. }
  129. if (lflag && subname != NULL) {
  130. fprintf(stderr,
  131.     "%s: the -l and -s options may not both be specifiedn",
  132.     progname);
  133. return (EXIT_FAILURE);
  134. }
  136. if (keyflag && rflag) {
  137. fprintf(stderr, "%s: %s",
  138.     "the -k and -r or -R options may not both be specifiedn",
  139.     progname);
  140. return (EXIT_FAILURE);
  141. }
  143. if (subname != NULL && rflag) {
  144. fprintf(stderr, "%s: %s",
  145.     "the -s and -r or R options may not both be specifiedn",
  146.     progname);
  147. return (EXIT_FAILURE);
  148. }
  150. /* Handle possible interruptions. */
  151. __db_util_siginit();
  153. /*
  154.  * Create an environment object and initialize it for error
  155.  * reporting.
  156.  */
  157. retry: if ((ret = db_env_create(&dbenv, 0)) != 0) {
  158. fprintf(stderr,
  159.     "%s: db_env_create: %sn", progname, db_strerror(ret));
  160. goto err;
  161. }
  162. e_close = 1;
  164. dbenv->set_errfile(dbenv, stderr);
  165. dbenv->set_errpfx(dbenv, progname);
  166. if (nflag) {
  167. if ((ret = dbenv->set_flags(dbenv, DB_NOLOCKING, 1)) != 0) {
  168. dbenv->err(dbenv, ret, "set_flags: DB_NOLOCKING");
  169. goto err;
  170. }
  171. if ((ret = dbenv->set_flags(dbenv, DB_NOPANIC, 1)) != 0) {
  172. dbenv->err(dbenv, ret, "set_flags: DB_NOPANIC");
  173. goto err;
  174. }
  175. }
  176. if (passwd != NULL && (ret = dbenv->set_encrypt(dbenv,
  177.     passwd, DB_ENCRYPT_AES)) != 0) {
  178. dbenv->err(dbenv, ret, "set_passwd");
  179. goto err;
  180. }
  182. /* Initialize the environment. */
  183. if (db_init(dbenv, home, rflag, cache, &private) != 0)
  184. goto err;
  186. /* Create the DB object and open the file. */
  187. if ((ret = db_create(&dbp, dbenv, 0)) != 0) {
  188. dbenv->err(dbenv, ret, "db_create");
  189. goto err;
  190. }
  191. d_close = 1;
  193. /*
  194.  * If we're salvaging, don't do an open;  it might not be safe.
  195.  * Dispatch now into the salvager.
  196.  */
  197. if (rflag) {
  198. if ((ret = dbp->verify(dbp, argv[0], NULL, stdout,
  199.     DB_SALVAGE |
  200.     (Rflag ? DB_AGGRESSIVE : 0) |
  201.     (pflag ? DB_PRINTABLE : 0))) != 0)
  202. goto err;
  203. exitval = 0;
  204. goto done;
  205. }
  207. if ((ret = dbp->open(dbp, NULL,
  208.     argv[0], subname, DB_UNKNOWN, DB_RDONLY, 0)) != 0) {
  209. dbp->err(dbp, ret, "open: %s", argv[0]);
  210. goto err;
  211. }
  212. if (private != 0) {
  213. if ((ret = __db_util_cache(dbenv, dbp, &cache, &resize)) != 0)
  214. goto err;
  215. if (resize) {
  216. (void)dbp->close(dbp, 0);
  217. d_close = 0;
  219. (void)dbenv->close(dbenv, 0);
  220. e_close = 0;
  221. goto retry;
  222. }
  223. }
  225. if (dopt != NULL) {
  226. if (__db_dump(dbp, dopt, NULL)) {
  227. dbp->err(dbp, ret, "__db_dump: %s", argv[0]);
  228. goto err;
  229. }
  230. } else if (lflag) {
  231. if (is_sub(dbp, &subs))
  232. goto err;
  233. if (subs == 0) {
  234. dbp->errx(dbp,
  235.     "%s: does not contain multiple databases", argv[0]);
  236. goto err;
  237. }
  238. if (show_subs(dbp))
  239. goto err;
  240. } else {
  241. subs = 0;
  242. if (subname == NULL && is_sub(dbp, &subs))
  243. goto err;
  244. if (subs) {
  245. if (dump_sub(dbenv, dbp, argv[0], pflag, keyflag))
  246. goto err;
  247. } else
  248. if (__db_prheader(dbp, NULL, pflag, keyflag, stdout,
  249.     __db_verify_callback, NULL, 0) ||
  250.     dump(dbp, pflag, keyflag))
  251. goto err;
  252. }
  254. if (0) {
  255. err: exitval = 1;
  256. }
  257. done: if (d_close && (ret = dbp->close(dbp, 0)) != 0) {
  258. exitval = 1;
  259. dbenv->err(dbenv, ret, "close");
  260. }
  261. if (e_close && (ret = dbenv->close(dbenv, 0)) != 0) {
  262. exitval = 1;
  263. fprintf(stderr,
  264.     "%s: dbenv->close: %sn", progname, db_strerror(ret));
  265. }
  267. /* Resend any caught signal. */
  268. __db_util_sigresend();
  270. return (exitval == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
  271. }
  273. /*
  274.  * db_init --
  275.  * Initialize the environment.
  276.  */
  277. int
  278. db_init(dbenv, home, is_salvage, cache, is_privatep)
  279. DB_ENV *dbenv;
  280. char *home;
  281. int is_salvage;
  282. u_int32_t cache;
  283. int *is_privatep;
  284. {
  285. int ret;
  287. /*
  288.  * Try and use the underlying environment when opening a database.
  289.  * We wish to use the buffer pool so our information is as up-to-date
  290.  * as possible, even if the mpool cache hasn't been flushed.
  291.  *
  292.  * If we are not doing a salvage, we wish to use the DB_JOINENV flag;
  293.  * if a locking system is present, this will let us use it and be
  294.  * safe to run concurrently with other threads of control.  (We never
  295.  * need to use transactions explicitly, as we're read-only.)  Note
  296.  * that in CDB, too, this will configure our environment
  297.  * appropriately, and our cursors will (correctly) do locking as CDB
  298.  * read cursors.
  299.  *
  300.  * If we are doing a salvage, the verification code will protest
  301.  * if we initialize transactions, logging, or locking;  do an
  302.  * explicit DB_INIT_MPOOL to try to join any existing environment
  303.  * before we create our own.
  304.  */
  305. *is_privatep = 0;
  306. if (dbenv->open(dbenv, home,
  307.     DB_USE_ENVIRON | (is_salvage ? DB_INIT_MPOOL : DB_JOINENV), 0) == 0)
  308. return (0);
  310. /*
  311.  * An environment is required because we may be trying to look at
  312.  * databases in directories other than the current one.  We could
  313.  * avoid using an environment iff the -h option wasn't specified,
  314.  * but that seems like more work than it's worth.
  315.  *
  316.  * No environment exists (or, at least no environment that includes
  317.  * an mpool region exists).  Create one, but make it private so that
  318.  * no files are actually created.
  319.  */
  320. *is_privatep = 1;
  321. if ((ret = dbenv->set_cachesize(dbenv, 0, cache, 1)) == 0 &&
  322.     (ret = dbenv->open(dbenv, home,
  323.     DB_CREATE | DB_INIT_MPOOL | DB_PRIVATE | DB_USE_ENVIRON, 0)) == 0)
  324. return (0);
  326. /* An environment is required. */
  327. dbenv->err(dbenv, ret, "open");
  328. return (1);
  329. }
  331. /*
  332.  * is_sub --
  333.  * Return if the database contains subdatabases.
  334.  */
  335. int
  336. is_sub(dbp, yesno)
  337. DB *dbp;
  338. int *yesno;
  339. {
  340. DB_BTREE_STAT *btsp;
  341. DB_HASH_STAT *hsp;
  342. int ret;
  344. switch (dbp->type) {
  345. case DB_BTREE:
  346. case DB_RECNO:
  347. if ((ret = dbp->stat(dbp, &btsp, DB_FAST_STAT)) != 0) {
  348. dbp->err(dbp, ret, "DB->stat");
  349. return (ret);
  350. }
  351. *yesno = btsp->bt_metaflags & BTM_SUBDB ? 1 : 0;
  352. free(btsp);
  353. break;
  354. case DB_HASH:
  355. if ((ret = dbp->stat(dbp, &hsp, DB_FAST_STAT)) != 0) {
  356. dbp->err(dbp, ret, "DB->stat");
  357. return (ret);
  358. }
  359. *yesno = hsp->hash_metaflags & DB_HASH_SUBDB ? 1 : 0;
  360. free(hsp);
  361. break;
  362. case DB_QUEUE:
  363. break;
  364. default:
  365. dbp->errx(dbp, "unknown database type");
  366. return (1);
  367. }
  368. return (0);
  369. }
  371. /*
  372.  * dump_sub --
  373.  * Dump out the records for a DB containing subdatabases.
  374.  */
  375. int
  376. dump_sub(dbenv, parent_dbp, parent_name, pflag, keyflag)
  377. DB_ENV *dbenv;
  378. DB *parent_dbp;
  379. char *parent_name;
  380. int pflag, keyflag;
  381. {
  382. DB *dbp;
  383. DBC *dbcp;
  384. DBT key, data;
  385. int ret;
  386. char *subdb;
  388. /*
  389.  * Get a cursor and step through the database, dumping out each
  390.  * subdatabase.
  391.  */
  392. if ((ret = parent_dbp->cursor(parent_dbp, NULL, &dbcp, 0)) != 0) {
  393. dbenv->err(dbenv, ret, "DB->cursor");
  394. return (1);
  395. }
  397. memset(&key, 0, sizeof(key));
  398. memset(&data, 0, sizeof(data));
  399. while ((ret = dbcp->c_get(dbcp, &key, &data, DB_NEXT)) == 0) {
  400. /* Nul terminate the subdatabase name. */
  401. if ((subdb = malloc(key.size + 1)) == NULL) {
  402. dbenv->err(dbenv, ENOMEM, NULL);
  403. return (1);
  404. }
  405. memcpy(subdb, key.data, key.size);
  406. subdb[key.size] = '';
  408. /* Create the DB object and open the file. */
  409. if ((ret = db_create(&dbp, dbenv, 0)) != 0) {
  410. dbenv->err(dbenv, ret, "db_create");
  411. free(subdb);
  412. return (1);
  413. }
  414. if ((ret = dbp->open(dbp, NULL,
  415.     parent_name, subdb, DB_UNKNOWN, DB_RDONLY, 0)) != 0)
  416. dbp->err(dbp, ret,
  417.     "DB->open: %s:%s", parent_name, subdb);
  418. if (ret == 0 &&
  419.     (__db_prheader(dbp, subdb, pflag, keyflag, stdout,
  420.     __db_verify_callback, NULL, 0) ||
  421.     dump(dbp, pflag, keyflag)))
  422. ret = 1;
  423. (void)dbp->close(dbp, 0);
  424. free(subdb);
  425. if (ret != 0)
  426. return (1);
  427. }
  428. if (ret != DB_NOTFOUND) {
  429. dbp->err(dbp, ret, "DBcursor->get");
  430. return (1);
  431. }
  433. if ((ret = dbcp->c_close(dbcp)) != 0) {
  434. dbp->err(dbp, ret, "DBcursor->close");
  435. return (1);
  436. }
  438. return (0);
  439. }
  441. /*
  442.  * show_subs --
  443.  * Display the subdatabases for a database.
  444.  */
  445. int
  446. show_subs(dbp)
  447. DB *dbp;
  448. {
  449. DBC *dbcp;
  450. DBT key, data;
  451. int ret;
  453. /*
  454.  * Get a cursor and step through the database, printing out the key
  455.  * of each key/data pair.
  456.  */
  457. if ((ret = dbp->cursor(dbp, NULL, &dbcp, 0)) != 0) {
  458. dbp->err(dbp, ret, "DB->cursor");
  459. return (1);
  460. }
  462. memset(&key, 0, sizeof(key));
  463. memset(&data, 0, sizeof(data));
  464. while ((ret = dbcp->c_get(dbcp, &key, &data, DB_NEXT)) == 0) {
  465. if ((ret = __db_prdbt(&key, 1, NULL, stdout,
  466.     __db_verify_callback, 0, NULL)) != 0) {
  467. dbp->errx(dbp, NULL);
  468. return (1);
  469. }
  470. }
  471. if (ret != DB_NOTFOUND) {
  472. dbp->err(dbp, ret, "DBcursor->get");
  473. return (1);
  474. }
  476. if ((ret = dbcp->c_close(dbcp)) != 0) {
  477. dbp->err(dbp, ret, "DBcursor->close");
  478. return (1);
  479. }
  480. return (0);
  481. }
  483. /*
  484.  * dump --
  485.  * Dump out the records for a DB.
  486.  */
  487. int
  488. dump(dbp, pflag, keyflag)
  489. DB *dbp;
  490. int pflag, keyflag;
  491. {
  492. DBC *dbcp;
  493. DBT key, data;
  494. DBT keyret, dataret;
  495. db_recno_t recno;
  496. int is_recno, failed, ret;
  497. void *pointer;
  499. /*
  500.  * Get a cursor and step through the database, printing out each
  501.  * key/data pair.
  502.  */
  503. if ((ret = dbp->cursor(dbp, NULL, &dbcp, 0)) != 0) {
  504. dbp->err(dbp, ret, "DB->cursor");
  505. return (1);
  506. }
  508. failed = 0;
  509. memset(&key, 0, sizeof(key));
  510. memset(&data, 0, sizeof(data));
  511. data.data = malloc(1024 * 1024);
  512. if (data.data == NULL) {
  513. dbp->err(dbp, ENOMEM, "bulk get buffer");
  514. failed = 1;
  515. goto err;
  516. }
  517. data.ulen = 1024 * 1024;
  518. data.flags = DB_DBT_USERMEM;
  519. is_recno = (dbp->type == DB_RECNO || dbp->type == DB_QUEUE);
  520. keyflag = is_recno ? keyflag : 1;
  521. if (is_recno) {
  522. keyret.data = &recno;
  523. keyret.size = sizeof(recno);
  524. }
  526. retry:
  527. while ((ret =
  528.     dbcp->c_get(dbcp, &key, &data, DB_NEXT | DB_MULTIPLE_KEY)) == 0) {
  529. DB_MULTIPLE_INIT(pointer, &data);
  530. for (;;) {
  531. if (is_recno)
  532. DB_MULTIPLE_RECNO_NEXT(pointer, &data,
  533.     recno, dataret.data, dataret.size);
  534. else
  535. DB_MULTIPLE_KEY_NEXT(pointer,
  536.     &data, keyret.data,
  537.     keyret.size, dataret.data, dataret.size);
  539. if (dataret.data == NULL)
  540. break;
  542. if ((keyflag && (ret = __db_prdbt(&keyret,
  543.     pflag, " ", stdout, __db_verify_callback,
  544.     is_recno, NULL)) != 0) || (ret =
  545.     __db_prdbt(&dataret, pflag, " ", stdout,
  546. __db_verify_callback, 0, NULL)) != 0) {
  547. dbp->errx(dbp, NULL);
  548. failed = 1;
  549. goto err;
  550. }
  551. }
  552. }
  553. if (ret == ENOMEM) {
  554. data.data = realloc(data.data, data.size);
  555. if (data.data == NULL) {
  556. dbp->err(dbp, ENOMEM, "bulk get buffer");
  557. failed = 1;
  558. goto err;
  559. }
  560. data.ulen = data.size;
  561. goto retry;
  562. }
  564. if (ret != DB_NOTFOUND) {
  565. dbp->err(dbp, ret, "DBcursor->get");
  566. failed = 1;
  567. }
  569. err: if (data.data != NULL)
  570. free(data.data);
  572. if ((ret = dbcp->c_close(dbcp)) != 0) {
  573. dbp->err(dbp, ret, "DBcursor->close");
  574. failed = 1;
  575. }
  577. (void)__db_prfooter(stdout, __db_verify_callback);
  578. return (failed);
  579. }
  581. /*
  582.  * usage --
  583.  * Display the usage message.
  584.  */
  585. int
  586. usage()
  587. {
  588. (void)fprintf(stderr, "%snt%sn",
  589.     "usage: db_dump [-klNprRV]",
  590.     "[-d ahr] [-f output] [-h home] [-P password] [-s database] db_file");
  591. return (EXIT_FAILURE);
  592. }
  594. int
  595. version_check(progname)
  596. const char *progname;
  597. {
  598. int v_major, v_minor, v_patch;
  600. /* Make sure we're loaded with the right version of the DB library. */
  601. (void)db_version(&v_major, &v_minor, &v_patch);
  602. if (v_major != DB_VERSION_MAJOR ||
  603.     v_minor != DB_VERSION_MINOR || v_patch != DB_VERSION_PATCH) {
  604. fprintf(stderr,
  605. "%s: version %d.%d.%d doesn't match library version %d.%d.%dn",
  606.     progname, DB_VERSION_MAJOR, DB_VERSION_MINOR,
  607.     DB_VERSION_PATCH, v_major, v_minor, v_patch);
  608. return (EXIT_FAILURE);
  609. }
  610. return (0);
  611. }