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

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

MySQL数据库

开发平台：

Visual C++

bt_stat.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 revid[] = "$Id: bt_stat.c,v 11.29 2000/11/28 21:42:27 bostic Exp $";
  12. #endif /* not lint */
  14. #ifndef NO_SYSTEM_INCLUDES
  15. #include <sys/types.h>
  17. #include <string.h>
  18. #endif
  20. #include "db_int.h"
  21. #include "db_page.h"
  22. #include "db_shash.h"
  23. #include "lock.h"
  24. #include "btree.h"
  26. /*
  27.  * __bam_stat --
  28.  * Gather/print the btree statistics
  29.  *
  30.  * PUBLIC: int __bam_stat __P((DB *, void *, void *(*)(size_t), u_int32_t));
  31.  */
  32. int
  33. __bam_stat(dbp, spp, db_malloc, flags)
  34. DB *dbp;
  35. void *spp;
  36. void *(*db_malloc) __P((size_t));
  37. u_int32_t flags;
  38. {
  39. BTMETA *meta;
  40. BTREE *t;
  41. BTREE_CURSOR *cp;
  42. DBC *dbc;
  43. DB_BTREE_STAT *sp;
  44. DB_LOCK lock, metalock;
  45. PAGE *h;
  46. db_pgno_t pgno;
  47. int ret, t_ret;
  49. PANIC_CHECK(dbp->dbenv);
  50. DB_ILLEGAL_BEFORE_OPEN(dbp, "DB->stat");
  52. meta = NULL;
  53. t = dbp->bt_internal;
  54. sp = NULL;
  55. metalock.off = lock.off = LOCK_INVALID;
  56. h = NULL;
  57. ret = 0;
  59. /* Check for invalid flags. */
  60. if ((ret = __db_statchk(dbp, flags)) != 0)
  61. return (ret);
  63. /* Acquire a cursor. */
  64. if ((ret = dbp->cursor(dbp, NULL, &dbc, 0)) != 0)
  65. return (ret);
  66. cp = (BTREE_CURSOR *)dbc->internal;
  68. DEBUG_LWRITE(dbc, NULL, "bam_stat", NULL, NULL, flags);
  70. /* Allocate and clear the structure. */
  71. if ((ret = __os_malloc(dbp->dbenv, sizeof(*sp), db_malloc, &sp)) != 0)
  72. goto err;
  73. memset(sp, 0, sizeof(*sp));
  75. /* If the app just wants the record count, make it fast. */
  76. if (flags == DB_RECORDCOUNT) {
  77. if ((ret = __db_lget(dbc, 0,
  78.     cp->root, DB_LOCK_READ, 0, &lock)) != 0)
  79. goto err;
  80. if ((ret = memp_fget(dbp->mpf,
  81.     &cp->root, 0, (PAGE **)&h)) != 0)
  82. goto err;
  84. sp->bt_nkeys = RE_NREC(h);
  86. goto done;
  87. }
  88. if (flags == DB_CACHED_COUNTS) {
  89. if ((ret = __db_lget(dbc,
  90.     0, t->bt_meta, DB_LOCK_READ, 0, &lock)) != 0)
  91. goto err;
  92. if ((ret =
  93.     memp_fget(dbp->mpf, &t->bt_meta, 0, (PAGE **)&meta)) != 0)
  94. goto err;
  95. sp->bt_nkeys = meta->dbmeta.key_count;
  96. sp->bt_ndata = meta->dbmeta.record_count;
  98. goto done;
  99. }
  101. /* Get the metadata page for the entire database. */
  102. pgno = PGNO_BASE_MD;
  103. if ((ret = __db_lget(dbc, 0, pgno, DB_LOCK_READ, 0, &metalock)) != 0)
  104. goto err;
  105. if ((ret = memp_fget(dbp->mpf, &pgno, 0, (PAGE **)&meta)) != 0)
  106. goto err;
  108. /* Walk the metadata free list, counting pages. */
  109. for (sp->bt_free = 0, pgno = meta->dbmeta.free; pgno != PGNO_INVALID;) {
  110. ++sp->bt_free;
  112. if ((ret = memp_fget(dbp->mpf, &pgno, 0, &h)) != 0)
  113. goto err;
  115. pgno = h->next_pgno;
  116. if ((ret = memp_fput(dbp->mpf, h, 0)) != 0)
  117. goto err;
  118. h = NULL;
  119. }
  121. /* Get the root page. */
  122. pgno = cp->root;
  123. if ((ret = __db_lget(dbc, 0, pgno, DB_LOCK_READ, 0, &lock)) != 0)
  124. goto err;
  125. if ((ret = memp_fget(dbp->mpf, &pgno, 0, &h)) != 0)
  126. goto err;
  128. /* Get the levels from the root page. */
  129. sp->bt_levels = h->level;
  131. /* Discard the root page. */
  132. if ((ret = memp_fput(dbp->mpf, h, 0)) != 0)
  133. goto err;
  134. h = NULL;
  135. __LPUT(dbc, lock);
  137. /* Walk the tree. */
  138. if ((ret = __bam_traverse(dbc,
  139.     DB_LOCK_READ, cp->root, __bam_stat_callback, sp)) != 0)
  140. goto err;
  142. /*
  143.  * Get the subdatabase metadata page if it's not the same as the
  144.  * one we already have.
  145.  */
  146. if (t->bt_meta != PGNO_BASE_MD || !F_ISSET(dbp, DB_AM_RDONLY)) {
  147. if ((ret = memp_fput(dbp->mpf, meta, 0)) != 0)
  148. goto err;
  149. meta = NULL;
  150. __LPUT(dbc, metalock);
  152. if ((ret = __db_lget(dbc,
  153.     0, t->bt_meta, F_ISSET(dbp, DB_AM_RDONLY) ?
  154.     DB_LOCK_READ : DB_LOCK_WRITE, 0, &metalock)) != 0)
  155. goto err;
  156. if ((ret =
  157.     memp_fget(dbp->mpf, &t->bt_meta, 0, (PAGE **)&meta)) != 0)
  158. goto err;
  159. }
  161. /* Get metadata page statistics. */
  162. sp->bt_metaflags = meta->dbmeta.flags;
  163. sp->bt_maxkey = meta->maxkey;
  164. sp->bt_minkey = meta->minkey;
  165. sp->bt_re_len = meta->re_len;
  166. sp->bt_re_pad = meta->re_pad;
  167. sp->bt_pagesize = meta->dbmeta.pagesize;
  168. sp->bt_magic = meta->dbmeta.magic;
  169. sp->bt_version = meta->dbmeta.version;
  170. if (!F_ISSET(dbp, DB_AM_RDONLY)) {
  171. meta->dbmeta.key_count = sp->bt_nkeys;
  172. meta->dbmeta.record_count = sp->bt_ndata;
  173. }
  175. /* Discard the metadata page. */
  176. if ((ret = memp_fput(dbp->mpf,
  177.     meta, F_ISSET(dbp, DB_AM_RDONLY) ? 0 : DB_MPOOL_DIRTY)) != 0)
  178. goto err;
  179. meta = NULL;
  180. __LPUT(dbc, metalock);
  182. done: *(DB_BTREE_STAT **)spp = sp;
  184. if (0) {
  185. err: if (sp != NULL)
  186. __os_free(sp, sizeof(*sp));
  187. }
  189. if (h != NULL &&
  190.     (t_ret = memp_fput(dbp->mpf, h, 0)) != 0 && ret == 0)
  191. ret = t_ret;
  193. if (meta != NULL &&
  194.     (t_ret = memp_fput(dbp->mpf, meta, 0)) != 0 && ret == 0)
  195. ret = t_ret;
  197. if (lock.off != LOCK_INVALID)
  198. __LPUT(dbc, lock);
  200. if ((t_ret = dbc->c_close(dbc)) != 0 && ret == 0)
  201. ret = t_ret;
  203. return (ret);
  204. }
  206. /*
  207.  * __bam_traverse --
  208.  * Walk a Btree database.
  209.  *
  210.  * PUBLIC: int __bam_traverse __P((DBC *, db_lockmode_t,
  211.  * PUBLIC:     db_pgno_t, int (*)(DB *, PAGE *, void *, int *), void *));
  212.  */
  213. int
  214. __bam_traverse(dbc, mode, root_pgno, callback, cookie)
  215. DBC *dbc;
  216. db_lockmode_t mode;
  217. db_pgno_t root_pgno;
  218. int (*callback)__P((DB *, PAGE *, void *, int *));
  219. void *cookie;
  220. {
  221. BINTERNAL *bi;
  222. BKEYDATA *bk;
  223. DB *dbp;
  224. DB_LOCK lock;
  225. PAGE *h;
  226. RINTERNAL *ri;
  227. db_indx_t indx;
  228. int already_put, ret, t_ret;
  230. dbp = dbc->dbp;
  232. if ((ret = __db_lget(dbc, 0, root_pgno, mode, 0, &lock)) != 0)
  233. return (ret);
  234. if ((ret = memp_fget(dbp->mpf, &root_pgno, 0, &h)) != 0)
  235. goto err;
  237. switch (TYPE(h)) {
  238. case P_IBTREE:
  239. for (indx = 0; indx < NUM_ENT(h); indx += O_INDX) {
  240. bi = GET_BINTERNAL(h, indx);
  241. if (B_TYPE(bi->type) == B_OVERFLOW &&
  242.     (ret = __db_traverse_big(dbp,
  243.     ((BOVERFLOW *)bi->data)->pgno,
  244.     callback, cookie)) != 0)
  245. goto err;
  246. if ((ret = __bam_traverse(
  247.     dbc, mode, bi->pgno, callback, cookie)) != 0)
  248. break;
  249. }
  250. break;
  251. case P_IRECNO:
  252. for (indx = 0; indx < NUM_ENT(h); indx += O_INDX) {
  253. ri = GET_RINTERNAL(h, indx);
  254. if ((ret = __bam_traverse(
  255.     dbc, mode, ri->pgno, callback, cookie)) != 0)
  256. break;
  257. }
  258. break;
  259. case P_LBTREE:
  260. for (indx = 0; indx < NUM_ENT(h); indx += P_INDX) {
  261. bk = GET_BKEYDATA(h, indx);
  262. if (B_TYPE(bk->type) == B_OVERFLOW &&
  263.     (ret = __db_traverse_big(dbp,
  264.     GET_BOVERFLOW(h, indx)->pgno,
  265.     callback, cookie)) != 0)
  266. goto err;
  267. bk = GET_BKEYDATA(h, indx + O_INDX);
  268. if (B_TYPE(bk->type) == B_DUPLICATE &&
  269.     (ret = __bam_traverse(dbc, mode,
  270.     GET_BOVERFLOW(h, indx + O_INDX)->pgno,
  271.     callback, cookie)) != 0)
  272. goto err;
  273. if (B_TYPE(bk->type) == B_OVERFLOW &&
  274.     (ret = __db_traverse_big(dbp,
  275.     GET_BOVERFLOW(h, indx + O_INDX)->pgno,
  276.     callback, cookie)) != 0)
  277. goto err;
  278. }
  279. break;
  280. case P_LDUP:
  281. case P_LRECNO:
  282. for (indx = 0; indx < NUM_ENT(h); indx += O_INDX) {
  283. bk = GET_BKEYDATA(h, indx);
  284. if (B_TYPE(bk->type) == B_OVERFLOW &&
  285.     (ret = __db_traverse_big(dbp,
  286.     GET_BOVERFLOW(h, indx)->pgno,
  287.     callback, cookie)) != 0)
  288. goto err;
  289. }
  290. break;
  291. }
  293. already_put = 0;
  294. if ((ret = callback(dbp, h, cookie, &already_put)) != 0)
  295. goto err;
  297. err: if (!already_put &&
  298.     (t_ret = memp_fput(dbp->mpf, h, 0)) != 0 && ret != 0)
  299. ret = t_ret;
  300. __LPUT(dbc, lock);
  302. return (ret);
  303. }
  305. /*
  306.  * __bam_stat_callback --
  307.  * Statistics callback.
  308.  *
  309.  * PUBLIC: int __bam_stat_callback __P((DB *, PAGE *, void *, int *));
  310.  */
  311. int
  312. __bam_stat_callback(dbp, h, cookie, putp)
  313. DB *dbp;
  314. PAGE *h;
  315. void *cookie;
  316. int *putp;
  317. {
  318. DB_BTREE_STAT *sp;
  319. db_indx_t indx, top;
  320. u_int8_t type;
  322. sp = cookie;
  323. *putp = 0;
  324. top = NUM_ENT(h);
  326. switch (TYPE(h)) {
  327. case P_IBTREE:
  328. case P_IRECNO:
  329. ++sp->bt_int_pg;
  330. sp->bt_int_pgfree += P_FREESPACE(h);
  331. break;
  332. case P_LBTREE:
  333. /* Correct for on-page duplicates and deleted items. */
  334. for (indx = 0; indx < top; indx += P_INDX) {
  335. if (indx + P_INDX >= top ||
  336.     h->inp[indx] != h->inp[indx + P_INDX])
  337. ++sp->bt_nkeys;
  339. type = GET_BKEYDATA(h, indx + O_INDX)->type;
  340. if (!B_DISSET(type) && B_TYPE(type) != B_DUPLICATE)
  341. ++sp->bt_ndata;
  342. }
  344. ++sp->bt_leaf_pg;
  345. sp->bt_leaf_pgfree += P_FREESPACE(h);
  346. break;
  347. case P_LRECNO:
  348. /*
  349.  * If walking a recno tree, then each of these items is a key.
  350.  * Otherwise, we're walking an off-page duplicate set.
  351.  */
  352. if (dbp->type == DB_RECNO) {
  353. sp->bt_nkeys += top;
  355. /*
  356.  * Correct for deleted items in non-renumbering
  357.  * Recno databases.
  358.  */
  359. if (F_ISSET(dbp, DB_RE_RENUMBER))
  360. sp->bt_ndata += top;
  361. else
  362. for (indx = 0; indx < top; indx += O_INDX) {
  363. type = GET_BKEYDATA(h, indx)->type;
  364. if (!B_DISSET(type))
  365. ++sp->bt_ndata;
  366. }
  368. ++sp->bt_leaf_pg;
  369. sp->bt_leaf_pgfree += P_FREESPACE(h);
  370. } else {
  371. sp->bt_ndata += top;
  373. ++sp->bt_dup_pg;
  374. sp->bt_dup_pgfree += P_FREESPACE(h);
  375. }
  376. break;
  377. case P_LDUP:
  378. /* Correct for deleted items. */
  379. for (indx = 0; indx < top; indx += O_INDX)
  380. if (!B_DISSET(GET_BKEYDATA(h, indx)->type))
  381. ++sp->bt_ndata;
  383. ++sp->bt_dup_pg;
  384. sp->bt_dup_pgfree += P_FREESPACE(h);
  385. break;
  386. case P_OVERFLOW:
  387. ++sp->bt_over_pg;
  388. sp->bt_over_pgfree += P_OVFLSPACE(dbp->pgsize, h);
  389. break;
  390. default:
  391. return (__db_pgfmt(dbp, h->pgno));
  392. }
  393. return (0);
  394. }
  396. /*
  397.  * __bam_key_range --
  398.  * Return proportion of keys relative to given key.  The numbers are
  399.  * slightly skewed due to on page duplicates.
  400.  *
  401.  * PUBLIC: int __bam_key_range __P((DB *,
  402.  * PUBLIC:     DB_TXN *, DBT *, DB_KEY_RANGE *, u_int32_t));
  403.  */
  404. int
  405. __bam_key_range(dbp, txn, dbt, kp, flags)
  406. DB *dbp;
  407. DB_TXN *txn;
  408. DBT *dbt;
  409. DB_KEY_RANGE *kp;
  410. u_int32_t flags;
  411. {
  412. BTREE_CURSOR *cp;
  413. DBC *dbc;
  414. EPG *sp;
  415. double factor;
  416. int exact, ret, t_ret;
  418. PANIC_CHECK(dbp->dbenv);
  419. DB_ILLEGAL_BEFORE_OPEN(dbp, "DB->key_range");
  421. if (flags != 0)
  422. return (__db_ferr(dbp->dbenv, "DB->key_range", 0));
  424. /* Acquire a cursor. */
  425. if ((ret = dbp->cursor(dbp, txn, &dbc, 0)) != 0)
  426. return (ret);
  428. DEBUG_LWRITE(dbc, NULL, "bam_key_range", NULL, NULL, 0);
  430. if ((ret = __bam_search(dbc, dbt, S_STK_ONLY, 1, NULL, &exact)) != 0)
  431. goto err;
  433. cp = (BTREE_CURSOR *)dbc->internal;
  434. kp->less = kp->greater = 0.0;
  436. factor = 1.0;
  437. /* Correct the leaf page. */
  438. cp->csp->entries /= 2;
  439. cp->csp->indx /= 2;
  440. for (sp = cp->sp; sp <= cp->csp; ++sp) {
  441. /*
  442.  * At each level we know that pages greater than indx contain
  443.  * keys greater than what we are looking for and those less
  444.  * than indx are less than.  The one pointed to by indx may
  445.  * have some less, some greater or even equal.  If indx is
  446.  * equal to the number of entries, then the key is out of range
  447.  * and everything is less.
  448.  */
  449. if (sp->indx == 0)
  450. kp->greater += factor * (sp->entries - 1)/sp->entries;
  451. else if (sp->indx == sp->entries)
  452. kp->less += factor;
  453. else {
  454. kp->less += factor * sp->indx / sp->entries;
  455. kp->greater += factor *
  456.     (sp->entries - sp->indx - 1) / sp->entries;
  457. }
  458. factor *= 1.0/sp->entries;
  459. }
  461. /*
  462.  * If there was an exact match then assign 1 n'th to the key itself.
  463.  * Otherwise that factor belongs to those greater than the key, unless
  464.  * the key was out of range.
  465.  */
  466. if (exact)
  467. kp->equal = factor;
  468. else {
  469. if (kp->less != 1)
  470. kp->greater += factor;
  471. kp->equal = 0;
  472. }
  474. BT_STK_CLR(cp);
  476. err: if ((t_ret = dbc->c_close(dbc)) != 0 && ret == 0)
  477. ret = t_ret;
  479. return (ret);
  480. }