index/kinput.c

   1 /* $Id: kinput.c,v 1.89 2008-01-09 22:18:04 adam Exp $
   2    Copyright (C) 1995-2007
   3    Index Data ApS
   4
   5 This file is part of the Zebra server.
   6
   7 Zebra is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 Zebra is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  20
  21 */
  22
  23 #include <fcntl.h>
  24 #ifdef WIN32
  25 #include <io.h>
  26 #endif
  27 #if HAVE_UNISTD_H
  28 #include <unistd.h>
  29 #endif
  30 #include <stdlib.h>
  31 #include <string.h>
  32 #include <stdio.h>
  33 #include <assert.h>
  34
  35 #include "index.h"
  36
  37 #define KEY_SIZE (1+sizeof(struct it_key))
  38 #define INP_NAME_MAX 768
  39
  40 struct key_file {
  41     int   no;            /* file no */
  42     off_t offset;        /* file offset */
  43     unsigned char *buf;  /* buffer block */
  44     size_t buf_size;     /* number of read bytes in block */
  45     size_t chunk;        /* number of bytes allocated */
  46     size_t buf_ptr;      /* current position in buffer */
  47     char *prev_name;     /* last word read */
  48     void *decode_handle;
  49     off_t length;        /* length of file */
  50                          /* handler invoked in each read */
  51     void (*readHandler)(struct key_file *keyp, void *rinfo);
  52     void *readInfo;
  53     Res res;
  54 };
  55
  56 #if 0
  57 static void pkey(const char *b, int mode)
  58 {
  59     key_logdump_txt(YLOG_LOG, b, mode ? "i" : "d");
  60 }
  61 #endif
  62
  63
  64 void getFnameTmp(Res res, char *fname, int no)
  65 {
  66     const char *pre;
  67
  68     pre = res_get_def(res, "keyTmpDir", ".");
  69     sprintf(fname, "%s/key%d.tmp", pre, no);
  70 }
  71
  72 void extract_get_fname_tmp(ZebraHandle zh, char *fname, int no)
  73 {
  74     const char *pre;
  75
  76     pre = res_get_def(zh->res, "keyTmpDir", ".");
  77     sprintf(fname, "%s/key%d.tmp", pre, no);
  78 }
  79
  80 void key_file_chunk_read(struct key_file *f)
  81 {
  82     int nr = 0, r = 0, fd;
  83     char fname[1024];
  84     getFnameTmp(f->res, fname, f->no);
  85     fd = open(fname, O_BINARY|O_RDONLY);
  86
  87     f->buf_ptr = 0;
  88     f->buf_size = 0;
  89     if (fd == -1)
  90     {
  91         yaz_log(YLOG_WARN|YLOG_ERRNO, "cannot open %s", fname);
  92         return ;
  93     }
  94     if (!f->length)
  95     {
  96         if ((f->length = lseek(fd, 0L, SEEK_END)) == (off_t) -1)
  97         {
  98             yaz_log(YLOG_WARN|YLOG_ERRNO, "cannot seek %s", fname);
  99             close(fd);
 100             return ;
 101         }
 102     }
 103     if (lseek(fd, f->offset, SEEK_SET) == -1)
 104     {
 105         yaz_log(YLOG_WARN|YLOG_ERRNO, "cannot seek %s", fname);
 106         close(fd);
 107         return ;
 108     }
 109     while (f->chunk - nr > 0)
 110     {
 111         r = read(fd, f->buf + nr, f->chunk - nr);
 112         if (r <= 0)
 113             break;
 114         nr += r;
 115     }
 116     if (r == -1)
 117     {
 118         yaz_log(YLOG_WARN|YLOG_ERRNO, "read of %s", fname);
 119         close(fd);
 120         return;
 121     }
 122     f->buf_size = nr;
 123     if (f->readHandler)
 124         (*f->readHandler)(f, f->readInfo);
 125     close(fd);
 126 }
 127
 128 void key_file_destroy(struct key_file *f)
 129 {
 130     iscz1_stop(f->decode_handle);
 131     xfree(f->buf);
 132     xfree(f->prev_name);
 133     xfree(f);
 134 }
 135
 136 struct key_file *key_file_init(int no, int chunk, Res res)
 137 {
 138     struct key_file *f;
 139
 140     f = (struct key_file *) xmalloc(sizeof(*f));
 141     f->res = res;
 142     f->decode_handle = iscz1_start();
 143     f->no = no;
 144     f->chunk = chunk;
 145     f->offset = 0;
 146     f->length = 0;
 147     f->readHandler = NULL;
 148     f->buf = (unsigned char *) xmalloc(f->chunk);
 149     f->prev_name = (char *) xmalloc(INP_NAME_MAX);
 150     *f->prev_name = '\0';
 151     key_file_chunk_read(f);
 152     return f;
 153 }
 154
 155 int key_file_getc(struct key_file *f)
 156 {
 157     if (f->buf_ptr < f->buf_size)
 158         return f->buf[(f->buf_ptr)++];
 159     if (f->buf_size < f->chunk)
 160         return EOF;
 161     f->offset += f->buf_size;
 162     key_file_chunk_read(f);
 163     if (f->buf_ptr < f->buf_size)
 164         return f->buf[(f->buf_ptr)++];
 165     else
 166         return EOF;
 167 }
 168
 169 int key_file_read(struct key_file *f, char *key)
 170 {
 171     int i, c;
 172     char srcbuf[128];
 173     const char *src = srcbuf;
 174     char *dst;
 175     int j;
 176
 177     c = key_file_getc(f);
 178     if (c == 0)
 179     {
 180         strcpy(key, f->prev_name);
 181         i = 1+strlen(key);
 182     }
 183     else if (c == EOF)
 184         return 0;
 185     else
 186     {
 187         i = 0;
 188         key[i++] = c;
 189         while ((c = key_file_getc(f)))
 190         {
 191             if (i < IT_MAX_WORD)
 192                 key[i++] = c;
 193         }
 194         key[i++] = '\0';
 195         strcpy(f->prev_name, key);
 196         iscz1_reset(f->decode_handle);
 197     }
 198     c = key_file_getc(f); /* length +  insert/delete combined */
 199     key[i++] = c & 128;
 200     c = c & 127;
 201     for (j = 0; j < c; j++)
 202         srcbuf[j] = key_file_getc(f);
 203     dst = key + i;
 204     iscz1_decode(f->decode_handle, &dst, &src);
 205
 206 #if 0
 207     /* debugging */
 208     if (1)
 209     {
 210         struct it_key k;
 211         memcpy(&k, key+i, sizeof(k));
 212         if (!k.mem[1])
 213             yaz_log(YLOG_LOG, "00 KEY");
 214     }
 215 #endif
 216     return i + sizeof(struct it_key);
 217 }
 218
 219 struct heap_info {
 220     struct {
 221         struct key_file **file;
 222         char   **buf;
 223     } info;
 224     int    heapnum;
 225     int    *ptr;
 226     int    (*cmp)(const void *p1, const void *p2);
 227     struct zebra_register *reg;
 228     ZebraHandle zh;
 229     zint no_diffs;
 230     zint no_updates;
 231     zint no_deletions;
 232     zint no_insertions;
 233     zint no_iterations;
 234 };
 235
 236 static struct heap_info *key_heap_malloc(void)
 237 {  /* malloc and clear it */
 238     struct heap_info *hi;
 239     hi = (struct heap_info *) xmalloc(sizeof(*hi));
 240     hi->info.file = 0;
 241     hi->info.buf = 0;
 242     hi->heapnum = 0;
 243     hi->ptr = 0;
 244     hi->no_diffs = 0;
 245     hi->no_diffs = 0;
 246     hi->no_updates = 0;
 247     hi->no_deletions = 0;
 248     hi->no_insertions = 0;
 249     hi->no_iterations = 0;
 250     return hi;
 251 }
 252
 253 struct heap_info *key_heap_init_file(ZebraHandle zh,
 254                                      int nkeys,
 255                                      int (*cmp)(const void *p1, const void *p2))
 256 {
 257     struct heap_info *hi;
 258     int i;
 259
 260     hi = key_heap_malloc();
 261     hi->zh = zh;
 262     hi->info.file = (struct key_file **)
 263         xmalloc(sizeof(*hi->info.file) * (1+nkeys));
 264     hi->info.buf = (char **) xmalloc(sizeof(*hi->info.buf) * (1+nkeys));
 265     hi->ptr = (int *) xmalloc(sizeof(*hi->ptr) * (1+nkeys));
 266     hi->cmp = cmp;
 267     for (i = 0; i<= nkeys; i++)
 268     {
 269         hi->ptr[i] = i;
 270         hi->info.buf[i] = (char *) xmalloc(INP_NAME_MAX);
 271     }
 272     return hi;
 273 }
 274
 275 void key_heap_destroy(struct heap_info *hi, int nkeys)
 276 {
 277     int i;
 278     for (i = 0; i<=nkeys; i++)
 279         xfree(hi->info.buf[i]);
 280     xfree(hi->info.buf);
 281     xfree(hi->ptr);
 282     xfree(hi->info.file);
 283     xfree(hi);
 284 }
 285
 286 static void key_heap_swap(struct heap_info *hi, int i1, int i2)
 287 {
 288     int swap;
 289
 290     swap = hi->ptr[i1];
 291     hi->ptr[i1] = hi->ptr[i2];
 292     hi->ptr[i2] = swap;
 293 }
 294
 295
 296 static void key_heap_delete(struct heap_info *hi)
 297 {
 298     int cur = 1, child = 2;
 299
 300     assert(hi->heapnum > 0);
 301
 302     key_heap_swap(hi, 1, hi->heapnum);
 303     hi->heapnum--;
 304     while (child <= hi->heapnum) {
 305         if (child < hi->heapnum &&
 306             (*hi->cmp)(&hi->info.buf[hi->ptr[child]],
 307                        &hi->info.buf[hi->ptr[child+1]]) > 0)
 308             child++;
 309         if ((*hi->cmp)(&hi->info.buf[hi->ptr[cur]],
 310                        &hi->info.buf[hi->ptr[child]]) > 0)
 311         {
 312             key_heap_swap(hi, cur, child);
 313             cur = child;
 314             child = 2*cur;
 315         }
 316         else
 317             break;
 318     }
 319 }
 320
 321 static void key_heap_insert(struct heap_info *hi, const char *buf, int nbytes,
 322                              struct key_file *kf)
 323 {
 324     int cur, parent;
 325
 326     cur = ++(hi->heapnum);
 327     memcpy(hi->info.buf[hi->ptr[cur]], buf, nbytes);
 328     hi->info.file[hi->ptr[cur]] = kf;
 329
 330     parent = cur/2;
 331     while (parent && (*hi->cmp)(&hi->info.buf[hi->ptr[parent]],
 332                                 &hi->info.buf[hi->ptr[cur]]) > 0)
 333     {
 334         key_heap_swap(hi, cur, parent);
 335         cur = parent;
 336         parent = cur/2;
 337     }
 338 }
 339
 340 static int heap_read_one(struct heap_info *hi, char *name, char *key)
 341 {
 342     int n, r;
 343     char rbuf[INP_NAME_MAX];
 344     struct key_file *kf;
 345
 346     if (!hi->heapnum)
 347         return 0;
 348     n = hi->ptr[1];
 349     strcpy(name, hi->info.buf[n]);
 350     kf = hi->info.file[n];
 351     r = strlen(name);
 352     memcpy(key, hi->info.buf[n] + r+1, KEY_SIZE);
 353     key_heap_delete(hi);
 354     if ((r = key_file_read(kf, rbuf)))
 355         key_heap_insert(hi, rbuf, r, kf);
 356     hi->no_iterations++;
 357     return 1;
 358 }
 359
 360 #define PR_KEY_LOW 0
 361 #define PR_KEY_TOP 0
 362
 363 /* for debugging only */
 364 void zebra_log_dict_entry(ZebraHandle zh, const char *s)
 365 {
 366     char dst[IT_MAX_WORD+1];
 367     int ord;
 368     int len = key_SU_decode(&ord, (const unsigned char *) s);
 369     const char *index_type;
 370
 371     if (!zh)
 372         yaz_log(YLOG_LOG, "ord=%d", ord);
 373     else
 374     {
 375         const char *string_index;
 376         const char *db = 0;
 377         zebraExplain_lookup_ord(zh->reg->zei,
 378                                 ord, &index_type, &db, &string_index);
 379
 380         zebra_term_untrans(zh, index_type, dst, s + len);
 381
 382         yaz_log(YLOG_LOG, "ord=%d index_type=%s index=%s term=%s",
 383                 ord, index_type, string_index, dst);
 384     }
 385 }
 386
 387 struct heap_cread_info {
 388     char prev_name[INP_NAME_MAX];
 389     char cur_name[INP_NAME_MAX];
 390     char *key;
 391     char *key_1, *key_2;
 392     int mode_1, mode_2;
 393     int sz_1, sz_2;
 394     struct heap_info *hi;
 395     int first_in_list;
 396     int more;
 397     int ret;
 398     int look_level;
 399 };
 400
 401 static int heap_cread_item(void *vp, char **dst, int *insertMode);
 402
 403 int heap_cread_item2(void *vp, char **dst, int *insertMode)
 404 {
 405     struct heap_cread_info *p = (struct heap_cread_info *) vp;
 406     int level = 0;
 407
 408     if (p->look_level)
 409     {
 410         if (p->look_level > 0)
 411         {
 412             *insertMode = 1;
 413             p->look_level--;
 414         }
 415         else
 416         {
 417             *insertMode = 0;
 418             p->look_level++;
 419         }
 420         memcpy(*dst, p->key_1, p->sz_1);
 421 #if 0
 422         yaz_log(YLOG_LOG, "DUP level=%d", p->look_level);
 423         pkey(*dst, *insertMode);
 424 #endif
 425         (*dst) += p->sz_1;
 426         return 1;
 427     }
 428     if (p->ret == 0)    /* lookahead was 0?. Return that in read next round */
 429     {
 430         p->ret = -1;
 431         return 0;
 432     }
 433     else if (p->ret == -1) /* Must read new item ? */
 434     {
 435         char *dst_1 = p->key_1;
 436         p->ret = heap_cread_item(vp, &dst_1, &p->mode_1);
 437         p->sz_1 = dst_1 - p->key_1;
 438     }
 439     else
 440     {        /* lookahead in 2 . Now in 1. */
 441         p->sz_1 = p->sz_2;
 442         p->mode_1 = p->mode_2;
 443         memcpy(p->key_1, p->key_2, p->sz_2);
 444     }
 445     if (p->mode_1)
 446         level = 1;     /* insert */
 447     else
 448         level = -1;    /* delete */
 449     while(1)
 450     {
 451         char *dst_2 = p->key_2;
 452         p->ret = heap_cread_item(vp, &dst_2, &p->mode_2);
 453         if (!p->ret)
 454         {
 455             if (level)
 456                 break;
 457             p->ret = -1;
 458             return 0;
 459         }
 460         p->sz_2 = dst_2 - p->key_2;
 461
 462         if (key_compare(p->key_1, p->key_2) == 0)
 463         {
 464             if (p->mode_2) /* adjust level according to deletes/inserts */
 465                 level++;
 466             else
 467                 level--;
 468         }
 469         else
 470         {
 471             if (level)
 472                 break;
 473             /* all the same. new round .. */
 474             p->sz_1 = p->sz_2;
 475             p->mode_1 = p->mode_2;
 476             memcpy(p->key_1, p->key_2, p->sz_1);
 477             if (p->mode_1)
 478                 level = 1;     /* insert */
 479             else
 480                 level = -1;    /* delete */
 481         }
 482     }
 483     /* outcome is insert (1) or delete (0) depending on final level */
 484     if (level > 0)
 485     {
 486         *insertMode = 1;
 487         level--;
 488     }
 489     else
 490     {
 491         *insertMode = 0;
 492         level++;
 493     }
 494     p->look_level = level;
 495     memcpy(*dst, p->key_1, p->sz_1);
 496 #if 0
 497     pkey(*dst, *insertMode);
 498 #endif
 499     (*dst) += p->sz_1;
 500     return 1;
 501 }
 502
 503 int heap_cread_item(void *vp, char **dst, int *insertMode)
 504 {
 505     struct heap_cread_info *p = (struct heap_cread_info *) vp;
 506     struct heap_info *hi = p->hi;
 507
 508     if (p->first_in_list)
 509     {
 510         *insertMode = p->key[0];
 511         memcpy(*dst, p->key+1, sizeof(struct it_key));
 512 #if PR_KEY_LOW
 513         zebra_log_dict_entry(hi->zh, p->cur_name);
 514         pkey(*dst, *insertMode);
 515 #endif
 516         (*dst) += sizeof(struct it_key);
 517         p->first_in_list = 0;
 518         return 1;
 519     }
 520     strcpy(p->prev_name, p->cur_name);
 521     if (!(p->more = heap_read_one(hi, p->cur_name, p->key)))
 522         return 0;
 523     if (*p->cur_name && strcmp(p->cur_name, p->prev_name))
 524     {
 525         p->first_in_list = 1;
 526         return 0;
 527     }
 528     *insertMode = p->key[0];
 529     memcpy(*dst, p->key+1, sizeof(struct it_key));
 530 #if PR_KEY_LOW
 531     zebra_log_dict_entry(hi->zh, p->cur_name);
 532     pkey(*dst, *insertMode);
 533 #endif
 534     (*dst) += sizeof(struct it_key);
 535     return 1;
 536 }
 537
 538 int heap_inpc(struct heap_cread_info *hci, struct heap_info *hi)
 539 {
 540     ISAMC_I *isamc_i = (ISAMC_I *) xmalloc(sizeof(*isamc_i));
 541
 542     isamc_i->clientData = hci;
 543     isamc_i->read_item = heap_cread_item2;
 544
 545     while (hci->more)
 546     {
 547         char this_name[INP_NAME_MAX];
 548         ISAM_P isamc_p, isamc_p2;
 549         char *dict_info;
 550
 551         strcpy(this_name, hci->cur_name);
 552         assert(hci->cur_name[0]);
 553         hi->no_diffs++;
 554         if ((dict_info = dict_lookup(hi->reg->dict, hci->cur_name)))
 555         {
 556             memcpy(&isamc_p, dict_info+1, sizeof(ISAM_P));
 557             isamc_p2 = isamc_p;
 558             isamc_merge(hi->reg->isamc, &isamc_p2, isamc_i);
 559             if (!isamc_p2)
 560             {
 561                 hi->no_deletions++;
 562                 if (!dict_delete(hi->reg->dict, this_name))
 563                     abort();
 564             }
 565             else
 566             {
 567                 hi->no_updates++;
 568                 if (isamc_p2 != isamc_p)
 569                     dict_insert(hi->reg->dict, this_name,
 570                                  sizeof(ISAM_P), &isamc_p2);
 571             }
 572         }
 573         else
 574         {
 575             isamc_p = 0;
 576             isamc_merge(hi->reg->isamc, &isamc_p, isamc_i);
 577             hi->no_insertions++;
 578             if (isamc_p)
 579                 dict_insert(hi->reg->dict, this_name,
 580                              sizeof(ISAM_P), &isamc_p);
 581         }
 582     }
 583     xfree(isamc_i);
 584     return 0;
 585 }
 586
 587 int heap_inpb(struct heap_cread_info *hci, struct heap_info *hi)
 588 {
 589     ISAMC_I *isamc_i = (ISAMC_I *) xmalloc(sizeof(*isamc_i));
 590
 591     isamc_i->clientData = hci;
 592     isamc_i->read_item = heap_cread_item2;
 593
 594     while (hci->more)
 595     {
 596         char this_name[INP_NAME_MAX];
 597         ISAM_P isamc_p, isamc_p2;
 598         char *dict_info;
 599
 600         strcpy(this_name, hci->cur_name);
 601         assert(hci->cur_name[0]);
 602         hi->no_diffs++;
 603
 604 #if 0
 605         assert(hi->zh);
 606         zebra_log_dict_entry(hi->zh, hci->cur_name);
 607 #endif
 608         if ((dict_info = dict_lookup(hi->reg->dict, hci->cur_name)))
 609         {
 610             memcpy(&isamc_p, dict_info+1, sizeof(ISAM_P));
 611             isamc_p2 = isamc_p;
 612             isamb_merge(hi->reg->isamb, &isamc_p2, isamc_i);
 613             if (!isamc_p2)
 614             {
 615                 hi->no_deletions++;
 616                 if (!dict_delete(hi->reg->dict, this_name))
 617                     abort();
 618             }
 619             else
 620             {
 621                 hi->no_updates++;
 622                 if (isamc_p2 != isamc_p)
 623                     dict_insert(hi->reg->dict, this_name,
 624                                  sizeof(ISAM_P), &isamc_p2);
 625             }
 626         }
 627         else
 628         {
 629             isamc_p = 0;
 630             isamb_merge(hi->reg->isamb, &isamc_p, isamc_i);
 631             hi->no_insertions++;
 632             if (isamc_p)
 633                 dict_insert(hi->reg->dict, this_name,
 634                              sizeof(ISAM_P), &isamc_p);
 635         }
 636     }
 637     xfree(isamc_i);
 638     return 0;
 639 }
 640
 641 int heap_inps(struct heap_cread_info *hci, struct heap_info *hi)
 642 {
 643     ISAMS_I isams_i = (ISAMS_I) xmalloc(sizeof(*isams_i));
 644
 645     isams_i->clientData = hci;
 646     isams_i->read_item = heap_cread_item;
 647
 648     while (hci->more)
 649     {
 650         char this_name[INP_NAME_MAX];
 651         ISAM_P isams_p;
 652         char *dict_info;
 653
 654         strcpy(this_name, hci->cur_name);
 655         assert(hci->cur_name[0]);
 656         hi->no_diffs++;
 657         if (!(dict_info = dict_lookup(hi->reg->dict, hci->cur_name)))
 658         {
 659             isams_p = isams_merge(hi->reg->isams, isams_i);
 660             hi->no_insertions++;
 661             dict_insert(hi->reg->dict, this_name, sizeof(ISAM_P), &isams_p);
 662         }
 663         else
 664         {
 665             yaz_log(YLOG_FATAL, "isams doesn't support this kind of update");
 666             break;
 667         }
 668     }
 669     xfree(isams_i);
 670     return 0;
 671 }
 672
 673 struct progressInfo {
 674     time_t   startTime;
 675     time_t   lastTime;
 676     off_t    totalBytes;
 677     off_t    totalOffset;
 678 };
 679
 680 void progressFunc(struct key_file *keyp, void *info)
 681 {
 682     struct progressInfo *p = (struct progressInfo *) info;
 683     time_t now, remaining;
 684
 685     if (keyp->buf_size <= 0 || p->totalBytes <= 0)
 686         return ;
 687     time (&now);
 688
 689     if (now >= p->lastTime+10)
 690     {
 691         p->lastTime = now;
 692         remaining = (time_t) ((now - p->startTime)*
 693             ((double) p->totalBytes/p->totalOffset - 1.0));
 694         if (remaining <= 130)
 695             yaz_log(YLOG_LOG, "Merge %2.1f%% completed; %ld seconds remaining",
 696                  (100.0*p->totalOffset) / p->totalBytes, (long) remaining);
 697         else
 698             yaz_log(YLOG_LOG, "Merge %2.1f%% completed; %ld minutes remaining",
 699                  (100.0*p->totalOffset) / p->totalBytes, (long) remaining/60);
 700     }
 701     p->totalOffset += keyp->buf_size;
 702 }
 703
 704 #ifndef R_OK
 705 #define R_OK 4
 706 #endif
 707
 708 void zebra_index_merge(ZebraHandle zh)
 709 {
 710     struct key_file **kf = 0;
 711     char rbuf[1024];
 712     int i, r;
 713     struct heap_info *hi;
 714     struct progressInfo progressInfo;
 715     int nkeys = key_block_get_no_files(zh->reg->key_block);
 716
 717     if (nkeys == 0)
 718         return;
 719
 720     if (nkeys < 0)
 721     {
 722         char fname[1024];
 723         nkeys = 0;
 724         while (1)
 725         {
 726             extract_get_fname_tmp (zh, fname, nkeys+1);
 727             if (access(fname, R_OK) == -1)
 728                 break;
 729             nkeys++;
 730         }
 731         if (!nkeys)
 732             return ;
 733     }
 734     kf = (struct key_file **) xmalloc((1+nkeys) * sizeof(*kf));
 735     progressInfo.totalBytes = 0;
 736     progressInfo.totalOffset = 0;
 737     time(&progressInfo.startTime);
 738     time(&progressInfo.lastTime);
 739     for (i = 1; i<=nkeys; i++)
 740     {
 741         kf[i] = key_file_init(i, 8192, zh->res);
 742         kf[i]->readHandler = progressFunc;
 743         kf[i]->readInfo = &progressInfo;
 744         progressInfo.totalBytes += kf[i]->length;
 745         progressInfo.totalOffset += kf[i]->buf_size;
 746     }
 747     hi = key_heap_init_file(zh, nkeys, key_qsort_compare);
 748     hi->reg = zh->reg;
 749
 750     for (i = 1; i<=nkeys; i++)
 751         if ((r = key_file_read(kf[i], rbuf)))
 752             key_heap_insert(hi, rbuf, r, kf[i]);
 753
 754     if (1)
 755     {
 756         struct heap_cread_info hci;
 757
 758         hci.key = (char *) xmalloc(KEY_SIZE);
 759         hci.key_1 = (char *) xmalloc(KEY_SIZE);
 760         hci.key_2 = (char *) xmalloc(KEY_SIZE);
 761         hci.ret = -1;
 762         hci.first_in_list = 1;
 763         hci.hi = hi;
 764         hci.look_level = 0;
 765         hci.more = heap_read_one(hi, hci.cur_name, hci.key);
 766
 767         if (zh->reg->isams)
 768             heap_inps(&hci, hi);
 769         if (zh->reg->isamc)
 770             heap_inpc(&hci, hi);
 771         if (zh->reg->isamb)
 772             heap_inpb(&hci, hi);
 773
 774         xfree(hci.key);
 775         xfree(hci.key_1);
 776         xfree(hci.key_2);
 777     }
 778
 779     for (i = 1; i<=nkeys; i++)
 780     {
 781         extract_get_fname_tmp (zh, rbuf, i);
 782         unlink(rbuf);
 783     }
 784     for (i = 1; i<=nkeys; i++)
 785         key_file_destroy(kf[i]);
 786     xfree(kf);
 787     if (hi->no_iterations)
 788     { /* do not log if nothing happened */
 789         yaz_log(YLOG_LOG, "Iterations: isam/dict "
 790                 ZINT_FORMAT "/" ZINT_FORMAT,
 791                 hi->no_iterations, hi->no_diffs);
 792         yaz_log(YLOG_LOG, "Dict: inserts/updates/deletions: "
 793                 ZINT_FORMAT "/" ZINT_FORMAT "/" ZINT_FORMAT,
 794                 hi->no_insertions, hi->no_updates, hi->no_deletions);
 795     }
 796     key_block_destroy(&zh->reg->key_block);
 797     key_heap_destroy(hi, nkeys);
 798 }
 799 /*
 800  * Local variables:
 801  * c-basic-offset: 4
 802  * indent-tabs-mode: nil
 803  * End:
 804  * vim: shiftwidth=4 tabstop=8 expandtab
 805  */
 806