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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
db_dump.c
资源名称：mysql-3.23.35.tar.gz　[点击查看]
上传用户：tsgydb
上传日期：2007-04-14
资源大小：10674k
文件大小：11k
源码类别：

MySQL数据库

开发平台：

Visual C++

db_dump.c：源码内容
  1. /*-
  2.  * See the file LICENSE for redistribution information.
  3.  *
  4.  * Copyright (c) 1996, 1997, 1998, 1999, 2000
  5.  * Sleepycat Software.  All rights reserved.
  6.  */
  8. #include "db_config.h"
  10. #ifndef lint
  11. static const char copyright[] =
  12.     "Copyright (c) 1996-2000nSleepycat Software Inc.  All rights reserved.n";
  13. static const char revid[] =
  14.     "$Id: db_dump.c,v 11.41 2001/01/18 18:36:57 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 "db_page.h"
  28. #include "db_shash.h"
  29. #include "btree.h"
  30. #include "hash.h"
  31. #include "lock.h"
  33. void  configure __P((char *));
  34. int  db_init __P((char *));
  35. int  dump __P((DB *, int, int));
  36. int  dump_sub __P((DB *, char *, int, int));
  37. int  is_sub __P((DB *, int *));
  38. int  main __P((int, char *[]));
  39. int  show_subs __P((DB *));
  40. void  usage __P((void));
  41. void  version_check __P((void));
  43. DB_ENV *dbenv;
  44. const char
  45. *progname = "db_dump"; /* Program name. */
  47. int
  48. main(argc, argv)
  49. int argc;
  50. char *argv[];
  51. {
  52. extern char *optarg;
  53. extern int optind;
  54. DB *dbp;
  55. int ch, d_close;
  56. int e_close, exitval;
  57. int lflag, nflag, pflag, ret, rflag, Rflag, subs, keyflag;
  58. char *dopt, *home, *subname;
  60. version_check();
  62. dbp = NULL;
  63. d_close = e_close = exitval = lflag = nflag = pflag = rflag = Rflag = 0;
  64. keyflag = 0;
  65. dopt = home = subname = NULL;
  66. while ((ch = getopt(argc, argv, "d:f:h:klNprRs:V")) != EOF)
  67. switch (ch) {
  68. case 'd':
  69. dopt = optarg;
  70. break;
  71. case 'f':
  72. if (freopen(optarg, "w", stdout) == NULL) {
  73. fprintf(stderr, "%s: %s: reopen: %sn",
  74.     progname, optarg, strerror(errno));
  75. exit (1);
  76. }
  77. break;
  78. case 'h':
  79. home = optarg;
  80. break;
  81. case 'k':
  82. keyflag = 1;
  83. break;
  84. case 'l':
  85. lflag = 1;
  86. break;
  87. case 'N':
  88. nflag = 1;
  89. if ((ret = db_env_set_panicstate(0)) != 0) {
  90. fprintf(stderr,
  91.     "%s: db_env_set_panicstate: %sn",
  92.     progname, db_strerror(ret));
  93. return (1);
  94. }
  95. break;
  96. case 'p':
  97. pflag = 1;
  98. break;
  99. case 's':
  100. subname = optarg;
  101. break;
  102. case 'R':
  103. Rflag = 1;
  104. /* DB_AGGRESSIVE requires DB_SALVAGE */
  105. /* FALLTHROUGH */
  106. case 'r':
  107. rflag = 1;
  108. break;
  109. case 'V':
  110. printf("%sn", db_version(NULL, NULL, NULL));
  111. exit(0);
  112. case '?':
  113. default:
  114. usage();
  115. }
  116. argc -= optind;
  117. argv += optind;
  119. if (argc != 1)
  120. usage();
  122. if (dopt != NULL && pflag) {
  123. fprintf(stderr,
  124.     "%s: the -d and -p options may not both be specifiedn",
  125.     progname);
  126. exit (1);
  127. }
  128. if (lflag && subname != NULL) {
  129. fprintf(stderr,
  130.     "%s: the -l and -s options may not both be specifiedn",
  131.     progname);
  132. exit (1);
  133. }
  135. if (keyflag && rflag) {
  136. fprintf(stderr, "%s: %s",
  137.     "the -k and -r or -R options may not both be specifiedn",
  138.     progname);
  139. exit(1);
  140. }
  142. if (subname != NULL && rflag) {
  143. fprintf(stderr, "%s: %s",
  144.     "the -s and -r or R options may not both be specifiedn",
  145.     progname);
  146. exit(1);
  147. }
  149. /* Handle possible interruptions. */
  150. __db_util_siginit();
  152. /*
  153.  * Create an environment object and initialize it for error
  154.  * reporting.
  155.  */
  156. if ((ret = db_env_create(&dbenv, 0)) != 0) {
  157. fprintf(stderr,
  158.     "%s: db_env_create: %sn", progname, db_strerror(ret));
  159. goto err;
  160. }
  161. e_close = 1;
  163. dbenv->set_errfile(dbenv, stderr);
  164. dbenv->set_errpfx(dbenv, progname);
  166. if (nflag && (ret = dbenv->set_mutexlocks(dbenv, 0)) != 0) {
  167. dbenv->err(dbenv, ret, "set_mutexlocks");
  168. goto err;
  169. }
  171. /* Initialize the environment. */
  172. if (db_init(home) != 0)
  173. goto err;
  175. /* Create the DB object and open the file. */
  176. if ((ret = db_create(&dbp, dbenv, 0)) != 0) {
  177. dbenv->err(dbenv, ret, "db_create");
  178. goto err;
  179. }
  180. d_close = 1;
  182. /*
  183.  * If we're salvaging, don't do an open;  it might not be safe.
  184.  * Dispatch now into the salvager.
  185.  */
  186. if (rflag) {
  187. if ((ret = dbp->verify(dbp, argv[0], NULL, stdout,
  188.     DB_SALVAGE | (Rflag ? DB_AGGRESSIVE : 0))) != 0)
  189. goto err;
  190. exitval = 0;
  191. goto done;
  192. }
  194. if ((ret = dbp->open(dbp,
  195.     argv[0], subname, DB_UNKNOWN, DB_RDONLY, 0)) != 0) {
  196. dbp->err(dbp, ret, "open: %s", argv[0]);
  197. goto err;
  198. }
  200. if (dopt != NULL) {
  201. if (__db_dump(dbp, dopt, NULL)) {
  202. dbp->err(dbp, ret, "__db_dump: %s", argv[0]);
  203. goto err;
  204. }
  205. } else if (lflag) {
  206. if (is_sub(dbp, &subs))
  207. goto err;
  208. if (subs == 0) {
  209. dbp->errx(dbp,
  210.     "%s: does not contain multiple databases", argv[0]);
  211. goto err;
  212. }
  213. if (show_subs(dbp))
  214. goto err;
  215. } else {
  216. subs = 0;
  217. if (subname == NULL && is_sub(dbp, &subs))
  218. goto err;
  219. if (subs) {
  220. if (dump_sub(dbp, argv[0], pflag, keyflag))
  221. goto err;
  222. } else
  223. if (__db_prheader(dbp, NULL, pflag, keyflag, stdout,
  224.     __db_verify_callback, NULL, 0) ||
  225.     dump(dbp, pflag, keyflag))
  226. goto err;
  227. }
  229. if (0) {
  230. err: exitval = 1;
  231. }
  232. done: if (d_close && (ret = dbp->close(dbp, 0)) != 0) {
  233. exitval = 1;
  234. dbp->err(dbp, ret, "close");
  235. }
  236. if (e_close && (ret = dbenv->close(dbenv, 0)) != 0) {
  237. exitval = 1;
  238. fprintf(stderr,
  239.     "%s: dbenv->close: %sn", progname, db_strerror(ret));
  240. }
  242. /* Resend any caught signal. */
  243. __db_util_sigresend();
  245. return (exitval);
  246. }
  248. /*
  249.  * db_init --
  250.  * Initialize the environment.
  251.  */
  252. int
  253. db_init(home)
  254. char *home;
  255. {
  256. int ret;
  258. /*
  259.  * Try and use the underlying environment when opening a database.  We
  260.  * wish to use the buffer pool so our information is as up-to-date as
  261.  * possible, even if the mpool cache hasn't been flushed;  we wish to
  262.  * use the locking system, if present, so that we are safe to use with
  263.  * transactions.  (We don't need to use transactions explicitly, as
  264.  * we're read-only.)
  265.  *
  266.  * Note that in CDB, too, this will configure our environment
  267.  * appropriately, and our cursors will (correctly) do locking as CDB
  268.  * read cursors.
  269.  */
  270. if (dbenv->open(dbenv, home, DB_JOINENV | DB_USE_ENVIRON, 0) == 0)
  271. return (0);
  273. /*
  274.  * An environment is required because we may be trying to look at
  275.  * databases in directories other than the current one.  We could
  276.  * avoid using an environment iff the -h option wasn't specified,
  277.  * but that seems like more work than it's worth.
  278.  *
  279.  * No environment exists (or, at least no environment that includes
  280.  * an mpool region exists).  Create one, but make it private so that
  281.  * no files are actually created.
  282.  */
  283. if ((ret = dbenv->open(dbenv, home,
  284.     DB_CREATE | DB_INIT_MPOOL | DB_PRIVATE | DB_USE_ENVIRON, 0)) == 0)
  285. return (0);
  287. /* An environment is required. */
  288. dbenv->err(dbenv, ret, "open");
  289. return (1);
  290. }
  292. /*
  293.  * is_sub --
  294.  * Return if the database contains subdatabases.
  295.  */
  296. int
  297. is_sub(dbp, yesno)
  298. DB *dbp;
  299. int *yesno;
  300. {
  301. DB_BTREE_STAT *btsp;
  302. DB_HASH_STAT *hsp;
  303. int ret;
  305. switch (dbp->type) {
  306. case DB_BTREE:
  307. case DB_RECNO:
  308. if ((ret = dbp->stat(dbp, &btsp, NULL, 0)) != 0) {
  309. dbp->err(dbp, ret, "DB->stat");
  310. return (ret);
  311. }
  312. *yesno = btsp->bt_metaflags & BTM_SUBDB ? 1 : 0;
  313. break;
  314. case DB_HASH:
  315. if ((ret = dbp->stat(dbp, &hsp, NULL, 0)) != 0) {
  316. dbp->err(dbp, ret, "DB->stat");
  317. return (ret);
  318. }
  319. *yesno = hsp->hash_metaflags & DB_HASH_SUBDB ? 1 : 0;
  320. break;
  321. case DB_QUEUE:
  322. break;
  323. default:
  324. dbp->errx(dbp, "unknown database type");
  325. return (1);
  326. }
  327. return (0);
  328. }
  330. /*
  331.  * dump_sub --
  332.  * Dump out the records for a DB containing subdatabases.
  333.  */
  334. int
  335. dump_sub(parent_dbp, parent_name, pflag, keyflag)
  336. DB *parent_dbp;
  337. char *parent_name;
  338. int pflag, keyflag;
  339. {
  340. DB *dbp;
  341. DBC *dbcp;
  342. DBT key, data;
  343. int ret;
  344. char *subdb;
  346. /*
  347.  * Get a cursor and step through the database, dumping out each
  348.  * subdatabase.
  349.  */
  350. if ((ret = parent_dbp->cursor(parent_dbp, NULL, &dbcp, 0)) != 0) {
  351. dbenv->err(dbenv, ret, "DB->cursor");
  352. return (1);
  353. }
  355. memset(&key, 0, sizeof(key));
  356. memset(&data, 0, sizeof(data));
  357. while ((ret = dbcp->c_get(dbcp, &key, &data, DB_NEXT)) == 0) {
  358. /* Nul terminate the subdatabase name. */
  359. if ((subdb = malloc(key.size + 1)) == NULL) {
  360. dbenv->err(dbenv, ENOMEM, NULL);
  361. return (1);
  362. }
  363. memcpy(subdb, key.data, key.size);
  364. subdb[key.size] = '';
  366. /* Create the DB object and open the file. */
  367. if ((ret = db_create(&dbp, dbenv, 0)) != 0) {
  368. dbenv->err(dbenv, ret, "db_create");
  369. free(subdb);
  370. return (1);
  371. }
  372. if ((ret = dbp->open(dbp,
  373.     parent_name, subdb, DB_UNKNOWN, DB_RDONLY, 0)) != 0)
  374. dbp->err(dbp, ret,
  375.     "DB->open: %s:%s", parent_name, subdb);
  376. if (ret == 0 &&
  377.     (__db_prheader(dbp, subdb, pflag, keyflag, stdout,
  378.     __db_verify_callback, NULL, 0) ||
  379.     dump(dbp, pflag, keyflag)))
  380. ret = 1;
  381. (void)dbp->close(dbp, 0);
  382. free(subdb);
  383. if (ret != 0)
  384. return (1);
  385. }
  386. if (ret != DB_NOTFOUND) {
  387. dbp->err(dbp, ret, "DBcursor->get");
  388. return (1);
  389. }
  391. if ((ret = dbcp->c_close(dbcp)) != 0) {
  392. dbp->err(dbp, ret, "DBcursor->close");
  393. return (1);
  394. }
  396. return (0);
  397. }
  399. /*
  400.  * show_subs --
  401.  * Display the subdatabases for a database.
  402.  */
  403. int
  404. show_subs(dbp)
  405. DB *dbp;
  406. {
  407. DBC *dbcp;
  408. DBT key, data;
  409. int ret;
  411. /*
  412.  * Get a cursor and step through the database, printing out the key
  413.  * of each key/data pair.
  414.  */
  415. if ((ret = dbp->cursor(dbp, NULL, &dbcp, 0)) != 0) {
  416. dbp->err(dbp, ret, "DB->cursor");
  417. return (1);
  418. }
  420. memset(&key, 0, sizeof(key));
  421. memset(&data, 0, sizeof(data));
  422. while ((ret = dbcp->c_get(dbcp, &key, &data, DB_NEXT)) == 0) {
  423. if ((ret = __db_prdbt(&key, 1, NULL, stdout,
  424.     __db_verify_callback, 0, NULL)) != 0) {
  425. dbp->errx(dbp, NULL);
  426. return (1);
  427. }
  428. }
  429. if (ret != DB_NOTFOUND) {
  430. dbp->err(dbp, ret, "DBcursor->get");
  431. return (1);
  432. }
  434. if ((ret = dbcp->c_close(dbcp)) != 0) {
  435. dbp->err(dbp, ret, "DBcursor->close");
  436. return (1);
  437. }
  438. return (0);
  439. }
  441. /*
  442.  * dump --
  443.  * Dump out the records for a DB.
  444.  */
  445. int
  446. dump(dbp, pflag, keyflag)
  447. DB *dbp;
  448. int pflag, keyflag;
  449. {
  450. DBC *dbcp;
  451. DBT key, data;
  452. int ret, is_recno;
  454. /*
  455.  * Get a cursor and step through the database, printing out each
  456.  * key/data pair.
  457.  */
  458. if ((ret = dbp->cursor(dbp, NULL, &dbcp, 0)) != 0) {
  459. dbp->err(dbp, ret, "DB->cursor");
  460. return (1);
  461. }
  463. memset(&key, 0, sizeof(key));
  464. memset(&data, 0, sizeof(data));
  465. is_recno = (dbp->type == DB_RECNO || dbp->type == DB_QUEUE);
  466. keyflag = is_recno ? keyflag : 1;
  467. while ((ret = dbcp->c_get(dbcp, &key, &data, DB_NEXT)) == 0)
  468. if ((keyflag && (ret = __db_prdbt(&key,
  469.     pflag, " ", stdout, __db_verify_callback,
  470.     is_recno, NULL)) != 0) || (ret =
  471.     __db_prdbt(&data, pflag, " ", stdout,
  472. __db_verify_callback, 0, NULL)) != 0) {
  473. dbp->errx(dbp, NULL);
  474. return (1);
  475. }
  476. if (ret != DB_NOTFOUND) {
  477. dbp->err(dbp, ret, "DBcursor->get");
  478. return (1);
  479. }
  481. if ((ret = dbcp->c_close(dbcp)) != 0) {
  482. dbp->err(dbp, ret, "DBcursor->close");
  483. return (1);
  484. }
  486. (void)__db_prfooter(stdout, __db_verify_callback);
  487. return (0);
  488. }
  490. /*
  491.  * usage --
  492.  * Display the usage message.
  493.  */
  494. void
  495. usage()
  496. {
  497. (void)fprintf(stderr, "usage: %sn",
  498. "db_dump [-klNprRV] [-d ahr] [-f output] [-h home] [-s database] db_file");
  499. exit(1);
  500. }
  502. void
  503. version_check()
  504. {
  505. int v_major, v_minor, v_patch;
  507. /* Make sure we're loaded with the right version of the DB library. */
  508. (void)db_version(&v_major, &v_minor, &v_patch);
  509. if (v_major != DB_VERSION_MAJOR ||
  510.     v_minor != DB_VERSION_MINOR || v_patch != DB_VERSION_PATCH) {
  511. fprintf(stderr,
  512. "%s: version %d.%d.%d doesn't match library version %d.%d.%dn",
  513.     progname, DB_VERSION_MAJOR, DB_VERSION_MINOR,
  514.     DB_VERSION_PATCH, v_major, v_minor, v_patch);
  515. exit (1);
  516. }
  517. }