Make two functions to get term/doc occurrences rather than one.
[idzebra-moved-to-github.git] / index / kinput.c
1 /* $Id: kinput.c,v 1.74 2006-05-10 08:13:22 adam Exp $
2    Copyright (C) 1995-2005
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 Zebra; see the file LICENSE.zebra.  If not, write to the
19 Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
20 02111-1307, USA.
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 #define INP_BUF_START 60000
40 #define INP_BUF_ADD  400000
41
42 struct key_file {
43     int   no;            /* file no */
44     off_t offset;        /* file offset */
45     unsigned char *buf;  /* buffer block */
46     size_t buf_size;     /* number of read bytes in block */
47     size_t chunk;        /* number of bytes allocated */
48     size_t buf_ptr;      /* current position in buffer */
49     char *prev_name;     /* last word read */
50     void *decode_handle;
51     off_t length;        /* length of file */
52                          /* handler invoked in each read */
53     void (*readHandler)(struct key_file *keyp, void *rinfo);
54     void *readInfo;
55     Res res;
56 };
57
58 #if 0
59 static void pkey(const char *b, int mode)
60 {
61     key_logdump_txt(YLOG_LOG, b, mode ? "i" : "d");
62 }
63 #endif
64
65
66 void getFnameTmp (Res res, char *fname, int no)
67 {
68     const char *pre;
69     
70     pre = res_get_def (res, "keyTmpDir", ".");
71     sprintf (fname, "%s/key%d.tmp", pre, no);
72 }
73
74 void extract_get_fname_tmp (ZebraHandle zh, char *fname, int no)
75 {
76     const char *pre;
77     
78     pre = res_get_def (zh->res, "keyTmpDir", ".");
79     sprintf (fname, "%s/key%d.tmp", pre, no);
80 }
81
82 void key_file_chunk_read (struct key_file *f)
83 {
84     int nr = 0, r = 0, fd;
85     char fname[1024];
86     getFnameTmp (f->res, fname, f->no);
87     fd = open (fname, O_BINARY|O_RDONLY);
88
89     f->buf_ptr = 0;
90     f->buf_size = 0;
91     if (fd == -1)
92     {
93         yaz_log (YLOG_WARN|YLOG_ERRNO, "cannot open %s", fname);
94         return ;
95     }
96     if (!f->length)
97     {
98         if ((f->length = lseek (fd, 0L, SEEK_END)) == (off_t) -1)
99         {
100             yaz_log (YLOG_WARN|YLOG_ERRNO, "cannot seek %s", fname);
101             close (fd);
102             return ;
103         }
104     }
105     if (lseek (fd, f->offset, SEEK_SET) == -1)
106     {
107         yaz_log (YLOG_WARN|YLOG_ERRNO, "cannot seek %s", fname);
108         close(fd);
109         return ;
110     }
111     while (f->chunk - nr > 0)
112     {
113         r = read (fd, f->buf + nr, f->chunk - nr);
114         if (r <= 0)
115             break;
116         nr += r;
117     }
118     if (r == -1)
119     {
120         yaz_log (YLOG_WARN|YLOG_ERRNO, "read of %s", fname);
121         close (fd);
122         return;
123     }
124     f->buf_size = nr;
125     if (f->readHandler)
126         (*f->readHandler)(f, f->readInfo);
127     close (fd);
128 }
129
130 void key_file_destroy (struct key_file *f)
131 {
132     iscz1_stop(f->decode_handle);
133     xfree (f->buf);
134     xfree (f->prev_name);
135     xfree (f);
136 }
137
138 struct key_file *key_file_init (int no, int chunk, Res res)
139 {
140     struct key_file *f;
141
142     f = (struct key_file *) xmalloc (sizeof(*f));
143     f->res = res;
144     f->decode_handle = iscz1_start();
145     f->no = no;
146     f->chunk = chunk;
147     f->offset = 0;
148     f->length = 0;
149     f->readHandler = NULL;
150     f->buf = (unsigned char *) xmalloc (f->chunk);
151     f->prev_name = (char *) xmalloc (INP_NAME_MAX);
152     *f->prev_name = '\0';
153     key_file_chunk_read (f);
154     return f;
155 }
156
157 int key_file_getc (struct key_file *f)
158 {
159     if (f->buf_ptr < f->buf_size)
160         return f->buf[(f->buf_ptr)++];
161     if (f->buf_size < f->chunk)
162         return EOF;
163     f->offset += f->buf_size;
164     key_file_chunk_read (f);
165     if (f->buf_ptr < f->buf_size)
166         return f->buf[(f->buf_ptr)++];
167     else
168         return EOF;
169 }
170
171 int key_file_decode (struct key_file *f)
172 {
173     int c, d;
174
175     c = key_file_getc (f);
176     switch (c & 192) 
177     {
178     case 0:
179         d = c;
180         break;
181     case 64:
182         d = ((c&63) << 8) + (key_file_getc (f) & 0xff);
183         break;
184     case 128:
185         d = ((c&63) << 8) + (key_file_getc (f) & 0xff);
186         d = (d << 8) + (key_file_getc (f) & 0xff);
187         break;
188     default: /* 192 */
189         d = ((c&63) << 8) + (key_file_getc (f) & 0xff);
190         d = (d << 8) + (key_file_getc (f) & 0xff);
191         d = (d << 8) + (key_file_getc (f) & 0xff);
192         break;
193     }
194     return d;
195 }
196
197 int key_file_read (struct key_file *f, char *key)
198 {
199     int i, c;
200     char srcbuf[128];
201     const char *src = srcbuf;
202     char *dst;
203     int j;
204
205     c = key_file_getc (f);
206     if (c == 0)
207     {
208         strcpy (key, f->prev_name);
209         i = 1+strlen (key);
210     }
211     else if (c == EOF)
212         return 0;
213     else
214     {
215         i = 0;
216         key[i++] = c;
217         while ((key[i++] = key_file_getc (f)))
218             ;
219         strcpy (f->prev_name, key);
220         iscz1_reset(f->decode_handle);
221     }
222     c = key_file_getc(f); /* length +  insert/delete combined */
223     key[i++] = c & 128;
224     c = c & 127;
225     for (j = 0; j < c; j++)
226         srcbuf[j] = key_file_getc(f);
227     dst = key + i;
228     iscz1_decode(f->decode_handle, &dst, &src);
229
230 #if 0
231     /* debugging */
232     if (1)
233     {
234         struct it_key k;
235         memcpy(&k, key+i, sizeof(k));
236         if (!k.mem[1])
237             yaz_log(YLOG_LOG, "00 KEY");
238     }
239 #endif
240     return i + sizeof(struct it_key);
241 }
242
243 struct heap_info {
244     struct {
245         struct key_file **file;
246         char   **buf;
247     } info;
248     int    heapnum;
249     int    *ptr;
250     int    (*cmp)(const void *p1, const void *p2);
251     struct zebra_register *reg;
252     ZebraHandle zh;
253     int raw_reading; /* 1=raw /mem read. 0=file reading */
254     int no_diffs;
255     int no_updates;
256     int no_deletions;
257     int no_insertions;
258     int no_iterations;
259 };
260
261 static struct heap_info *key_heap_malloc()
262 {  /* malloc and clear it */
263     struct heap_info *hi;
264     hi = (struct heap_info *) xmalloc (sizeof(*hi));
265     hi->info.file = 0;
266     hi->info.buf = 0;
267     hi->heapnum = 0;
268     hi->ptr = 0;
269     hi->raw_reading = 0;
270     hi->no_diffs = 0;
271     hi->no_diffs = 0;
272     hi->no_updates = 0;
273     hi->no_deletions = 0;
274     hi->no_insertions = 0;
275     hi->no_iterations = 0;
276     return hi;
277 }
278
279 struct heap_info *key_heap_init_file(ZebraHandle zh,
280                                      int nkeys,
281                                      int (*cmp)(const void *p1, const void *p2))
282 {
283     struct heap_info *hi;
284     int i;
285
286     hi = key_heap_malloc();
287     hi->zh = zh;
288     hi->info.file = (struct key_file **)
289         xmalloc (sizeof(*hi->info.file) * (1+nkeys));
290     hi->info.buf = (char **) xmalloc (sizeof(*hi->info.buf) * (1+nkeys));
291     hi->ptr = (int *) xmalloc (sizeof(*hi->ptr) * (1+nkeys));
292     hi->cmp = cmp;
293     for (i = 0; i<= nkeys; i++)
294     {
295         hi->ptr[i] = i;
296         hi->info.buf[i] = (char *) xmalloc (INP_NAME_MAX);
297     }
298     return hi;
299 }
300
301 struct heap_info *key_heap_init_raw(ZebraHandle zh,
302                                     int (*cmp)(const void *p1, const void *p2))
303 {
304     struct heap_info *hi=key_heap_malloc();
305     hi->cmp = cmp;
306     hi->zh = zh;
307     hi->raw_reading = 1;
308     return hi;
309 }
310
311 void key_heap_destroy (struct heap_info *hi, int nkeys)
312 {
313     int i;
314     if (!hi->raw_reading)
315         for (i = 0; i<=nkeys; i++)
316             xfree (hi->info.buf[i]);
317     
318     xfree (hi->info.buf);
319     xfree (hi->ptr);
320     xfree (hi->info.file);
321     xfree (hi);
322 }
323
324 static void key_heap_swap (struct heap_info *hi, int i1, int i2)
325 {
326     int swap;
327
328     swap = hi->ptr[i1];
329     hi->ptr[i1] = hi->ptr[i2];
330     hi->ptr[i2] = swap;
331 }
332
333
334 static void key_heap_delete (struct heap_info *hi)
335 {
336     int cur = 1, child = 2;
337
338     assert (hi->heapnum > 0);
339
340     key_heap_swap (hi, 1, hi->heapnum);
341     hi->heapnum--;
342     while (child <= hi->heapnum) {
343         if (child < hi->heapnum &&
344             (*hi->cmp)(&hi->info.buf[hi->ptr[child]],
345                        &hi->info.buf[hi->ptr[child+1]]) > 0)
346             child++;
347         if ((*hi->cmp)(&hi->info.buf[hi->ptr[cur]],
348                        &hi->info.buf[hi->ptr[child]]) > 0)
349         {            
350             key_heap_swap (hi, cur, child);
351             cur = child;
352             child = 2*cur;
353         }
354         else
355             break;
356     }
357 }
358
359 static void key_heap_insert (struct heap_info *hi, const char *buf, int nbytes,
360                              struct key_file *kf)
361 {
362     int cur, parent;
363
364     cur = ++(hi->heapnum);
365     memcpy (hi->info.buf[hi->ptr[cur]], buf, nbytes);
366     hi->info.file[hi->ptr[cur]] = kf;
367
368     parent = cur/2;
369     while (parent && (*hi->cmp)(&hi->info.buf[hi->ptr[parent]],
370                                 &hi->info.buf[hi->ptr[cur]]) > 0)
371     {
372         key_heap_swap (hi, cur, parent);
373         cur = parent;
374         parent = cur/2;
375     }
376 }
377
378 static int heap_read_one_raw(struct heap_info *hi, char *name, char *key)
379 {
380     ZebraHandle zh = hi->zh;
381     size_t ptr_i = zh->reg->ptr_i;
382     char *cp;
383     if (!ptr_i)
384         return 0;
385     --(zh->reg->ptr_i);
386     cp=(zh->reg->key_buf)[zh->reg->ptr_top - ptr_i];
387     strcpy(name, cp);
388     memcpy(key, cp+strlen(name)+1, KEY_SIZE);
389     hi->no_iterations++;
390     return 1;
391 }
392
393 static int heap_read_one (struct heap_info *hi, char *name, char *key)
394 {
395     int n, r;
396     char rbuf[INP_NAME_MAX];
397     struct key_file *kf;
398
399     if (hi->raw_reading)
400         return heap_read_one_raw(hi, name, key);
401
402     if (!hi->heapnum)
403         return 0;
404     n = hi->ptr[1];
405     strcpy (name, hi->info.buf[n]);
406     kf = hi->info.file[n];
407     r = strlen(name);
408     memcpy (key, hi->info.buf[n] + r+1, KEY_SIZE);
409     key_heap_delete (hi);
410     if ((r = key_file_read (kf, rbuf)))
411         key_heap_insert (hi, rbuf, r, kf);
412     hi->no_iterations++;
413     return 1;
414 }
415
416 #define PR_KEY_LOW 0
417 #define PR_KEY_TOP 0
418
419 #if 0
420 /* for debugging only */
421 static void print_dict_item(ZebraHandle zh, const char *s)
422 {
423     char dst[IT_MAX_WORD+1];
424     int ord;
425     int len = key_SU_decode(&ord, (const unsigned char *) s);
426     int index_type;
427     const char *db = 0;
428
429     if (!zh)
430         yaz_log(YLOG_LOG, "ord=%d", ord);
431     else
432     {
433         zebraExplain_lookup_ord (zh->reg->zei,
434                              ord, &index_type, &db, 0, 0, 0);
435
436         zebra_term_untrans(zh, index_type, dst, s + len);
437
438         yaz_log(YLOG_LOG, "ord=%d term=%s", ord, dst);
439     }
440 }
441 #endif
442
443 struct heap_cread_info {
444     char prev_name[INP_NAME_MAX];
445     char cur_name[INP_NAME_MAX];
446     char *key;
447     char *key_1, *key_2;
448     int mode_1, mode_2;
449     int sz_1, sz_2;
450     struct heap_info *hi;
451     int first_in_list;
452     int more;
453     int ret;
454     int look_level;
455 };
456
457 static int heap_cread_item (void *vp, char **dst, int *insertMode);
458
459 int heap_cread_item2(void *vp, char **dst, int *insertMode)
460 {
461     struct heap_cread_info *p = (struct heap_cread_info *) vp;
462     int level = 0;
463
464     if (p->look_level)
465     {
466         if (p->look_level > 0)
467         {
468             *insertMode = 1;
469             p->look_level--;
470         }
471         else
472         {
473             *insertMode = 0;
474             p->look_level++;
475         }
476         memcpy (*dst, p->key_1, p->sz_1);
477 #if 0
478         yaz_log(YLOG_LOG, "DUP level=%d", p->look_level);
479         pkey(*dst, *insertMode);
480 #endif
481         (*dst) += p->sz_1;
482         return 1;
483     }
484     if (p->ret == 0)    /* lookahead was 0?. Return that in read next round */
485     {
486         p->ret = -1;
487         return 0;
488     }
489     else if (p->ret == -1) /* Must read new item ? */
490     {
491         char *dst_1 = p->key_1;
492         p->ret = heap_cread_item(vp, &dst_1, &p->mode_1);
493         p->sz_1 = dst_1 - p->key_1;
494     }
495     else
496     {        /* lookahead in 2 . Now in 1. */
497         p->sz_1 = p->sz_2;
498         p->mode_1 = p->mode_2;
499         memcpy (p->key_1, p->key_2, p->sz_2);
500     }
501     if (p->mode_1)
502         level = 1;     /* insert */
503     else
504         level = -1;    /* delete */
505     while(1)
506     {
507         char *dst_2 = p->key_2;
508         p->ret = heap_cread_item(vp, &dst_2, &p->mode_2);
509         if (!p->ret)
510         {
511             if (level)
512                 break;
513             p->ret = -1;
514             return 0;
515         }
516         p->sz_2 = dst_2 - p->key_2;
517
518         if (key_compare(p->key_1, p->key_2) == 0)
519         {
520             if (p->mode_2) /* adjust level according to deletes/inserts */
521                 level++;
522             else
523                 level--;
524         }
525         else
526         {
527             if (level)
528                 break;
529             /* all the same. new round .. */
530             p->sz_1 = p->sz_2;
531             p->mode_1 = p->mode_2;
532             memcpy (p->key_1, p->key_2, p->sz_1);
533             if (p->mode_1)
534                 level = 1;     /* insert */
535             else
536                 level = -1;    /* delete */
537         }
538     }
539     /* outcome is insert (1) or delete (0) depending on final level */
540     if (level > 0)
541     {
542         *insertMode = 1;
543         level--;
544     }
545     else
546     {
547         *insertMode = 0;
548         level++;
549     }
550     p->look_level = level;
551     memcpy (*dst, p->key_1, p->sz_1);
552 #if 0
553     pkey(*dst, *insertMode);
554 #endif
555     (*dst) += p->sz_1;
556     return 1;
557 }
558       
559 int heap_cread_item (void *vp, char **dst, int *insertMode)
560 {
561     struct heap_cread_info *p = (struct heap_cread_info *) vp;
562     struct heap_info *hi = p->hi;
563
564     if (p->first_in_list)
565     {
566         *insertMode = p->key[0];
567         memcpy (*dst, p->key+1, sizeof(struct it_key));
568 #if PR_KEY_LOW
569         pkey(*dst, *insertMode);
570 #endif
571         (*dst) += sizeof(struct it_key);
572         p->first_in_list = 0;
573         return 1;
574     }
575     strcpy (p->prev_name, p->cur_name);
576     if (!(p->more = heap_read_one (hi, p->cur_name, p->key)))
577         return 0;
578     if (*p->cur_name && strcmp (p->cur_name, p->prev_name))
579     {
580         p->first_in_list = 1;
581         return 0;
582     }
583     *insertMode = p->key[0];
584     memcpy (*dst, p->key+1, sizeof(struct it_key));
585 #if PR_KEY_LOW
586     pkey(*dst, *insertMode);
587 #endif
588     (*dst) += sizeof(struct it_key);
589     return 1;
590 }
591
592 int heap_inpc (struct heap_cread_info *hci, struct heap_info *hi)
593 {
594     ISAMC_I *isamc_i = (ISAMC_I *) xmalloc (sizeof(*isamc_i));
595
596     isamc_i->clientData = hci;
597     isamc_i->read_item = heap_cread_item2;
598
599     while (hci->more)
600     {
601         char this_name[INP_NAME_MAX];
602         ISAM_P isamc_p, isamc_p2;
603         char *dict_info;
604
605         strcpy (this_name, hci->cur_name);
606         assert (hci->cur_name[1]);
607         hi->no_diffs++;
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             isamc_merge (hi->reg->isamc, &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             isamc_merge (hi->reg->isamc, &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_inp0(struct heap_cread_info *hci, struct heap_info *hi)
642 {
643     while (hci->more)
644     {
645         char this_name[INP_NAME_MAX];
646         char mybuf[1024];
647         char *dst = mybuf;
648         int mode;
649
650         strcpy (this_name, hci->cur_name);
651         assert (hci->cur_name[1]);
652         hi->no_diffs++;
653
654         while (heap_cread_item2(hci, &dst, &mode))
655             ;
656     }
657     return 0;
658
659
660
661 int heap_inpb(struct heap_cread_info *hci, struct heap_info *hi)
662 {
663     ISAMC_I *isamc_i = (ISAMC_I *) xmalloc (sizeof(*isamc_i));
664
665     isamc_i->clientData = hci;
666     isamc_i->read_item = heap_cread_item2;
667
668     while (hci->more)
669     {
670         char this_name[INP_NAME_MAX];
671         ISAM_P isamc_p, isamc_p2;
672         char *dict_info;
673
674         strcpy (this_name, hci->cur_name);
675         assert (hci->cur_name[1]);
676         hi->no_diffs++;
677
678 #if 0
679         assert(hi->zh);
680         print_dict_item(hi->zh, hci->cur_name);
681 #endif
682         if ((dict_info = dict_lookup (hi->reg->dict, hci->cur_name)))
683         {
684             memcpy (&isamc_p, dict_info+1, sizeof(ISAM_P));
685             isamc_p2 = isamc_p;
686             isamb_merge (hi->reg->isamb, &isamc_p2, isamc_i);
687             if (!isamc_p2)
688             {
689                 hi->no_deletions++;
690                 if (!dict_delete (hi->reg->dict, this_name))
691                     abort();
692             }
693             else 
694             {
695                 hi->no_updates++;
696                 if (isamc_p2 != isamc_p)
697                     dict_insert (hi->reg->dict, this_name,
698                                  sizeof(ISAM_P), &isamc_p2);
699             }
700         } 
701         else
702         {
703             isamc_p = 0;
704             isamb_merge (hi->reg->isamb, &isamc_p, isamc_i);
705             hi->no_insertions++;
706             if (isamc_p)
707                 dict_insert (hi->reg->dict, this_name,
708                              sizeof(ISAM_P), &isamc_p);
709         }
710     }
711     xfree(isamc_i);
712     return 0;
713
714
715 int heap_inps (struct heap_cread_info *hci, struct heap_info *hi)
716 {
717     ISAMS_I isams_i = (ISAMS_I) xmalloc (sizeof(*isams_i));
718
719     isams_i->clientData = hci;
720     isams_i->read_item = heap_cread_item;
721
722     while (hci->more)
723     {
724         char this_name[INP_NAME_MAX];
725         ISAM_P isams_p;
726         char *dict_info;
727
728         strcpy (this_name, hci->cur_name);
729         assert (hci->cur_name[1]);
730         hi->no_diffs++;
731         if (!(dict_info = dict_lookup (hi->reg->dict, hci->cur_name)))
732         {
733             isams_p = isams_merge (hi->reg->isams, isams_i);
734             hi->no_insertions++;
735             dict_insert (hi->reg->dict, this_name, sizeof(ISAM_P), &isams_p);
736         }
737         else
738         {
739             yaz_log (YLOG_FATAL, "isams doesn't support this kind of update");
740             break;
741         }
742     }
743     xfree (isams_i);
744     return 0;
745
746
747 struct progressInfo {
748     time_t   startTime;
749     time_t   lastTime;
750     off_t    totalBytes;
751     off_t    totalOffset;
752 };
753
754 void progressFunc (struct key_file *keyp, void *info)
755 {
756     struct progressInfo *p = (struct progressInfo *) info;
757     time_t now, remaining;
758
759     if (keyp->buf_size <= 0 || p->totalBytes <= 0)
760         return ;
761     time (&now);
762
763     if (now >= p->lastTime+10)
764     {
765         p->lastTime = now;
766         remaining = (time_t) ((now - p->startTime)*
767             ((double) p->totalBytes/p->totalOffset - 1.0));
768         if (remaining <= 130)
769             yaz_log (YLOG_LOG, "Merge %2.1f%% completed; %ld seconds remaining",
770                  (100.0*p->totalOffset) / p->totalBytes, (long) remaining);
771         else
772             yaz_log (YLOG_LOG, "Merge %2.1f%% completed; %ld minutes remaining",
773                  (100.0*p->totalOffset) / p->totalBytes, (long) remaining/60);
774     }
775     p->totalOffset += keyp->buf_size;
776 }
777
778 #ifndef R_OK
779 #define R_OK 4
780 #endif
781
782 void zebra_index_merge (ZebraHandle zh)
783 {
784     struct key_file **kf = 0;
785     char rbuf[1024];
786     int i, r;
787     struct heap_info *hi;
788     struct progressInfo progressInfo;
789     int nkeys = zh->reg->key_file_no;
790     int usefile; 
791     yaz_log (YLOG_DEBUG, " index_merge called with nk=%d b=%p", 
792                     nkeys, zh->reg->key_buf);
793     if ( (nkeys==0) && (zh->reg->key_buf==0) )
794         return; /* nothing to merge - probably flush after end-trans */
795     
796     usefile = (nkeys!=0); 
797
798     if (usefile)
799     {
800         if (nkeys < 0)
801         {
802             char fname[1024];
803             nkeys = 0;
804             while (1)
805             {
806                 extract_get_fname_tmp  (zh, fname, nkeys+1);
807                 if (access (fname, R_OK) == -1)
808                         break;
809                 nkeys++;
810             }
811             if (!nkeys)
812                 return ;
813         }
814         kf = (struct key_file **) xmalloc ((1+nkeys) * sizeof(*kf));
815         progressInfo.totalBytes = 0;
816         progressInfo.totalOffset = 0;
817         time (&progressInfo.startTime);
818         time (&progressInfo.lastTime);
819         for (i = 1; i<=nkeys; i++)
820         {
821             kf[i] = key_file_init (i, 8192, zh->res);
822             kf[i]->readHandler = progressFunc;
823             kf[i]->readInfo = &progressInfo;
824             progressInfo.totalBytes += kf[i]->length;
825             progressInfo.totalOffset += kf[i]->buf_size;
826         }
827         hi = key_heap_init_file(zh, nkeys, key_qsort_compare);
828         hi->reg = zh->reg;
829         
830         for (i = 1; i<=nkeys; i++)
831             if ((r = key_file_read (kf[i], rbuf)))
832                 key_heap_insert (hi, rbuf, r, kf[i]);
833     }  /* use file */
834     else 
835     { /* do not use file, read straight from buffer */
836         hi = key_heap_init_raw(zh, key_qsort_compare);
837         hi->reg = zh->reg;
838     }
839
840     if (1)
841     {
842         struct heap_cread_info hci;
843     
844         hci.key = (char *) xmalloc (KEY_SIZE);
845         hci.key_1 = (char *) xmalloc (KEY_SIZE);
846         hci.key_2 = (char *) xmalloc (KEY_SIZE);
847         hci.ret = -1;
848         hci.first_in_list = 1;
849         hci.hi = hi;
850         hci.look_level = 0;
851         hci.more = heap_read_one (hi, hci.cur_name, hci.key);    
852         
853         if (zh->reg->isams)
854             heap_inps(&hci, hi);
855         if (zh->reg->isamc)
856             heap_inpc(&hci, hi);
857         if (zh->reg->isamb)
858             heap_inpb(&hci, hi);
859         
860         xfree (hci.key);
861         xfree (hci.key_1);
862         xfree (hci.key_2);
863     }
864         
865     if (usefile)
866     {
867         for (i = 1; i<=nkeys; i++)
868         {
869             extract_get_fname_tmp  (zh, rbuf, i);
870             unlink (rbuf);
871         }
872         for (i = 1; i<=nkeys; i++)
873             key_file_destroy (kf[i]);
874         xfree (kf);
875     }
876     if (hi->no_iterations)
877     { /* do not log if nothing happened */
878         yaz_log (YLOG_LOG, "Iterations . . .%7d", hi->no_iterations);
879         yaz_log (YLOG_LOG, "Distinct words .%7d", hi->no_diffs);
880         yaz_log (YLOG_LOG, "Updates. . . . .%7d", hi->no_updates);
881         yaz_log (YLOG_LOG, "Deletions. . . .%7d", hi->no_deletions);
882         yaz_log (YLOG_LOG, "Insertions . . .%7d", hi->no_insertions);
883     }
884     zh->reg->key_file_no = 0;
885
886     key_heap_destroy (hi, nkeys);
887 }
888 /*
889  * Local variables:
890  * c-basic-offset: 4
891  * indent-tabs-mode: nil
892  * End:
893  * vim: shiftwidth=4 tabstop=8 expandtab
894  */
895