X-Git-Url: http://git.indexdata.com/?a=blobdiff_plain;f=isamb%2Fisamb.c;h=9d4d4008588ad1cb8fd2c9af92d5cb9459c2b1d9;hb=28045b27be52a2f8ac41900051612f5640cea165;hp=8245f98b90e201d0dfce1a274158c0463d92ce5a;hpb=a3b63c6d6e93131e388dfd86953e3df1275a6b86;p=idzebra-moved-to-github.git diff --git a/isamb/isamb.c b/isamb/isamb.c index 8245f98..9d4d400 100644 --- a/isamb/isamb.c +++ b/isamb/isamb.c @@ -1,5 +1,5 @@ -/* $Id: isamb.c,v 1.74 2005-03-18 12:05:11 adam Exp $ - Copyright (C) 1995-2005 +/* $Id: isamb.c,v 1.93 2007-04-03 16:54:46 adam Exp $ + Copyright (C) 1995-2007 Index Data ApS This file is part of the Zebra server. @@ -15,9 +15,9 @@ FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License -along with Zebra; see the file LICENSE.zebra. If not, write to the -Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA -02111-1307, USA. +along with this program; if not, write to the Free Software +Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ #include @@ -33,7 +33,8 @@ Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA #define ISAMB_MAJOR_VERSION 3 -#define ISAMB_MINOR_VERSION 0 +#define ISAMB_MINOR_VERSION_NO_ROOT 0 +#define ISAMB_MINOR_VERSION_WITH_ROOT 1 struct ISAMB_head { zint first_block; @@ -53,8 +54,9 @@ struct ISAMB_head { #define ISAMB_MAX_LEVEL 10 /* approx 2*max page + max size of item */ -#define DST_BUF_SIZE 16840 +#define DST_BUF_SIZE (2*4096+300) +/* should be maximum block size of multiple thereof */ #define ISAMB_CACHE_ENTRY_SIZE 4096 /* CAT_MAX: _must_ be power of 2 */ @@ -72,7 +74,7 @@ struct ISAMB_head { #define ISAMB_PTR_CODEC 1 struct ISAMB_cache_entry { - ISAMB_P pos; + ISAM_P pos; unsigned char *buf; int dirty; int hits; @@ -99,10 +101,16 @@ struct ISAMB_s { zint returned_numbers; zint skipped_nodes[ISAMB_MAX_LEVEL]; /* [0]=skipped leaves, 1 = higher etc */ zint accessed_nodes[ISAMB_MAX_LEVEL]; /* nodes we did not skip */ + zint number_of_int_splits; + zint number_of_leaf_splits; + int enable_int_count; /* whether we count nodes (or not) */ + int cache_size; /* size of blocks to cache (if cache=1) */ + int minor_version; + zint root_ptr; }; struct ISAMB_block { - ISAMB_P pos; + ISAM_P pos; int cat; int size; int leaf; @@ -119,7 +127,7 @@ struct ISAMB_block { struct ISAMB_PP_s { ISAMB isamb; - ISAMB_P pos; + ISAM_P pos; int level; int maxlevel; /* total depth */ zint total_size; @@ -157,14 +165,13 @@ static void encode_ptr(char **dst, zint pos) #define decode_item_len decode_ptr #if ISAMB_PTR_CODEC -static void decode_ptr(const char **src1, zint *pos) +static void decode_ptr(const char **src, zint *pos) { - const unsigned char **src = (const unsigned char **) src1; zint d = 0; unsigned char c; unsigned r = 0; - while (((c = *(*src)++) & 128)) + while (((c = *(const unsigned char *)((*src)++)) & 128)) { d += ((zint) (c & 127) << r); r += 7; @@ -180,45 +187,91 @@ static void decode_ptr(const char **src, zint *pos) } #endif -ISAMB isamb_open(BFiles bfs, const char *name, int writeflag, ISAMC_M *method, - int cache) + +void isamb_set_int_count(ISAMB b, int v) +{ + b->enable_int_count = v; +} + +void isamb_set_cache_size(ISAMB b, int v) +{ + b->cache_size = v; +} + +ISAMB isamb_open2(BFiles bfs, const char *name, int writeflag, ISAMC_M *method, + int cache, int no_cat, int *sizes, int use_root_ptr) { ISAMB isamb = xmalloc(sizeof(*isamb)); - int i, b_size = ISAMB_MIN_SIZE; + int i; + + assert(no_cat <= CAT_MAX); isamb->bfs = bfs; isamb->method = (ISAMC_M *) xmalloc(sizeof(*method)); memcpy(isamb->method, method, sizeof(*method)); - isamb->no_cat = CAT_NO; + isamb->no_cat = no_cat; isamb->log_io = 0; isamb->log_freelist = 0; isamb->cache = cache; isamb->skipped_numbers = 0; isamb->returned_numbers = 0; + isamb->number_of_int_splits = 0; + isamb->number_of_leaf_splits = 0; + isamb->enable_int_count = 1; + isamb->cache_size = 40; + + if (use_root_ptr) + isamb->minor_version = ISAMB_MINOR_VERSION_WITH_ROOT; + else + isamb->minor_version = ISAMB_MINOR_VERSION_NO_ROOT; + + isamb->root_ptr = 0; + for (i = 0; iskipped_nodes[i] = isamb->accessed_nodes[i] = 0; + isamb->skipped_nodes[i] = isamb->accessed_nodes[i] = 0; - assert(cache == 0); + if (cache == -1) + { + yaz_log(YLOG_WARN, "isamb_open %s. Degraded TEST mode", name); + } + else + { + assert(cache == 0 || cache == 1); + } isamb->file = xmalloc(sizeof(*isamb->file) * isamb->no_cat); + + for (i = 0; i < isamb->no_cat; i++) + { + isamb->file[i].bf = 0; + isamb->file[i].head_dirty = 0; + isamb->file[i].cache_entries = 0; + } + for (i = 0; i < isamb->no_cat; i++) { char fname[DST_BUF_SIZE]; char hbuf[DST_BUF_SIZE]; - isamb->file[i].cache_entries = 0; - isamb->file[i].head_dirty = 0; + sprintf(fname, "%s%c", name, i+'A'); if (cache) isamb->file[i].bf = bf_open(bfs, fname, ISAMB_CACHE_ENTRY_SIZE, writeflag); else - isamb->file[i].bf = bf_open(bfs, fname, b_size, writeflag); + isamb->file[i].bf = bf_open(bfs, fname, sizes[i], writeflag); + + if (!isamb->file[i].bf) + { + isamb_close(isamb); + return 0; + } /* fill-in default values (for empty isamb) */ - isamb->file[i].head.first_block = ISAMB_CACHE_ENTRY_SIZE/b_size+1; + isamb->file[i].head.first_block = ISAMB_CACHE_ENTRY_SIZE/sizes[i]+1; isamb->file[i].head.last_block = isamb->file[i].head.first_block; - isamb->file[i].head.block_size = b_size; + isamb->file[i].head.block_size = sizes[i]; + assert(sizes[i] <= ISAMB_CACHE_ENTRY_SIZE); #if ISAMB_PTR_CODEC - if (i == isamb->no_cat-1 || b_size > 128) + if (i == isamb->no_cat-1 || sizes[i] > 128) isamb->file[i].head.block_offset = 8; else isamb->file[i].head.block_offset = 4; @@ -226,7 +279,7 @@ ISAMB isamb_open(BFiles bfs, const char *name, int writeflag, ISAMC_M *method, isamb->file[i].head.block_offset = 11; #endif isamb->file[i].head.block_max = - b_size - isamb->file[i].head.block_offset; + sizes[i] - isamb->file[i].head.block_offset; isamb->file[i].head.free_list = 0; if (bf_read(isamb->file[i].bf, 0, 0, 0, hbuf)) { @@ -238,27 +291,31 @@ ISAMB isamb_open(BFiles bfs, const char *name, int writeflag, ISAMC_M *method, if (memcmp(hbuf, "isamb", 5)) { yaz_log(YLOG_WARN, "bad isamb header for file %s", fname); + isamb_close(isamb); return 0; } if (sscanf(hbuf+5, "%d %d %d", &major, &minor, &len) != 3) { yaz_log(YLOG_WARN, "bad isamb header for file %s", fname); + isamb_close(isamb); return 0; } if (major != ISAMB_MAJOR_VERSION) { yaz_log(YLOG_WARN, "bad major version for file %s %d, must be %d", fname, major, ISAMB_MAJOR_VERSION); + isamb_close(isamb); return 0; } - for (left = len - b_size; left > 0; left = left - b_size) + for (left = len - sizes[i]; left > 0; left = left - sizes[i]) { pos++; - if (!bf_read(isamb->file[i].bf, pos, 0, 0, hbuf + pos*b_size)) + if (!bf_read(isamb->file[i].bf, pos, 0, 0, hbuf + pos*sizes[i])) { yaz_log(YLOG_WARN, "truncated isamb header for " "file=%s len=%d pos=%d", fname, len, pos); + isamb_close(isamb); return 0; } } @@ -270,11 +327,16 @@ ISAMB isamb_open(BFiles bfs, const char *name, int writeflag, ISAMC_M *method, decode_ptr(&src, &zint_tmp); isamb->file[i].head.block_max = (int) zint_tmp; decode_ptr(&src, &isamb->file[i].head.free_list); + if (isamb->minor_version >= ISAMB_MINOR_VERSION_WITH_ROOT) + decode_ptr(&src, &isamb->root_ptr); } assert (isamb->file[i].head.block_size >= isamb->file[i].head.block_offset); - isamb->file[i].head_dirty = 0; - assert(isamb->file[i].head.block_size == b_size); - b_size = b_size * ISAMB_FAC_SIZE; + /* must rewrite the header if root ptr is in use (bug #1017) */ + if (use_root_ptr && writeflag) + isamb->file[i].head_dirty = 1; + else + isamb->file[i].head_dirty = 0; + assert(isamb->file[i].head.block_size == sizes[i]); } #if ISAMB_DEBUG yaz_log(YLOG_WARN, "isamb debug enabled. Things will be slower than usual"); @@ -282,6 +344,21 @@ ISAMB isamb_open(BFiles bfs, const char *name, int writeflag, ISAMC_M *method, return isamb; } +ISAMB isamb_open(BFiles bfs, const char *name, int writeflag, ISAMC_M *method, + int cache) +{ + int sizes[CAT_NO]; + int i, b_size = ISAMB_MIN_SIZE; + + for (i = 0; ifile[cat].cache_entries) @@ -299,7 +376,7 @@ static void flush_blocks (ISAMB b, int cat) } } -static int cache_block (ISAMB b, ISAMC_P pos, char *userbuf, int wr) +static int cache_block (ISAMB b, ISAM_P pos, unsigned char *userbuf, int wr) { int cat = (int) (pos&CAT_MASK); int off = (int) (((pos/CAT_MAX) & @@ -336,9 +413,8 @@ static int cache_block (ISAMB b, ISAMC_P pos, char *userbuf, int wr) return 1; } } - if (no >= 40) + if (no >= b->cache_size) { - assert (no == 40); assert (ce_last && *ce_last); ce_this = *ce_last; *ce_last = 0; /* remove the last entry from list */ @@ -382,6 +458,7 @@ void isamb_close (ISAMB isamb) yaz_log(YLOG_DEBUG, "isamb_close returned "ZINT_FORMAT" values, " "skipped "ZINT_FORMAT, isamb->skipped_numbers, isamb->returned_numbers); + for (i = 0; ino_cat; i++) { flush_blocks (isamb, i); @@ -389,7 +466,6 @@ void isamb_close (ISAMB isamb) { char hbuf[DST_BUF_SIZE]; int major = ISAMB_MAJOR_VERSION; - int minor = ISAMB_MINOR_VERSION; int len = 16; char *dst = hbuf + 16; int pos = 0, left; @@ -400,12 +476,17 @@ void isamb_close (ISAMB isamb) encode_ptr(&dst, isamb->file[i].head.block_size); encode_ptr(&dst, isamb->file[i].head.block_max); encode_ptr(&dst, isamb->file[i].head.free_list); + + if (isamb->minor_version >= ISAMB_MINOR_VERSION_WITH_ROOT) + encode_ptr(&dst, isamb->root_ptr); + memset(dst, '\0', b_size); /* ensure no random bytes are written */ len = dst - hbuf; /* print exactly 16 bytes (including trailing 0) */ - sprintf(hbuf, "isamb%02d %02d %02d\r\n", major, minor, len); + sprintf(hbuf, "isamb%02d %02d %02d\r\n", major, + isamb->minor_version, len); bf_write(isamb->file[i].bf, pos, 0, 0, hbuf); @@ -415,7 +496,8 @@ void isamb_close (ISAMB isamb) bf_write(isamb->file[i].bf, pos, 0, 0, hbuf + pos*b_size); } } - bf_close (isamb->file[i].bf); + if (isamb->file[i].bf) + bf_close (isamb->file[i].bf); } xfree(isamb->file); xfree(isamb->method); @@ -432,7 +514,7 @@ void isamb_close (ISAMB isamb) * Reserve 5 bytes for large block sizes. 1 for small ones .. Number of items. We can thus have at most 2^40 nodes. */ -static struct ISAMB_block *open_block(ISAMB b, ISAMC_P pos) +static struct ISAMB_block *open_block(ISAMB b, ISAM_P pos) { int cat = (int) (pos&CAT_MASK); const char *src; @@ -449,14 +531,14 @@ static struct ISAMB_block *open_block(ISAMB b, ISAMC_P pos) if (!cache_block (b, pos, p->buf, 0)) { yaz_log(b->log_io, "bf_read: open_block"); - if (!bf_read(b->file[cat].bf, pos/CAT_MAX, 0, 0, p->buf)) + if (bf_read(b->file[cat].bf, pos/CAT_MAX, 0, 0, p->buf) != 1) { yaz_log(YLOG_FATAL, "isamb: read fail for pos=%ld block=%ld", (long) pos, (long) pos/CAT_MAX); - abort(); + zebra_exit("isamb:open_block"); } } - p->bytes = p->buf + offset; + p->bytes = (char *)p->buf + offset; p->leaf = p->buf[0]; p->size = (p->buf[1] + 256 * p->buf[2]) - offset; if (p->size < 0) @@ -465,7 +547,7 @@ static struct ISAMB_block *open_block(ISAMB b, ISAMC_P pos) p->size, pos); } assert (p->size >= 0); - src = p->buf + 3; + src = (char*) p->buf + 3; decode_ptr(&src, &p->no_items); p->offset = 0; @@ -499,7 +581,7 @@ struct ISAMB_block *new_block (ISAMB b, int leaf, int cat) { yaz_log(YLOG_FATAL, "isamb: read fail for pos=%ld block=%ld", (long) p->pos/CAT_MAX, (long) p->pos/CAT_MAX); - abort (); + zebra_exit("isamb:new_block"); } } yaz_log(b->log_freelist, "got block " ZINT_FORMAT " from freelist %d:" ZINT_FORMAT, p->pos, @@ -509,7 +591,7 @@ struct ISAMB_block *new_block (ISAMB b, int leaf, int cat) p->cat = cat; b->file[cat].head_dirty = 1; memset (p->buf, 0, b->file[cat].head.block_size); - p->bytes = p->buf + b->file[cat].head.block_offset; + p->bytes = (char*)p->buf + b->file[cat].head.block_offset; p->leaf = leaf; p->size = 0; p->dirty = 1; @@ -544,7 +626,7 @@ static void check_block (ISAMB b, struct ISAMB_block *p) char *startp = p->bytes; const char *src = startp; char *endp = p->bytes + p->size; - ISAMB_P pos; + ISAM_P pos; void *c1 = (*b->method->codec.start)(); decode_ptr(&src, &pos); @@ -559,7 +641,7 @@ static void check_block (ISAMB b, struct ISAMB_block *p) #else zint item_len; decode_item_len(&src, &item_len); - assert (item_len > 0 && item_len < 80); + assert (item_len > 0 && item_len < 128); src += item_len; #endif decode_ptr(&src, &pos); @@ -592,7 +674,7 @@ void close_block(ISAMB b, struct ISAMB_block *p) { int offset = b->file[p->cat].head.block_offset; int size = p->size + offset; - char *dst = p->buf + 3; + char *dst = (char*)p->buf + 3; assert (p->size >= 0); /* memset becuase encode_ptr usually does not write all bytes */ @@ -628,7 +710,7 @@ int insert_int (ISAMB b, struct ISAMB_block *p, void *lookahead_item, char *startp = p->bytes; const char *src = startp; char *endp = p->bytes + p->size; - ISAMB_P pos; + ISAM_P pos; struct ISAMB_block *sub_p1 = 0, *sub_p2 = 0; char sub_item[DST_ITEM_MAX]; int sub_size; @@ -707,7 +789,7 @@ int insert_int (ISAMB b, struct ISAMB_block *p, void *lookahead_item, #if INT_ENCODE const char *sub_item_ptr = sub_item; #endif - assert (sub_size < 80 && sub_size > 1); + assert (sub_size < 128 && sub_size > 1); memcpy (dst, startp, src - startp); @@ -732,11 +814,12 @@ int insert_int (ISAMB b, struct ISAMB_block *p, void *lookahead_item, p->size = dst - dst_buf; assert (p->size >= 0); - if (p->size <= b->file[p->cat].head.block_max) { /* it fits OK in this block */ memcpy (startp, dst_buf, dst - dst_buf); + + close_block(b, sub_p2); } else { @@ -753,14 +836,22 @@ int insert_int (ISAMB b, struct ISAMB_block *p, void *lookahead_item, const char *half; src = dst_buf; endp = dst; + + b->number_of_int_splits++; + + p->dirty = 1; + close_block(b, sub_p2); half = src + b->file[p->cat].head.block_size/2; decode_ptr(&src, &pos); - /* read sub block so we can get no_items for it */ - sub_p3 = open_block(b, pos); - no_items_first_half += sub_p3->no_items; - close_block(b, sub_p3); + if (b->enable_int_count) + { + /* read sub block so we can get no_items for it */ + sub_p3 = open_block(b, pos); + no_items_first_half += sub_p3->no_items; + close_block(b, sub_p3); + } while (src <= half) { @@ -775,10 +866,13 @@ int insert_int (ISAMB b, struct ISAMB_block *p, void *lookahead_item, #endif decode_ptr(&src, &pos); - /* read sub block so we can get no_items for it */ - sub_p3 = open_block(b, pos); - no_items_first_half += sub_p3->no_items; - close_block(b, sub_p3); + if (b->enable_int_count) + { + /* read sub block so we can get no_items for it */ + sub_p3 = open_block(b, pos); + no_items_first_half += sub_p3->no_items; + close_block(b, sub_p3); + } } /* p is first half */ p_new_size = src - dst_buf; @@ -807,8 +901,7 @@ int insert_int (ISAMB b, struct ISAMB_block *p, void *lookahead_item, (*sp)->no_items = p->no_items - no_items_first_half; p->no_items = no_items_first_half; } - p->dirty = 1; - close_block(b, sub_p2); + p->dirty = 1; } close_block(b, sub_p1); (*b->method->codec.stop)(c1); @@ -839,6 +932,7 @@ int insert_leaf (ISAMB b, struct ISAMB_block **sp1, void *lookahead_item, int cut_item_size = 0; int no_items = 0; /* number of items (total) */ int no_items_1 = 0; /* number of items (first half) */ + int inserted_dst_bytes = 0; if (p && p->size) { @@ -852,6 +946,7 @@ int insert_leaf (ISAMB b, struct ISAMB_block **sp1, void *lookahead_item, { const char *dst_item = 0; /* resulting item to be inserted */ char *lookahead_next; + char *dst_0 = dst; int d = -1; if (lookahead_item) @@ -871,13 +966,12 @@ int insert_leaf (ISAMB b, struct ISAMB_block **sp1, void *lookahead_item, if (!*lookahead_mode) { yaz_log(YLOG_WARN, "isamb: Inconsistent register (1)"); - assert (*lookahead_mode); + assert(*lookahead_mode); } } else dst_item = file_item_buf; - if (!*lookahead_mode && d == 0) { /* it's a deletion and they match so there is nothing to be @@ -914,7 +1008,8 @@ int insert_leaf (ISAMB b, struct ISAMB_block **sp1, void *lookahead_item, { /* we must move the lookahead pointer */ - if (dst > maxp) + inserted_dst_bytes += (dst - dst_0); + if (inserted_dst_bytes >= quater) /* no more room. Mark lookahead as "gone".. */ lookahead_item = 0; else @@ -971,17 +1066,7 @@ int insert_leaf (ISAMB b, struct ISAMB_block **sp1, void *lookahead_item, either it's empty (new) or all file items have been read in previous loop */ - /* determine maximum ptr for tail */ - if (half2) - { - /* split already. No more splits - fill up to one full (Extra) block */ - maxp = half2 + b->file[b->no_cat-1].head.block_max; - } - else - { - /* no split. Fill up to 1+1/4 block */ - maxp = dst_buf + b->file[b->no_cat-1].head.block_max + quater; - } + maxp = dst_buf + b->file[b->no_cat-1].head.block_max + quater; while (lookahead_item) { char *dst_item; @@ -999,7 +1084,7 @@ int insert_leaf (ISAMB b, struct ISAMB_block **sp1, void *lookahead_item, { /* this is append. So a delete is bad */ yaz_log(YLOG_WARN, "isamb: Inconsistent register (2)"); - abort(); + assert(*lookahead_mode); } else if (!half1 && dst > tail_cut) { @@ -1066,6 +1151,7 @@ int insert_leaf (ISAMB b, struct ISAMB_block **sp1, void *lookahead_item, /* first half */ p->size = half1 - dst_buf; + assert(p->size <= b->file[p->cat].head.block_max); memcpy (p->bytes, dst_buf, half1 - dst_buf); p->no_items = no_items_1; @@ -1074,6 +1160,8 @@ int insert_leaf (ISAMB b, struct ISAMB_block **sp1, void *lookahead_item, (*b->method->codec.reset)(c2); + b->number_of_leaf_splits++; + first_dst = (*sp2)->bytes; (*b->method->codec.encode)(c2, &first_dst, &cut_item); @@ -1081,6 +1169,7 @@ int insert_leaf (ISAMB b, struct ISAMB_block **sp1, void *lookahead_item, memcpy (first_dst, half2, dst - half2); (*sp2)->size = (first_dst - (*sp2)->bytes) + (dst - half2); + assert((*sp2)->size <= b->file[p->cat].head.block_max); (*sp2)->no_items = no_items - no_items_1; (*sp2)->dirty = 1; p->dirty = 1; @@ -1114,7 +1203,7 @@ int insert_sub (ISAMB b, struct ISAMB_block **p, void *new_item, sub_size, max_item); } -int isamb_unlink (ISAMB b, ISAMC_P pos) +int isamb_unlink (ISAMB b, ISAM_P pos) { struct ISAMB_block *p1; @@ -1155,7 +1244,7 @@ int isamb_unlink (ISAMB b, ISAMC_P pos) return 0; } -ISAMB_P isamb_merge (ISAMB b, ISAMC_P pos, ISAMC_I *stream) +void isamb_merge(ISAMB b, ISAM_P *pos, ISAMC_I *stream) { char item_buf[DST_ITEM_MAX]; char *item_ptr; @@ -1172,7 +1261,8 @@ ISAMB_P isamb_merge (ISAMB b, ISAMC_P pos, ISAMC_I *stream) more = (*stream->read_item)(stream->clientData, &item_ptr, &i_mode); } - return 1; + *pos = 1; + return; } item_ptr = item_buf; more = (*stream->read_item)(stream->clientData, &item_ptr, &i_mode); @@ -1182,8 +1272,8 @@ ISAMB_P isamb_merge (ISAMB b, ISAMC_P pos, ISAMC_I *stream) char sub_item[DST_ITEM_MAX]; int sub_size; - if (pos) - p = open_block(b, pos); + if (*pos) + p = open_block(b, *pos); more = insert_sub (b, &p, item_buf, &i_mode, stream, &sp, sub_item, &sub_size, 0); if (sp) @@ -1196,7 +1286,7 @@ ISAMB_P isamb_merge (ISAMB b, ISAMC_P pos, ISAMC_I *stream) #endif encode_ptr(&dst, p->pos); - assert (sub_size < 80 && sub_size > 1); + assert (sub_size < 128 && sub_size > 1); #if INT_ENCODE (*b->method->codec.reset)(c1); (*b->method->codec.encode)(c1, &dst, &sub_item_ptr); @@ -1209,7 +1299,7 @@ ISAMB_P isamb_merge (ISAMB b, ISAMC_P pos, ISAMC_I *stream) p2->size = dst - p2->bytes; p2->no_items = p->no_items + sp->no_items; - pos = p2->pos; /* return new super page */ + *pos = p2->pos; /* return new super page */ close_block(b, sp); close_block(b, p2); #if INT_ENCODE @@ -1218,7 +1308,7 @@ ISAMB_P isamb_merge (ISAMB b, ISAMC_P pos, ISAMC_I *stream) } else { - pos = p->pos; /* return current one (again) */ + *pos = p->pos; /* return current one (again) */ } if (p->no_items == 0) must_delete = 1; @@ -1228,13 +1318,12 @@ ISAMB_P isamb_merge (ISAMB b, ISAMC_P pos, ISAMC_I *stream) } if (must_delete) { - isamb_unlink(b, pos); - return 0; + isamb_unlink(b, *pos); + *pos = 0; } - return pos; } -ISAMB_PP isamb_pp_open_x(ISAMB isamb, ISAMB_P pos, int *level, int scope) +ISAMB_PP isamb_pp_open_x(ISAMB isamb, ISAM_P pos, int *level, int scope) { ISAMB_PP pp = xmalloc(sizeof(*pp)); int i; @@ -1276,7 +1365,7 @@ ISAMB_PP isamb_pp_open_x(ISAMB isamb, ISAMB_P pos, int *level, int scope) return pp; } -ISAMB_PP isamb_pp_open (ISAMB isamb, ISAMB_P pos, int scope) +ISAMB_PP isamb_pp_open (ISAMB isamb, ISAM_P pos, int scope) { return isamb_pp_open_x(isamb, pos, 0, scope); } @@ -1324,7 +1413,7 @@ void isamb_pp_close (ISAMB_PP pp) } /* simple recursive dumper .. */ -static void isamb_dump_r (ISAMB b, ISAMB_P pos, void (*pr)(const char *str), +static void isamb_dump_r (ISAMB b, ISAM_P pos, void (*pr)(const char *str), int level) { char buf[1024]; @@ -1353,7 +1442,7 @@ static void isamb_dump_r (ISAMB b, ISAMB_P pos, void (*pr)(const char *str), else { const char *src = p->bytes + p->offset; - ISAMB_P sub; + ISAM_P sub; decode_ptr(&src, &sub); p->offset = src - (char*) p->bytes; @@ -1386,7 +1475,7 @@ static void isamb_dump_r (ISAMB b, ISAMB_P pos, void (*pr)(const char *str), } } -void isamb_dump(ISAMB b, ISAMB_P pos, void (*pr)(const char *str)) +void isamb_dump(ISAMB b, ISAM_P pos, void (*pr)(const char *str)) { isamb_dump_r(b, pos, pr, 0); } @@ -1520,7 +1609,7 @@ static int isamb_pp_forward_on_leaf(ISAMB_PP pp, void *buf, const void *untilbuf } } /* forward_on_leaf */ -static int isamb_pp_climb_level(ISAMB_PP pp, ISAMB_P *pos) +static int isamb_pp_climb_level(ISAMB_PP pp, ISAM_P *pos) { /* climbs higher in the tree, until finds a level with data left */ /* returns the node to (consider to) descend to in *pos) */ struct ISAMB_block *p = pp->block[pp->level]; @@ -1660,7 +1749,7 @@ static zint isamb_pp_forward_unode(ISAMB_PP pp, zint pos, const void *untilbuf) } /* forward_unode */ -static void isamb_pp_descend_to_leaf(ISAMB_PP pp, ISAMB_P pos, +static void isamb_pp_descend_to_leaf(ISAMB_PP pp, ISAM_P pos, const void *untilbuf) { /* climbs down the tree, from pos, to the leftmost leaf */ struct ISAMB_block *p = pp->block[pp->level]; @@ -1700,7 +1789,7 @@ static void isamb_pp_descend_to_leaf(ISAMB_PP pp, ISAMB_P pos, static int isamb_pp_find_next_leaf(ISAMB_PP pp) { /* finds the next leaf by climbing up and down */ - ISAMB_P pos; + ISAM_P pos; if (!isamb_pp_climb_level(pp, &pos)) return 0; isamb_pp_descend_to_leaf(pp, pos, 0); @@ -1709,7 +1798,7 @@ static int isamb_pp_find_next_leaf(ISAMB_PP pp) static int isamb_pp_climb_desc(ISAMB_PP pp, const void *untilbuf) { /* climbs up and descends to a leaf where values >= *untilbuf are found */ - ISAMB_P pos; + ISAM_P pos; #if ISAMB_DEBUG struct ISAMB_block *p = pp->block[pp->level]; yaz_log(YLOG_DEBUG, "isamb_pp_climb_desc starting " @@ -1805,10 +1894,10 @@ int isamb_pp_forward (ISAMB_PP pp, void *buf, const void *untilbuf) void isamb_pp_pos(ISAMB_PP pp, double *current, double *total) { /* return an estimate of the current position and of the total number of */ /* occureences in the isam tree, based on the current leaf */ - struct ISAMB_block *p = pp->block[pp->level]; assert(total); assert(current); - assert(p->leaf); + + /* if end-of-stream PP may not be leaf */ *total = (double) (pp->block[0]->no_items); *current = (double) pp->returned_numbers; @@ -1829,7 +1918,7 @@ int isamb_pp_forward2(ISAMB_PP pp, void *buf, const void *untilb) again: while (p->offset == p->size) { - ISAMB_P pos; + ISAM_P pos; #if INT_ENCODE const char *src_0; void *c1; @@ -1950,3 +2039,33 @@ again: } return 1; } + +zint isamb_get_int_splits(ISAMB b) +{ + return b->number_of_int_splits; +} + +zint isamb_get_leaf_splits(ISAMB b) +{ + return b->number_of_leaf_splits; +} + +zint isamb_get_root_ptr(ISAMB b) +{ + return b->root_ptr; +} + +void isamb_set_root_ptr(ISAMB b, zint root_ptr) +{ + b->root_ptr = root_ptr; +} + + +/* + * Local variables: + * c-basic-offset: 4 + * indent-tabs-mode: nil + * End: + * vim: shiftwidth=4 tabstop=8 expandtab + */ +