Experiment with combined shared lib libidzebra-all.la. Create
[idzebra-moved-to-github.git] / index / zsets.c
1 /* $Id: zsets.c,v 1.99 2006-01-26 22:17:16 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
24 #include <stdio.h>
25 #include <assert.h>
26 #ifdef WIN32
27 #include <io.h>
28 #else
29 #include <unistd.h>
30 #endif
31
32 #include "index.h"
33 #include <yaz/diagbib1.h>
34 #include <rset.h>
35
36 #define SORT_IDX_ENTRYSIZE 64
37 #define ZSET_SORT_MAX_LEVEL 3
38
39 struct zebra_set_term_entry {
40     int reg_type;
41     char *db;
42     int set;
43     int use;
44     char *term;
45 };
46
47 struct zebra_set {
48     char *name;
49     RSET rset;
50     NMEM nmem;
51     NMEM rset_nmem; /* for creating the rsets in */
52     zint hits;
53     int num_bases;
54     char **basenames;
55     Z_RPNQuery *rpn;
56     Z_SortKeySpecList *sortSpec;
57     struct zset_sort_info *sort_info;
58     struct zebra_set_term_entry *term_entries;
59     int term_entries_max;
60     struct zebra_set *next;
61     int locked;
62
63     zint cache_position;  /* last position */
64     RSFD cache_rfd;       /* rfd (NULL if not existing) */
65     zint cache_psysno;    /* sysno for last position */
66     zint approx_limit;    /* limit before we do approx */
67 };
68
69 struct zset_sort_entry {
70     zint sysno;
71     int score;
72     char buf[ZSET_SORT_MAX_LEVEL][SORT_IDX_ENTRYSIZE];
73 };
74
75 struct zset_sort_info {
76     int max_entries;
77     int num_entries;
78     struct zset_sort_entry *all_entries;
79     struct zset_sort_entry **entries;
80 };
81
82 static int log_level_set=0;
83 static int log_level_sort=0;
84 static int log_level_searchhits=0;
85 static int log_level_searchterms=0;
86 static int log_level_resultsets=0;
87
88 static void loglevels()
89 {
90     if (log_level_set)
91         return;
92     log_level_sort = yaz_log_module_level("sorting");
93     log_level_searchhits = yaz_log_module_level("searchhits");
94     log_level_searchterms = yaz_log_module_level("searchterms");
95     log_level_resultsets = yaz_log_module_level("resultsets");
96     log_level_set = 1;
97 }
98
99 ZEBRA_RES resultSetSearch(ZebraHandle zh, NMEM nmem, NMEM rset_nmem,
100                           Z_RPNQuery *rpn, ZebraSet sset)
101 {
102     RSET rset = 0;
103     oident *attrset;
104     Z_SortKeySpecList *sort_sequence;
105     int sort_status, i;
106     ZEBRA_RES res = ZEBRA_OK;
107
108     zh->hits = 0;
109
110     sort_sequence = (Z_SortKeySpecList *)
111         nmem_malloc(nmem, sizeof(*sort_sequence));
112     sort_sequence->num_specs = 10; /* FIXME - Hard-coded number */
113     sort_sequence->specs = (Z_SortKeySpec **)
114         nmem_malloc(nmem, sort_sequence->num_specs *
115                      sizeof(*sort_sequence->specs));
116     for (i = 0; i<sort_sequence->num_specs; i++)
117         sort_sequence->specs[i] = 0;
118     
119     attrset = oid_getentbyoid (rpn->attributeSetId);
120     res = rpn_search_top(zh, rpn->RPNStructure, attrset->value,
121                          nmem, rset_nmem,
122                          sort_sequence,
123                          sset->num_bases, sset->basenames,
124                          &rset);
125     if (res != ZEBRA_OK)
126     {
127         sset->rset = 0;
128         return res;
129     }
130     for (i = 0; sort_sequence->specs[i]; i++)
131         ;
132     sort_sequence->num_specs = i;
133     rset->hits_limit = sset->approx_limit;
134     if (!i)
135     {
136         res = resultSetRank (zh, sset, rset, rset_nmem);
137     }
138     else
139     {
140         res = resultSetSortSingle (zh, nmem, sset, rset,
141                                    sort_sequence, &sort_status);
142     }
143     sset->rset = rset;
144     return res;
145 }
146
147
148 ZEBRA_RES resultSetAddRPN (ZebraHandle zh, NMEM m, Z_RPNQuery *rpn,
149                            int num_bases, char **basenames,
150                            const char *setname)
151 {
152     ZebraSet zebraSet;
153     int i;
154     ZEBRA_RES res;
155
156     zh->hits = 0;
157
158     zebraSet = resultSetAdd(zh, setname, 1);
159     if (!zebraSet)
160         return ZEBRA_FAIL;
161     zebraSet->locked = 1;
162     zebraSet->rpn = 0;
163     zebraSet->nmem = m;
164     zebraSet->rset_nmem = nmem_create(); 
165
166     zebraSet->num_bases = num_bases;
167     zebraSet->basenames = 
168         nmem_malloc (zebraSet->nmem, num_bases * sizeof(*zebraSet->basenames));
169     for (i = 0; i<num_bases; i++)
170         zebraSet->basenames[i] = nmem_strdup(zebraSet->nmem, basenames[i]);
171
172     res = resultSetSearch(zh, zebraSet->nmem, zebraSet->rset_nmem,
173                           rpn, zebraSet);
174     zh->hits = zebraSet->hits;
175     if (zebraSet->rset)
176         zebraSet->rpn = rpn;
177     zebraSet->locked = 0;
178     if (!zebraSet->rset)
179         return ZEBRA_FAIL;
180     return res;
181 }
182
183 void resultSetAddTerm (ZebraHandle zh, ZebraSet s, int reg_type,
184                        const char *db, int set,
185                        int use, const char *term)
186 {
187     assert(zh); /* compiler shut up */
188     if (!s->nmem)
189         s->nmem = nmem_create ();
190     if (!s->term_entries)
191     {
192         int i;
193         s->term_entries_max = 1000;
194         s->term_entries =
195             nmem_malloc (s->nmem, s->term_entries_max * 
196                          sizeof(*s->term_entries));
197         for (i = 0; i < s->term_entries_max; i++)
198             s->term_entries[i].term = 0;
199     }
200     if (s->hits < s->term_entries_max)
201     {
202         s->term_entries[s->hits].reg_type = reg_type;
203         s->term_entries[s->hits].db = nmem_strdup (s->nmem, db);
204         s->term_entries[s->hits].set = set;
205         s->term_entries[s->hits].use = use;
206         s->term_entries[s->hits].term = nmem_strdup (s->nmem, term);
207     }
208     (s->hits)++;
209 }
210
211 ZebraSet resultSetAdd(ZebraHandle zh, const char *name, int ov)
212 {
213     ZebraSet s;
214     int i;
215
216     for (s = zh->sets; s; s = s->next)
217         if (!strcmp (s->name, name))
218             break;
219     
220     if (!log_level_set)
221         loglevels();
222     if (s)
223     {
224         yaz_log(log_level_resultsets, "updating result set %s", name);
225         if (!ov || s->locked)
226             return NULL;
227         if (s->rset)
228         {
229             if (s->cache_rfd)
230                 rset_close(s->cache_rfd);
231             rset_delete (s->rset);
232         }
233         if (s->rset_nmem)
234             nmem_destroy (s->rset_nmem);
235         if (s->nmem)
236             nmem_destroy (s->nmem);
237     }
238     else
239     {
240         const char *sort_max_str = zebra_get_resource(zh, "sortmax", "1000");
241
242         yaz_log(log_level_resultsets, "adding result set %s", name);
243         s = (ZebraSet) xmalloc (sizeof(*s));
244         s->next = zh->sets;
245         zh->sets = s;
246         s->name = (char *) xmalloc (strlen(name)+1);
247         strcpy (s->name, name);
248
249         s->sort_info = (struct zset_sort_info *)
250             xmalloc (sizeof(*s->sort_info));
251         s->sort_info->max_entries = atoi(sort_max_str);
252         if (s->sort_info->max_entries < 2)
253             s->sort_info->max_entries = 2;
254
255         s->sort_info->entries = (struct zset_sort_entry **)
256             xmalloc (sizeof(*s->sort_info->entries) *
257                      s->sort_info->max_entries);
258         s->sort_info->all_entries = (struct zset_sort_entry *)
259             xmalloc (sizeof(*s->sort_info->all_entries) *
260                      s->sort_info->max_entries);
261         for (i = 0; i < s->sort_info->max_entries; i++)
262             s->sort_info->entries[i] = s->sort_info->all_entries + i;
263     }
264     s->locked = 0;
265     s->term_entries = 0;
266     s->hits = 0;
267     s->rset = 0;
268     s->rset_nmem = 0;
269     s->nmem = 0;
270     s->rpn = 0;
271     s->sortSpec = 0;
272     s->cache_position = 0;
273     s->cache_rfd = 0;
274     s->approx_limit = zh->approx_limit;
275     return s;
276 }
277
278 ZebraSet resultSetGet(ZebraHandle zh, const char *name)
279 {
280     ZebraSet s;
281
282     for (s = zh->sets; s; s = s->next)
283         if (!strcmp (s->name, name))
284         {
285             if (!s->term_entries && !s->rset && s->rpn)
286             {
287                 NMEM nmem = nmem_create ();
288                 yaz_log(log_level_resultsets, "research %s", name);
289                 if (!s->rset_nmem)
290                     s->rset_nmem=nmem_create();
291                 resultSetSearch(zh, nmem, s->rset_nmem, s->rpn, s);
292                 if (s->rset && s->sortSpec)
293                 {
294                     int sort_status;
295                     yaz_log(log_level_resultsets, "resort %s", name);
296                     resultSetSortSingle (zh, nmem, s, s->rset, s->sortSpec,
297                                          &sort_status);
298                 }
299                 nmem_destroy (nmem);
300             }
301             return s;
302         }
303     return NULL;
304 }
305
306 void resultSetInvalidate (ZebraHandle zh)
307 {
308     ZebraSet s = zh->sets;
309     
310     yaz_log(log_level_resultsets, "invalidating result sets");
311     for (; s; s = s->next)
312     {
313         if (s->rset)
314         {
315             if (s->cache_rfd)
316                 rset_close(s->cache_rfd);
317             rset_delete (s->rset);
318         }
319         s->rset = 0;
320         s->cache_rfd = 0;
321         s->cache_position = 0;
322         if (s->rset_nmem)
323             nmem_destroy(s->rset_nmem);
324         s->rset_nmem=0;
325     }
326 }
327
328 void resultSetDestroy(ZebraHandle zh, int num, char **names,int *statuses)
329 {
330     ZebraSet * ss = &zh->sets;
331     int i;
332     
333     if (statuses)
334         for (i = 0; i<num; i++)
335             statuses[i] = Z_DeleteStatus_resultSetDidNotExist;
336     while (*ss)
337     {
338         int i = -1;
339         ZebraSet s = *ss;
340         if (num >= 0)
341         {
342             for (i = 0; i<num; i++)
343                 if (!strcmp (s->name, names[i]))
344                 {
345                     if (statuses)
346                         statuses[i] = Z_DeleteStatus_success;
347                     i = -1;
348                     break;
349                 }
350         }
351         if (i < 0)
352         {
353             *ss = s->next;
354             
355             xfree (s->sort_info->all_entries);
356             xfree (s->sort_info->entries);
357             xfree (s->sort_info);
358             
359             if (s->nmem)
360                 nmem_destroy (s->nmem);
361             if (s->rset)
362             {
363                 if (s->cache_rfd)
364                     rset_close(s->cache_rfd);
365                 rset_delete (s->rset);
366             }
367             if (s->rset_nmem)
368                 nmem_destroy(s->rset_nmem);
369             xfree (s->name);
370             xfree (s);
371         }
372         else
373             ss = &s->next;
374     }
375 }
376
377 ZebraMetaRecord *zebra_meta_records_create_range(ZebraHandle zh,
378                                                  const char *name, 
379                                                  zint start, int num)
380 {
381     zint pos_small[10];
382     zint *pos = pos_small;
383     ZebraMetaRecord *mr;
384     int i;
385
386     if (num > 10000 || num <= 0)
387         return 0;
388
389     if (num > 10)
390         pos = xmalloc(sizeof(*pos) * num);
391     
392     for (i = 0; i<num; i++)
393         pos[i] = start+i;
394
395     mr = zebra_meta_records_create(zh, name, num, pos);
396     
397     if (num > 10)
398         xfree(pos);
399     return mr;
400 }
401
402 ZebraMetaRecord *zebra_meta_records_create(ZebraHandle zh, const char *name, 
403                                            int num, zint *positions)
404 {
405     ZebraSet sset;
406     ZebraMetaRecord *sr = 0;
407     RSET rset;
408     int i;
409     struct zset_sort_info *sort_info;
410     size_t sysno_mem_index = 0;
411
412     if (zh->m_staticrank)
413         sysno_mem_index = 1;
414
415     if (!log_level_set)
416         loglevels();
417     if (!(sset = resultSetGet (zh, name)))
418         return NULL;
419     if (!(rset = sset->rset))
420     {
421         if (!sset->term_entries)
422             return 0;
423         sr = (ZebraMetaRecord *) xmalloc (sizeof(*sr) * num);
424         for (i = 0; i<num; i++)
425         {
426             sr[i].sysno = 0;
427             sr[i].score = -1;
428             sr[i].term = 0;
429             sr[i].db = 0;
430
431             if (positions[i] <= sset->term_entries_max)
432             {
433                 sr[i].term = sset->term_entries[positions[i]-1].term;
434                 sr[i].db = sset->term_entries[positions[i]-1].db;
435             }
436         }
437     }
438     else
439     {
440         sr = (ZebraMetaRecord *) xmalloc (sizeof(*sr) * num);
441         for (i = 0; i<num; i++)
442         {
443             sr[i].sysno = 0;
444             sr[i].score = -1;
445             sr[i].term = 0;
446             sr[i].db = 0;
447         }
448         sort_info = sset->sort_info;
449         if (sort_info)
450         {
451             zint position;
452             
453             for (i = 0; i<num; i++)
454             {
455                 position = positions[i];
456                 if (position > 0 && position <= sort_info->num_entries)
457                 {
458                     yaz_log(log_level_sort, "got pos=" ZINT_FORMAT
459                             " (sorted)", position);
460                     sr[i].sysno = sort_info->entries[position-1]->sysno;
461                     sr[i].score = sort_info->entries[position-1]->score;
462                 }
463             }
464         }
465         /* did we really get all entries using sort ? */
466         for (i = 0; i<num; i++)
467         {
468             if (!sr[i].sysno)
469                 break;
470         }
471         if (i < num) /* nope, get the rest, unsorted - sorry */
472         {
473             zint position = 0;
474             int num_i = 0;
475             zint psysno = 0;
476             RSFD rfd;
477             struct it_key key;
478             
479             if (sort_info)
480                 position = sort_info->num_entries;
481             while (num_i < num && positions[num_i] <= position)
482                 num_i++;
483             
484             if (sset->cache_rfd &&
485                 num_i < num && positions[num_i] > sset->cache_position)
486             {
487                 position = sset->cache_position;
488                 rfd = sset->cache_rfd;
489                 psysno = sset->cache_psysno;
490             }
491             else
492             {
493                 if (sset->cache_rfd)
494                     rset_close(sset->cache_rfd);
495                 rfd = rset_open (rset, RSETF_READ);
496             }
497             while (num_i < num && rset_read (rfd, &key, 0))
498             {
499                 zint this_sys = key.mem[sysno_mem_index];
500                 if (this_sys != psysno)
501                 {
502                     psysno = this_sys;
503                     if (sort_info)
504                     {
505                         /* determine we alreay have this in our set */
506                         for (i = sort_info->num_entries; --i >= 0; )
507                             if (psysno == sort_info->entries[i]->sysno)
508                                 break;
509                         if (i >= 0)
510                             continue;
511                     }
512                     position++;
513                     assert (num_i < num);
514                     if (position == positions[num_i])
515                     {
516                         sr[num_i].sysno = psysno;
517                         yaz_log(log_level_sort, "got pos=" ZINT_FORMAT " (unsorted)", position);
518                         sr[num_i].score = -1;
519                         num_i++;
520                     }
521                 }
522             }
523             sset->cache_position = position;
524             sset->cache_psysno = psysno;
525             sset->cache_rfd = rfd;
526         }
527     }
528     return sr;
529 }
530
531 void zebra_meta_records_destroy (ZebraHandle zh, ZebraMetaRecord *records,
532                                  int num)
533 {
534     assert(zh); /* compiler shut up about unused arg */
535     xfree (records);
536 }
537
538 struct sortKeyInfo {
539     int relation;
540     int attrUse;
541     int numerical;
542 };
543
544 void resultSetInsertSort (ZebraHandle zh, ZebraSet sset,
545                           struct sortKeyInfo *criteria, int num_criteria,
546                           zint sysno)
547 {
548     struct zset_sort_entry this_entry;
549     struct zset_sort_entry *new_entry = NULL;
550     struct zset_sort_info *sort_info = sset->sort_info;
551     int i, j;
552
553     sortIdx_sysno (zh->reg->sortIdx, sysno);
554     for (i = 0; i<num_criteria; i++)
555     {
556         sortIdx_type (zh->reg->sortIdx, criteria[i].attrUse);
557         sortIdx_read (zh->reg->sortIdx, this_entry.buf[i]);
558     }
559     i = sort_info->num_entries;
560     while (--i >= 0)
561     {
562         int rel = 0;
563         for (j = 0; j<num_criteria; j++)
564         {
565             if (criteria[j].numerical)
566             {
567                 double diff = atof(this_entry.buf[j]) -
568                               atof(sort_info->entries[i]->buf[j]);
569                 rel = 0;
570                 if (diff > 0.0)
571                     rel = 1;
572                 else if (diff < 0.0)
573                     rel = -1;
574             }
575             else
576             {
577                 rel = memcmp (this_entry.buf[j], sort_info->entries[i]->buf[j],
578                           SORT_IDX_ENTRYSIZE);
579             }
580             if (rel)
581                 break;
582         }       
583         if (!rel)
584             break;
585         if (criteria[j].relation == 'A')
586         {
587             if (rel > 0)
588                 break;
589         }
590         else if (criteria[j].relation == 'D')
591         {
592             if (rel < 0)
593                 break;
594         }
595     }
596     ++i;
597     j = sort_info->max_entries;
598     if (i == j)
599         return;
600
601     if (sort_info->num_entries == j)
602         --j;
603     else
604         j = (sort_info->num_entries)++;
605     new_entry = sort_info->entries[j];
606     while (j != i)
607     {
608         sort_info->entries[j] = sort_info->entries[j-1];
609         --j;
610     }
611     sort_info->entries[i] = new_entry;
612     assert (new_entry);
613     for (i = 0; i<num_criteria; i++)
614         memcpy (new_entry->buf[i], this_entry.buf[i], SORT_IDX_ENTRYSIZE);
615     new_entry->sysno = sysno;
616     new_entry->score = -1;
617 }
618
619 void resultSetInsertRank (ZebraHandle zh, struct zset_sort_info *sort_info,
620                           zint sysno, int score, int relation)
621 {
622     struct zset_sort_entry *new_entry = NULL;
623     int i, j;
624     assert(zh); /* compiler shut up about unused arg */
625
626     i = sort_info->num_entries;
627     while (--i >= 0)
628     {
629         int rel = 0;
630
631         rel = score - sort_info->entries[i]->score;
632
633         if (relation == 'D')
634         {
635             if (rel >= 0)
636                 break;
637         }
638         else if (relation == 'A')
639         {
640             if (rel <= 0)
641                 break;
642         }
643     }
644     ++i;
645     j = sort_info->max_entries;
646     if (i == j)
647         return;
648
649     if (sort_info->num_entries == j)
650         --j;
651     else
652         j = (sort_info->num_entries)++;
653     
654     new_entry = sort_info->entries[j];
655     while (j != i)
656     {
657         sort_info->entries[j] = sort_info->entries[j-1];
658         --j;
659     }
660     sort_info->entries[i] = new_entry;
661     assert (new_entry);
662     new_entry->sysno = sysno;
663     new_entry->score = score;
664 }
665
666 static Z_RPNQuery *copy_RPNQuery(Z_RPNQuery *src, NMEM nmem)
667 {
668     Z_RPNQuery *dst = 0;
669     ODR encode = odr_createmem(ODR_ENCODE);
670     ODR decode = odr_createmem(ODR_DECODE);
671
672     if (z_RPNQuery(encode, &src, 0, 0))
673     {
674         int len;
675         char *buf = odr_getbuf(encode, &len, 0);
676
677         if (buf)
678         {
679             odr_setbuf(decode, buf, len, 0);
680             z_RPNQuery(decode, &dst, 0, 0);
681         }
682     }
683     nmem_transfer(nmem, decode->mem);
684     odr_destroy(encode);
685     odr_destroy(decode);
686     return dst;
687 }
688
689 static Z_SortKeySpecList *copy_SortKeySpecList(Z_SortKeySpecList *src, NMEM nmem)
690 {
691     Z_SortKeySpecList *dst = 0;
692     ODR encode = odr_createmem(ODR_ENCODE);
693     ODR decode = odr_createmem(ODR_DECODE);
694
695     if (z_SortKeySpecList(encode, &src, 0, 0))
696     {
697         int len;
698         char *buf = odr_getbuf(encode, &len, 0);
699
700         if (buf)
701         {
702             odr_setbuf(decode, buf, len, 0);
703             z_SortKeySpecList(decode, &dst, 0, 0);
704         }
705     }
706     nmem_transfer(nmem, decode->mem);
707     odr_destroy(encode);
708     odr_destroy(decode);
709     return dst;
710 }
711
712 ZebraSet resultSetClone(ZebraHandle zh, const char *setname,
713                         ZebraSet rset)
714 {
715     ZebraSet nset;
716     int i;
717
718     nset = resultSetAdd(zh, setname, 1);
719     if (!nset)
720         return 0;
721
722     nset->nmem = nmem_create();
723
724     nset->num_bases = rset->num_bases;
725     nset->basenames = 
726         nmem_malloc (nset->nmem, nset->num_bases * sizeof(*rset->basenames));
727     for (i = 0; i<rset->num_bases; i++)
728         nset->basenames[i] = nmem_strdup(nset->nmem, rset->basenames[i]);
729
730     if (rset->rset)
731         nset->rset = rset_dup(rset->rset);
732     if (rset->rpn)
733         nset->rpn = copy_RPNQuery(rset->rpn, nset->nmem);
734     return nset;
735 }
736
737 ZEBRA_RES resultSetSort(ZebraHandle zh, NMEM nmem,
738                         int num_input_setnames, const char **input_setnames,
739                         const char *output_setname,
740                         Z_SortKeySpecList *sort_sequence, int *sort_status)
741 {
742     ZebraSet sset;
743     RSET rset;
744
745     if (num_input_setnames == 0)
746     {
747         zebra_setError(zh, YAZ_BIB1_NO_RESULT_SET_NAME_SUPPLIED_ON_SORT, 0);
748         return ZEBRA_FAIL;
749     }
750     if (num_input_setnames > 1)
751     {
752         zebra_setError(zh, YAZ_BIB1_SORT_TOO_MANY_INPUT_RESULTS, 0);
753         return ZEBRA_FAIL;
754     }
755     if (!log_level_set)
756         loglevels();
757     yaz_log(log_level_sort, "result set sort input=%s output=%s",
758           *input_setnames, output_setname);
759     sset = resultSetGet (zh, input_setnames[0]);
760     if (!sset)
761     {
762         zebra_setError(zh, YAZ_BIB1_SPECIFIED_RESULT_SET_DOES_NOT_EXIST,
763                        input_setnames[0]);
764         return ZEBRA_FAIL;
765     }
766     if (!(rset = sset->rset))
767     {
768         zebra_setError(zh, YAZ_BIB1_SPECIFIED_RESULT_SET_DOES_NOT_EXIST,
769                        input_setnames[0]);
770         return ZEBRA_FAIL;
771     }
772     if (strcmp (output_setname, input_setnames[0]))
773         sset = resultSetClone(zh, output_setname, sset);
774     sset->sortSpec = copy_SortKeySpecList(sort_sequence, sset->nmem);
775     return resultSetSortSingle (zh, nmem, sset, rset, sort_sequence,
776                                 sort_status);
777 }
778
779 ZEBRA_RES resultSetSortSingle(ZebraHandle zh, NMEM nmem,
780                               ZebraSet sset, RSET rset,
781                               Z_SortKeySpecList *sort_sequence,
782                               int *sort_status)
783 {
784     int i;
785     int n = 0;
786     zint kno = 0;
787     zint psysno = 0;
788     struct it_key key;
789     struct sortKeyInfo sort_criteria[3];
790     int num_criteria;
791     RSFD rfd;
792     TERMID termid;
793     TERMID *terms;
794     int numTerms = 0;
795     size_t sysno_mem_index = 0;
796
797     if (zh->m_staticrank)
798         sysno_mem_index = 1;
799
800
801     assert(nmem); /* compiler shut up about unused param */
802     sset->sort_info->num_entries = 0;
803
804     rset_getterms(rset, 0, 0, &n);
805     terms = (TERMID *) nmem_malloc(nmem, sizeof(*terms)*n);
806     rset_getterms(rset, terms, n, &numTerms);
807
808     sset->hits = 0;
809     num_criteria = sort_sequence->num_specs;
810     if (num_criteria > 3)
811         num_criteria = 3;
812     for (i = 0; i < num_criteria; i++)
813     {
814         Z_SortKeySpec *sks = sort_sequence->specs[i];
815         Z_SortKey *sk;
816
817         if (*sks->sortRelation == Z_SortKeySpec_ascending)
818             sort_criteria[i].relation = 'A';
819         else if (*sks->sortRelation == Z_SortKeySpec_descending)
820             sort_criteria[i].relation = 'D';
821         else
822         {
823             zebra_setError(zh, YAZ_BIB1_ILLEGAL_SORT_RELATION, 0);
824             return ZEBRA_FAIL;
825         }
826         if (sks->sortElement->which == Z_SortElement_databaseSpecific)
827         {
828             zebra_setError(zh, YAZ_BIB1_DATABASE_SPECIFIC_SORT_UNSUPP, 0);
829             return ZEBRA_FAIL;
830         }
831         else if (sks->sortElement->which != Z_SortElement_generic)
832         {
833             zebra_setError(zh, YAZ_BIB1_SORT_ILLEGAL_SORT, 0);
834             return ZEBRA_FAIL;
835         }       
836         sk = sks->sortElement->u.generic;
837         switch (sk->which)
838         {
839         case Z_SortKey_sortField:
840             yaz_log(log_level_sort, "key %d is of type sortField",
841                     i+1);
842             zebra_setError(zh, YAZ_BIB1_CANNOT_SORT_ACCORDING_TO_SEQUENCE, 0);
843             return ZEBRA_FAIL;
844         case Z_SortKey_elementSpec:
845             yaz_log(log_level_sort, "key %d is of type elementSpec",
846                     i+1);
847             zebra_setError(zh, YAZ_BIB1_CANNOT_SORT_ACCORDING_TO_SEQUENCE, 0);
848             return ZEBRA_FAIL;
849         case Z_SortKey_sortAttributes:
850             yaz_log(log_level_sort, "key %d is of type sortAttributes", i+1);
851             sort_criteria[i].attrUse =
852                 zebra_maps_sort (zh->reg->zebra_maps,
853                                  sk->u.sortAttributes,
854                                  &sort_criteria[i].numerical);
855             yaz_log(log_level_sort, "use value = %d", sort_criteria[i].attrUse);
856             if (sort_criteria[i].attrUse == -1)
857             {
858                 zebra_setError(
859                     zh, YAZ_BIB1_USE_ATTRIBUTE_REQUIRED_BUT_NOT_SUPPLIED, 0); 
860                 return ZEBRA_FAIL;
861             }
862             if (sortIdx_type (zh->reg->sortIdx, sort_criteria[i].attrUse))
863             {
864                 zebra_setError(
865                     zh, YAZ_BIB1_CANNOT_SORT_ACCORDING_TO_SEQUENCE, 0);
866                 return ZEBRA_FAIL;
867             }
868             break;
869         }
870     }
871     rfd = rset_open (rset, RSETF_READ);
872     while (rset_read (rfd, &key, &termid))
873     {
874         zint this_sys = key.mem[sysno_mem_index];
875         if (log_level_searchhits)
876             key_logdump_txt(log_level_searchhits, &key, termid->name);
877         kno++;
878         if (this_sys != psysno)
879         {
880             (sset->hits)++;
881             psysno = this_sys;
882             resultSetInsertSort (zh, sset,
883                                  sort_criteria, num_criteria, psysno);
884         }
885     }
886     rset_close (rfd);
887     yaz_log(log_level_sort, ZINT_FORMAT " keys, " ZINT_FORMAT " sysnos, sort",
888             kno, sset->hits);   
889     for (i = 0; i < numTerms; i++)
890         yaz_log(log_level_sort, "term=\"%s\" type=%s count=" ZINT_FORMAT,
891                  terms[i]->name, terms[i]->flags, terms[i]->rset->hits_count);
892     *sort_status = Z_SortResponse_success;
893     return ZEBRA_OK;
894 }
895
896 RSET resultSetRef(ZebraHandle zh, const char *resultSetId)
897 {
898     ZebraSet s;
899
900     if ((s = resultSetGet (zh, resultSetId)))
901         return s->rset;
902     return NULL;
903 }
904
905 ZEBRA_RES resultSetRank(ZebraHandle zh, ZebraSet zebraSet,
906                         RSET rset, NMEM nmem)
907 {
908     struct it_key key;
909     TERMID termid;
910     TERMID *terms;
911     zint kno = 0;
912     int numTerms = 0;
913     int n = 0;
914     int i;
915     ZebraRankClass rank_class;
916     struct zset_sort_info *sort_info;
917     const char *rank_handler_name = res_get_def(zh->res, "rank", "rank-1");
918     size_t sysno_mem_index = 0;
919
920     if (zh->m_staticrank)
921         sysno_mem_index = 1;
922
923     if (!log_level_set)
924         loglevels();
925     sort_info = zebraSet->sort_info;
926     sort_info->num_entries = 0;
927     zebraSet->hits = 0;
928     rset_getterms(rset, 0, 0, &n);
929     terms = (TERMID *) nmem_malloc(nmem, sizeof(*terms)*n);
930     rset_getterms(rset, terms, n, &numTerms);
931
932
933     rank_class = zebraRankLookup(zh, rank_handler_name);
934     if (!rank_class)
935     {
936         yaz_log(YLOG_WARN, "No such rank handler: %s", rank_handler_name);
937         zebra_setError(zh, YAZ_BIB1_UNSUPP_SEARCH, "Cannot find rank handler");
938         return ZEBRA_FAIL;
939     }
940     else
941     {
942         RSFD rfd = rset_open(rset, RSETF_READ);
943         struct rank_control *rc = rank_class->control;
944         double score;
945         zint count = 0;
946         
947         void *handle =
948             (*rc->begin) (zh->reg, rank_class->class_handle, rset, nmem,
949                           terms, numTerms);
950         zint psysno = 0;  /* previous doc id / sys no */
951         zint pstaticrank = 0; /* previous static rank */
952         int stop_flag = 0;
953         while (rset_read(rfd, &key, &termid))
954         {
955             zint this_sys = key.mem[sysno_mem_index];
956
957             zint seqno = key.mem[key.len-1];
958             kno++;
959             if (log_level_searchhits)
960                 key_logdump_txt(log_level_searchhits, &key, termid->name);
961             if (this_sys != psysno) 
962             {   /* new record .. */
963                 if (rfd->counted_items > rset->hits_limit)
964                     break;
965                 if (psysno)
966                 {   /* only if we did have a previous record */
967                     score = (*rc->calc) (handle, psysno, pstaticrank,
968                                          &stop_flag);
969                     /* insert the hit. A=Ascending */
970                     resultSetInsertRank (zh, sort_info, psysno, score, 'A');
971                     count++;
972                     if (stop_flag)
973                         break;
974                 }
975                 psysno = this_sys;
976                 if (zh->m_staticrank)
977                     pstaticrank = key.mem[0];
978             }
979             (*rc->add) (handle, CAST_ZINT_TO_INT(seqno), termid);
980         }
981         /* no more items */
982         if (psysno)
983         {   /* we had - at least - one record */
984             score = (*rc->calc)(handle, psysno, pstaticrank, &stop_flag);
985             /* insert the hit. A=Ascending */
986             resultSetInsertRank(zh, sort_info, psysno, score, 'A');
987             count++;
988         }
989         (*rc->end) (zh->reg, handle);
990         rset_close (rfd);
991     }
992     zebraSet->hits = rset->hits_count;
993
994     yaz_log(log_level_searchterms, ZINT_FORMAT " keys, "
995             ZINT_FORMAT " sysnos, rank",  kno, zebraSet->hits);
996     for (i = 0; i < numTerms; i++)
997     {
998         yaz_log(log_level_searchterms, "term=\"%s\" type=%s count="
999                 ZINT_FORMAT,
1000                 terms[i]->name, terms[i]->flags, terms[i]->rset->hits_count);
1001     }
1002     return ZEBRA_OK;
1003 }
1004
1005 ZebraRankClass zebraRankLookup(ZebraHandle zh, const char *name)
1006 {
1007     ZebraRankClass p = zh->reg->rank_classes;
1008     while (p && strcmp (p->control->name, name))
1009         p = p->next;
1010     if (p && !p->init_flag)
1011     {
1012         if (p->control->create)
1013             p->class_handle = (*p->control->create)(zh);
1014         p->init_flag = 1;
1015     }
1016     return p;
1017 }
1018
1019 void zebraRankInstall(struct zebra_register *reg, struct rank_control *ctrl)
1020 {
1021     ZebraRankClass p = (ZebraRankClass) xmalloc (sizeof(*p));
1022     p->control = (struct rank_control *) xmalloc (sizeof(*p->control));
1023     memcpy (p->control, ctrl, sizeof(*p->control));
1024     p->control->name = xstrdup (ctrl->name);
1025     p->init_flag = 0;
1026     p->next = reg->rank_classes;
1027     reg->rank_classes = p;
1028 }
1029
1030 void zebraRankDestroy(struct zebra_register *reg)
1031 {
1032     ZebraRankClass p = reg->rank_classes;
1033     while (p)
1034     {
1035         ZebraRankClass p_next = p->next;
1036         if (p->init_flag && p->control->destroy)
1037             (*p->control->destroy)(reg, p->class_handle);
1038         xfree(p->control->name);
1039         xfree(p->control);
1040         xfree(p);
1041         p = p_next;
1042     }
1043     reg->rank_classes = NULL;
1044 }
1045
1046 static int trav_rset_for_termids(RSET rset, TERMID *termid_array,
1047                                  zint *hits_array, int *approx_array)
1048 {
1049     int no = 0;
1050     int i;
1051     for (i = 0; i<rset->no_children; i++)
1052         no += trav_rset_for_termids(rset->children[i],
1053                                     (termid_array ? termid_array + no : 0),
1054                                     (hits_array ? hits_array + no : 0),
1055                                     (approx_array ? approx_array + no : 0));
1056     if (rset->term)
1057     {
1058         if (termid_array)
1059             termid_array[no] = rset->term;
1060         if (hits_array)
1061             hits_array[no] = rset->hits_count;
1062         if (approx_array)
1063             approx_array[no] = rset->hits_approx;
1064 #if 0
1065         yaz_log(YLOG_LOG, "rset=%p term=%s limit=" ZINT_FORMAT
1066                 " count=" ZINT_FORMAT,
1067                 rset, rset->term->name, rset->hits_limit, rset->hits_count);
1068 #endif
1069         no++;
1070     }
1071     return no;
1072 }
1073
1074 ZEBRA_RES zebra_result_set_term_no(ZebraHandle zh, const char *setname,
1075                                    int *num_terms)
1076 {
1077     ZebraSet sset = resultSetGet(zh, setname);
1078     *num_terms = 0;
1079     if (sset)
1080     {
1081         *num_terms = trav_rset_for_termids(sset->rset, 0, 0, 0);
1082         return ZEBRA_OK;
1083     }
1084     return ZEBRA_FAIL;
1085 }
1086
1087 ZEBRA_RES zebra_result_set_term_info(ZebraHandle zh, const char *setname,
1088                                      int no, zint *count, int *approx,
1089                                      char *termbuf, size_t *termlen,
1090                                      const char **term_ref_id)
1091 {
1092     ZebraSet sset = resultSetGet(zh, setname);
1093     if (sset)
1094     {
1095         int num_terms = trav_rset_for_termids(sset->rset, 0, 0, 0);
1096         if (no >= 0 && no < num_terms)
1097         {
1098             TERMID *term_array = xmalloc(num_terms * sizeof(*term_array));
1099             zint *hits_array = xmalloc(num_terms * sizeof(*hits_array));
1100             int *approx_array = xmalloc(num_terms * sizeof(*approx_array));
1101             
1102             trav_rset_for_termids(sset->rset, term_array,
1103                                   hits_array, approx_array);
1104
1105             if (count)
1106                 *count = hits_array[no];
1107             if (approx)
1108                 *approx = approx_array[no];
1109             if (termbuf)
1110             {
1111                 char *inbuf = term_array[no]->name;
1112                 size_t inleft = strlen(inbuf);
1113                 size_t outleft = *termlen - 1;
1114
1115                 if (zh->iconv_from_utf8 != 0)
1116                 {
1117                     char *outbuf = termbuf;
1118                     size_t ret;
1119                     
1120                     ret = yaz_iconv(zh->iconv_from_utf8, &inbuf, &inleft,
1121                                     &outbuf, &outleft);
1122                     if (ret == (size_t)(-1))
1123                         *termlen = 0;
1124                     else
1125                         *termlen = outbuf - termbuf;
1126                 }
1127                 else
1128                 {
1129                     if (inleft > outleft)
1130                         inleft = outleft;
1131                     *termlen = inleft;
1132                     memcpy(termbuf, inbuf, *termlen);
1133                 }
1134                 termbuf[*termlen] = '\0';
1135             }
1136             if (term_ref_id)
1137                 *term_ref_id = term_array[no]->ref_id;
1138
1139             xfree(term_array);
1140             xfree(hits_array);
1141             xfree(approx_array);
1142             return ZEBRA_OK;
1143         }
1144     }
1145     return ZEBRA_FAIL;
1146 }
1147
1148 ZEBRA_RES zebra_snippets_hit_vector(ZebraHandle zh, const char *setname,
1149                                     zint sysno, zebra_snippets *snippets)
1150 {
1151     ZebraSet sset = resultSetGet(zh, setname);
1152     yaz_log(YLOG_DEBUG, "zebra_get_hit_vector setname=%s zysno=" ZINT_FORMAT,
1153             setname, sysno);
1154     if (!sset)
1155         return ZEBRA_FAIL;
1156     else
1157     {
1158         struct rset_key_control *kc = zebra_key_control_create(zh);
1159         NMEM nmem = nmem_create();
1160         struct it_key key;
1161         RSET rsets[2], rset_comb;
1162         RSET rset_temp = rstemp_create(nmem, kc, kc->scope, 
1163                                        res_get (zh->res, "setTmpDir"),0 );
1164         
1165         TERMID termid;
1166         RSFD rsfd = rset_open(rset_temp, RSETF_WRITE);
1167         
1168         key.mem[0] = sysno;
1169         key.mem[1] = 0;
1170         key.mem[2] = 0;
1171         key.mem[3] = 0;
1172         key.len = 2;
1173         rset_write (rsfd, &key);
1174         rset_close (rsfd);
1175
1176         rsets[0] = rset_temp;
1177         rsets[1] = rset_dup(sset->rset);
1178         
1179         rset_comb = rsmulti_and_create(nmem, kc, kc->scope, 2, rsets);
1180
1181         rsfd = rset_open(rset_comb, RSETF_READ);
1182
1183         while (rset_read(rsfd, &key, &termid))
1184         {
1185             if (termid)
1186             {
1187                 struct ord_list *ol;
1188                 for (ol = termid->ol; ol; ol = ol->next)
1189                 {
1190                     zebra_snippets_append(snippets, key.mem[key.len-1],
1191                                           ol->ord, termid->name);
1192                 }
1193             }
1194         }
1195         rset_close(rsfd);
1196         
1197         rset_delete(rset_comb);
1198         nmem_destroy(nmem);
1199         kc->dec(kc);
1200     }
1201     return ZEBRA_OK;
1202 }
1203