diff options
Diffstat (limited to 'debian/htdig/htdig-3.2.0b6/db/bt_stat.c')
| -rw-r--r-- | debian/htdig/htdig-3.2.0b6/db/bt_stat.c | 324 |
1 files changed, 324 insertions, 0 deletions
diff --git a/debian/htdig/htdig-3.2.0b6/db/bt_stat.c b/debian/htdig/htdig-3.2.0b6/db/bt_stat.c new file mode 100644 index 00000000..a1a1f26b --- /dev/null +++ b/debian/htdig/htdig-3.2.0b6/db/bt_stat.c @@ -0,0 +1,324 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 1996, 1997, 1998, 1999 + * Sleepycat Software. All rights reserved. + */ + +#include "db_config.h" + +#ifndef lint +static const char sccsid[] = "@(#)bt_stat.c 11.4 (Sleepycat) 10/18/99"; +#endif /* not lint */ + +#ifndef NO_SYSTEM_INCLUDES +#include <sys/types.h> + +#include <string.h> +#endif + +#include "db_int.h" +#include "db_page.h" +#include "db_shash.h" +#include "lock.h" +#include "btree.h" + +static int CDB___bam_stat_callback __P((DB *, PAGE *, void *, int *)); + +/* + * CDB___bam_stat -- + * Gather/print the btree statistics + * + * PUBLIC: int CDB___bam_stat __P((DB *, void *, void *(*)(size_t), u_int32_t)); + */ +int +CDB___bam_stat(dbp, spp, db_malloc, flags) + DB *dbp; + void *spp; + void *(*db_malloc) __P((size_t)); + u_int32_t flags; +{ + BTMETA *meta; + BTREE *t; + DBC *dbc; + DB_BTREE_STAT *sp; + DB_LOCK lock; + PAGE *h; + db_pgno_t pgno; + int ret, t_ret; + + PANIC_CHECK(dbp->dbenv); + DB_ILLEGAL_BEFORE_OPEN(dbp, "DB->stat"); + + meta = NULL; + t = dbp->bt_internal; + sp = NULL; + lock.off = LOCK_INVALID; + h = NULL; + ret = 0; + + /* Check for invalid flags. */ + if ((ret = CDB___db_statchk(dbp, flags)) != 0) + return (ret); + + if (spp == NULL) + return (0); + + /* Acquire a cursor. */ + if ((ret = dbp->cursor(dbp, NULL, &dbc, 0)) != 0) + return (ret); + + DEBUG_LWRITE(dbc, NULL, "bam_stat", NULL, NULL, flags); + + /* Allocate and clear the structure. */ + if ((ret = CDB___os_malloc(sizeof(*sp), db_malloc, &sp)) != 0) + goto err; + memset(sp, 0, sizeof(*sp)); + + /* If the app just wants the record count, make it fast. */ + if (flags == DB_RECORDCOUNT) { + if ((ret = + CDB___db_lget(dbc, 0, t->bt_root, DB_LOCK_READ, 0, &lock)) != 0) + goto err; + if ((ret = + CDB_memp_fget(dbp->mpf, &t->bt_root, 0, (PAGE **)&h)) != 0) + goto err; + + sp->bt_nrecs = RE_NREC(h); + + goto done; + } + + /* Get the metadata page for the entire database. */ + pgno = PGNO_BASE_MD; + if ((ret = CDB___db_lget(dbc, 0, pgno, DB_LOCK_READ, 0, &lock)) != 0) + goto err; + if ((ret = CDB_memp_fget(dbp->mpf, &pgno, 0, (PAGE **)&meta)) != 0) + goto err; + + /* Walk the metadata free list, counting pages. */ + for (sp->bt_free = 0, pgno = meta->dbmeta.free; pgno != PGNO_INVALID;) { + ++sp->bt_free; + + if ((ret = CDB_memp_fget(dbp->mpf, &pgno, 0, &h)) != 0) + goto err; + + pgno = h->next_pgno; + if ((ret = CDB_memp_fput(dbp->mpf, h, 0)) != 0) + goto err; + h = NULL; + } + + /* + * Get the subdatabase metadata page if it's not the same as the + * one we already have. + */ + if (t->bt_meta != PGNO_BASE_MD) { + if ((ret = CDB_memp_fput(dbp->mpf, meta, 0)) != 0) + goto err; + meta = NULL; + __LPUT(dbc, lock); + + if ((ret = + CDB___db_lget(dbc, 0, t->bt_meta, DB_LOCK_READ, 0, &lock)) != 0) + goto err; + if ((ret = + CDB_memp_fget(dbp->mpf, &t->bt_meta, 0, (PAGE **)&meta)) != 0) + goto err; + } + + /* Get metadata page statistics. */ + sp->bt_metaflags = meta->dbmeta.flags; + sp->bt_maxkey = meta->maxkey; + sp->bt_minkey = meta->minkey; + sp->bt_re_len = meta->re_len; + sp->bt_re_pad = meta->re_pad; + sp->bt_pagesize = meta->dbmeta.pagesize; + sp->bt_magic = meta->dbmeta.magic; + sp->bt_version = meta->dbmeta.version; + + /* Discard the metadata page. */ + if ((ret = CDB_memp_fput(dbp->mpf, meta, 0)) != 0) + goto err; + meta = NULL; + __LPUT(dbc, lock); + + /* Get the root page. */ + pgno = t->bt_root; + if ((ret = CDB___db_lget(dbc, 0, pgno, DB_LOCK_READ, 0, &lock)) != 0) + goto err; + if ((ret = CDB_memp_fget(dbp->mpf, &pgno, 0, &h)) != 0) + goto err; + + /* Get the levels from the root page. */ + sp->bt_levels = h->level; + + /* Discard the root page. */ + if ((ret = CDB_memp_fput(dbp->mpf, h, 0)) != 0) + goto err; + h = NULL; + __LPUT(dbc, lock); + + /* Walk the tree. */ + if ((ret = CDB___bam_traverse(dbc, + DB_LOCK_READ, t->bt_root, CDB___bam_stat_callback, sp)) != 0) + goto err; + +done: *(DB_BTREE_STAT **)spp = sp; + + if (0) { +err: if (sp != NULL) + CDB___os_free(sp, sizeof(*sp)); + } + + if (h != NULL && + (t_ret = CDB_memp_fput(dbp->mpf, h, 0)) != 0 && ret == 0) + ret = t_ret; + + if (meta != NULL && + (t_ret = CDB_memp_fput(dbp->mpf, meta, 0)) != 0 && ret == 0) + ret = t_ret; + + if (lock.off != LOCK_INVALID) + __LPUT(dbc, lock); + + if ((t_ret = dbc->c_close(dbc)) != 0 && ret == 0) + ret = t_ret; + + return (ret); +} + +/* + * CDB___bam_traverse -- + * Walk a Btree database. + * + * PUBLIC: int CDB___bam_traverse __P((DBC *, db_lockmode_t, + * PUBLIC: db_pgno_t, int (*)(DB *, PAGE *, void *, int *), void *)); + */ +int +CDB___bam_traverse(dbc, mode, root_pgno, callback, cookie) + DBC *dbc; + db_lockmode_t mode; + db_pgno_t root_pgno; + int (*callback)__P((DB *, PAGE *, void *, int *)); + void *cookie; +{ + BINTERNAL *bi; + BOVERFLOW *bo; + DB *dbp; + DB_LOCK lock; + PAGE *h; + RINTERNAL *ri; + int already_put, i, ret, t_ret; + + dbp = dbc->dbp; + + if ((ret = CDB___db_lget(dbc, 0, root_pgno, mode, 0, &lock)) != 0) + return (ret); + if ((ret = CDB_memp_fget(dbp->mpf, &root_pgno, 0, &h)) != 0) + goto err; + + switch (TYPE(h)) { + case P_IBTREE: + for (i = 0; i < NUM_ENT(h); i++) { + bi = GET_BINTERNAL(h, i); + if ((ret = CDB___bam_traverse(dbc, + mode, bi->pgno, callback, cookie)) != 0) + break; + + switch (B_TYPE(bi->type)) { + case B_DUPLICATE: + bo = (BOVERFLOW *)bi->data; + if ((ret = CDB___db_traverse_big( + dbp, bo->pgno, callback, cookie)) != 0) + goto err; + break; + case B_OVERFLOW: + bo = (BOVERFLOW *)bi->data; + if ((ret = CDB___db_traverse_dup( + dbp, bo->pgno, callback, cookie)) != 0) + goto err; + break; + case B_KEYDATA: + break; + default: + goto pgerr; + } + } + break; + case P_IRECNO: + for (i = 0; i < NUM_ENT(h); i++) { + ri = GET_RINTERNAL(h, i); + if ((ret = CDB___bam_traverse( + dbc, mode, ri->pgno, callback, cookie)) != 0) + break; + } + break; + case P_DUPLICATE: + case P_LBTREE: + case P_LRECNO: + case P_OVERFLOW: + case P_CMPR_FREE: + case P_CMPR_INTERNAL: + break; + default: +pgerr: return (CDB___db_pgfmt(dbc->dbp, h->pgno)); + } + + already_put = 0; + if ((ret = callback(dbp, h, cookie, &already_put)) != 0) + goto err; + +err: if (!already_put && + (t_ret = CDB_memp_fput(dbp->mpf, h, 0)) != 0 && ret != 0) + ret = t_ret; + __LPUT(dbc, lock); + + return (ret); +} + +/* + * CDB___bam_stat_callback -- + * Statistics callback. + */ +static int +CDB___bam_stat_callback(dbp, h, cookie, putp) + DB *dbp; + PAGE *h; + void *cookie; + int *putp; +{ + DB_BTREE_STAT *sp; + + *putp = 0; + sp = cookie; + + switch (TYPE(h)) { + case P_IBTREE: + case P_IRECNO: + ++sp->bt_int_pg; + sp->bt_int_pgfree += P_FREESPACE(h); + break; + case P_LBTREE: + ++sp->bt_leaf_pg; + sp->bt_leaf_pgfree += P_FREESPACE(h); + sp->bt_nrecs += NUM_ENT(h) / P_INDX; + break; + case P_LRECNO: + ++sp->bt_leaf_pg; + sp->bt_leaf_pgfree += P_FREESPACE(h); + sp->bt_nrecs += NUM_ENT(h); + break; + case P_DUPLICATE: + ++sp->bt_dup_pg; + sp->bt_dup_pgfree += P_FREESPACE(h); + break; + case P_OVERFLOW: + ++sp->bt_over_pg; + sp->bt_over_pgfree += P_OVFLSPACE(dbp->pgsize, h); + break; + default: + return (CDB___db_pgfmt(dbp, h->pgno)); + } + return (0); +} |