Option -n works again
[idzebra-moved-to-github.git] / index / zsets.c
1 /*
2  * Copyright (C) 1994-2002, Index Data
3  * All rights reserved.
4  * Sebastian Hammer, Adam Dickmeiss
5  *
6  * $Id: zsets.c,v 1.34 2002-04-04 14:14:13 adam Exp $
7  */
8 #include <stdio.h>
9 #include <assert.h>
10 #ifdef WIN32
11 #include <io.h>
12 #else
13 #include <unistd.h>
14 #endif
15
16 #include "index.h"
17 #include <rstemp.h>
18
19 #define SORT_IDX_ENTRYSIZE 64
20 #define ZSET_SORT_MAX_LEVEL 3
21
22 struct zebra_set_term_entry {
23     int reg_type;
24     char *db;
25     int set;
26     int use;
27     char *term;
28 };
29 struct zebra_set {
30     char *name;
31     RSET rset;
32     NMEM nmem;
33     int hits;
34     int num_bases;
35     char **basenames;
36     Z_RPNQuery *rpn;
37     struct zset_sort_info *sort_info;
38     struct zebra_set_term_entry *term_entries;
39     int term_entries_max;
40     struct zebra_set *next;
41     int locked;
42 };
43
44 struct zset_sort_entry {
45     int sysno;
46     int score;
47     char buf[ZSET_SORT_MAX_LEVEL][SORT_IDX_ENTRYSIZE];
48 };
49
50 struct zset_sort_info {
51     int max_entries;
52     int num_entries;
53     struct zset_sort_entry *all_entries;
54     struct zset_sort_entry **entries;
55 };
56
57 ZebraSet resultSetAddRPN (ZebraHandle zh, ODR input, ODR output,
58                           Z_RPNQuery *rpn, int num_bases,
59                           char **basenames, 
60                           const char *setname)
61 {
62     ZebraSet zebraSet;
63     int i;
64
65     zh->errCode = 0;
66     zh->errString = NULL;
67     zh->hits = 0;
68
69     zebraSet = resultSetAdd (zh, setname, 1);
70     if (!zebraSet)
71         return 0;
72     zebraSet->locked = 1;
73     zebraSet->rpn = 0;
74     zebraSet->nmem = nmem_create ();
75
76     zebraSet->num_bases = num_bases;
77     zebraSet->basenames = 
78         nmem_malloc (zebraSet->nmem, num_bases * sizeof(*zebraSet->basenames));
79     for (i = 0; i<num_bases; i++)
80         zebraSet->basenames[i] = nmem_strdup (zebraSet->nmem, basenames[i]);
81
82
83     zebraSet->rset = rpn_search (zh, output->mem, rpn,
84                                  zebraSet->num_bases,
85                                  zebraSet->basenames, zebraSet->name,
86                                  zebraSet);
87     zh->hits = zebraSet->hits;
88     if (zebraSet->rset)
89         zebraSet->rpn = rpn;
90     zebraSet->locked = 0;
91     return zebraSet;
92 }
93
94 void resultSetAddTerm (ZebraHandle zh, ZebraSet s, int reg_type,
95                        const char *db, int set,
96                        int use, const char *term)
97 {
98     if (!s->nmem)
99         s->nmem = nmem_create ();
100     if (!s->term_entries)
101     {
102         int i;
103         s->term_entries_max = 1000;
104         s->term_entries =
105             nmem_malloc (s->nmem, s->term_entries_max * 
106                          sizeof(*s->term_entries));
107         for (i = 0; i < s->term_entries_max; i++)
108             s->term_entries[i].term = 0;
109     }
110     if (s->hits < s->term_entries_max)
111     {
112         s->term_entries[s->hits].reg_type = reg_type;
113         s->term_entries[s->hits].db = nmem_strdup (s->nmem, db);
114         s->term_entries[s->hits].set = set;
115         s->term_entries[s->hits].use = use;
116         s->term_entries[s->hits].term = nmem_strdup (s->nmem, term);
117     }
118     (s->hits)++;
119 }
120
121
122 const char *zebra_resultSetTerms (ZebraHandle zh, const char *setname, 
123                                   int no, int *count, int *no_max)
124 {
125     ZebraSet s = resultSetGet (zh, setname);
126
127     *count = 0;
128     *no_max = 0;
129     if (!s || !s->rset)
130         return 0;
131     *no_max = s->rset->no_rset_terms;
132     if (no < 0 || no >= *no_max)
133         return 0;
134     *count = s->rset->rset_terms[no]->count;
135     return s->rset->rset_terms[no]->name;
136 }
137
138
139 ZebraSet resultSetAdd (ZebraHandle zh, const char *name, int ov)
140 {
141     ZebraSet s;
142     int i;
143
144     for (s = zh->sets; s; s = s->next)
145         if (!strcmp (s->name, name))
146             break;
147     if (s)
148     {
149         logf (LOG_DEBUG, "updating result set %s", name);
150         if (!ov || s->locked)
151             return NULL;
152         if (s->rset)
153             rset_delete (s->rset);
154         if (s->nmem)
155             nmem_destroy (s->nmem);
156     }
157     else
158     {
159         logf (LOG_DEBUG, "adding result set %s", name);
160         s = (ZebraSet) xmalloc (sizeof(*s));
161         s->next = zh->sets;
162         zh->sets = s;
163         s->name = (char *) xmalloc (strlen(name)+1);
164         strcpy (s->name, name);
165
166         s->sort_info = (struct zset_sort_info *)
167             xmalloc (sizeof(*s->sort_info));
168         s->sort_info->max_entries = 1000;
169         s->sort_info->entries = (struct zset_sort_entry **)
170             xmalloc (sizeof(*s->sort_info->entries) *
171                      s->sort_info->max_entries);
172         s->sort_info->all_entries = (struct zset_sort_entry *)
173             xmalloc (sizeof(*s->sort_info->all_entries) *
174                      s->sort_info->max_entries);
175         for (i = 0; i < s->sort_info->max_entries; i++)
176             s->sort_info->entries[i] = s->sort_info->all_entries + i;
177     }
178     s->locked = 0;
179     s->term_entries = 0;
180     s->hits = 0;
181     s->rset = 0;
182     s->nmem = 0;
183     s->rpn = 0;
184     return s;
185 }
186
187 ZebraSet resultSetGet (ZebraHandle zh, const char *name)
188 {
189     ZebraSet s;
190
191     for (s = zh->sets; s; s = s->next)
192         if (!strcmp (s->name, name))
193         {
194             if (!s->term_entries && !s->rset && s->rpn)
195             {
196                 NMEM nmem = nmem_create ();
197                 yaz_log (LOG_LOG, "research %s", name);
198                 s->rset =
199                     rpn_search (zh, nmem, s->rpn, s->num_bases,
200                                 s->basenames, s->name, s);
201                 nmem_destroy (nmem);
202             }
203             return s;
204         }
205     return NULL;
206 }
207
208 void resultSetInvalidate (ZebraHandle zh)
209 {
210     ZebraSet s = zh->sets;
211     
212     for (; s; s = s->next)
213     {
214         if (s->rset)
215             rset_delete (s->rset);
216         s->rset = 0;
217     }
218 }
219
220 void resultSetDestroy (ZebraHandle zh, int num, char **names,int *statuses)
221 {
222     ZebraSet * ss = &zh->sets;
223     int i;
224     
225     if (statuses)
226         for (i = 0; i<num; i++)
227             statuses[i] = Z_DeleteStatus_resultSetDidNotExist;
228     zh->errCode = 0;
229     zh->errString = NULL;
230     while (*ss)
231     {
232         int i = -1;
233         ZebraSet s = *ss;
234         if (num >= 0)
235         {
236             for (i = 0; i<num; i++)
237                 if (!strcmp (s->name, names[i]))
238                 {
239                     if (statuses)
240                         statuses[i] = Z_DeleteStatus_success;
241                     i = -1;
242                     break;
243                 }
244         }
245         if (i < 0)
246         {
247             *ss = s->next;
248             
249             xfree (s->sort_info->all_entries);
250             xfree (s->sort_info->entries);
251             xfree (s->sort_info);
252             
253             if (s->nmem)
254                 nmem_destroy (s->nmem);
255             if (s->rset)
256                 rset_delete (s->rset);
257             xfree (s->name);
258             xfree (s);
259         }
260         else
261             ss = &s->next;
262     }
263 }
264
265 ZebraPosSet zebraPosSetCreate (ZebraHandle zh, const char *name, 
266                                int num, int *positions)
267 {
268     ZebraSet sset;
269     ZebraPosSet sr = 0;
270     RSET rset;
271     int i;
272     struct zset_sort_info *sort_info;
273
274     if (!(sset = resultSetGet (zh, name)))
275         return NULL;
276     if (!(rset = sset->rset))
277     {
278         if (!sset->term_entries)
279             return 0;
280         sr = (ZebraPosSet) xmalloc (sizeof(*sr) * num);
281         for (i = 0; i<num; i++)
282         {
283             sr[i].sysno = 0;
284             sr[i].score = -1;
285             sr[i].term = 0;
286             sr[i].db = 0;
287
288             if (positions[i] <= sset->term_entries_max)
289             {
290                 sr[i].term = sset->term_entries[positions[i]-1].term;
291                 sr[i].db = sset->term_entries[positions[i]-1].db;
292             }
293         }
294     }
295     else
296     {
297         sr = (ZebraPosSet) xmalloc (sizeof(*sr) * num);
298         for (i = 0; i<num; i++)
299         {
300             sr[i].sysno = 0;
301             sr[i].score = -1;
302             sr[i].term = 0;
303             sr[i].db = 0;
304         }
305         sort_info = sset->sort_info;
306         if (sort_info)
307         {
308             int position;
309             
310             for (i = 0; i<num; i++)
311             {
312                 position = positions[i];
313                 if (position > 0 && position <= sort_info->num_entries)
314                 {
315                     logf (LOG_DEBUG, "got pos=%d (sorted)", position);
316                     sr[i].sysno = sort_info->entries[position-1]->sysno;
317                     sr[i].score = sort_info->entries[position-1]->score;
318                 }
319             }
320         }
321         /* did we really get all entries using sort ? */
322         for (i = 0; i<num; i++)
323         {
324             if (!sr[i].sysno)
325                 break;
326         }
327         if (i < num) /* nope, get the rest, unsorted - sorry */
328         {
329             int position = 0;
330             int num_i = 0;
331             int psysno = 0;
332             int term_index;
333             RSFD rfd;
334             struct it_key key;
335             
336             if (sort_info)
337                 position = sort_info->num_entries;
338             while (num_i < num && positions[num_i] < position)
339                 num_i++;
340             rfd = rset_open (rset, RSETF_READ);
341             while (num_i < num && rset_read (rset, rfd, &key, &term_index))
342             {
343                 if (key.sysno != psysno)
344                 {
345                     psysno = key.sysno;
346                     if (sort_info)
347                     {
348                         /* determine we alreay have this in our set */
349                         for (i = sort_info->num_entries; --i >= 0; )
350                             if (psysno == sort_info->entries[i]->sysno)
351                                 break;
352                         if (i >= 0)
353                             continue;
354                     }
355                     position++;
356                     assert (num_i < num);
357                     if (position == positions[num_i])
358                     {
359                         sr[num_i].sysno = psysno;
360                         logf (LOG_DEBUG, "got pos=%d (unsorted)", position);
361                         sr[num_i].score = -1;
362                         num_i++;
363                     }
364                 }
365             }
366             rset_close (rset, rfd);
367         }
368     }
369     return sr;
370 }
371
372 void zebraPosSetDestroy (ZebraHandle zh, ZebraPosSet records, int num)
373 {
374     xfree (records);
375 }
376
377 struct sortKeyInfo {
378     int relation;
379     int attrUse;
380     int numerical;
381 };
382
383 void resultSetInsertSort (ZebraHandle zh, ZebraSet sset,
384                           struct sortKeyInfo *criteria, int num_criteria,
385                           int sysno)
386 {
387     struct zset_sort_entry this_entry;
388     struct zset_sort_entry *new_entry = NULL;
389     struct zset_sort_info *sort_info = sset->sort_info;
390     int i, j;
391
392     sortIdx_sysno (zh->reg->sortIdx, sysno);
393     for (i = 0; i<num_criteria; i++)
394     {
395         sortIdx_type (zh->reg->sortIdx, criteria[i].attrUse);
396         sortIdx_read (zh->reg->sortIdx, this_entry.buf[i]);
397     }
398     i = sort_info->num_entries;
399     while (--i >= 0)
400     {
401         int rel = 0;
402         for (j = 0; j<num_criteria; j++)
403         {
404             if (criteria[j].numerical)
405             {
406                 double diff = atof(this_entry.buf[j]) -
407                               atof(sort_info->entries[i]->buf[j]);
408                 rel = 0;
409                 if (diff > 0.0)
410                     rel = 1;
411                 else if (diff < 0.0)
412                     rel = -1;
413             }
414             else
415             {
416                 rel = memcmp (this_entry.buf[j], sort_info->entries[i]->buf[j],
417                           SORT_IDX_ENTRYSIZE);
418             }
419             if (rel)
420                 break;
421         }       
422         if (!rel)
423             break;
424         if (criteria[j].relation == 'A')
425         {
426             if (rel > 0)
427                 break;
428         }
429         else if (criteria[j].relation == 'D')
430         {
431             if (rel < 0)
432                 break;
433         }
434     }
435     ++i;
436     j = sort_info->max_entries;
437     if (i == j)
438         return;
439
440     if (sort_info->num_entries == j)
441         --j;
442     else
443         j = (sort_info->num_entries)++;
444     new_entry = sort_info->entries[j];
445     while (j != i)
446     {
447         sort_info->entries[j] = sort_info->entries[j-1];
448         --j;
449     }
450     sort_info->entries[i] = new_entry;
451     assert (new_entry);
452     for (i = 0; i<num_criteria; i++)
453         memcpy (new_entry->buf[i], this_entry.buf[i], SORT_IDX_ENTRYSIZE);
454     new_entry->sysno = sysno;
455     new_entry->score = -1;
456 }
457
458 void resultSetInsertRank (ZebraHandle zh, struct zset_sort_info *sort_info,
459                           int sysno, int score, int relation)
460 {
461     struct zset_sort_entry *new_entry = NULL;
462     int i, j;
463
464     i = sort_info->num_entries;
465     while (--i >= 0)
466     {
467         int rel = 0;
468
469         rel = score - sort_info->entries[i]->score;
470
471         if (relation == 'D')
472         {
473             if (rel >= 0)
474                 break;
475         }
476         else if (relation == 'A')
477         {
478             if (rel <= 0)
479                 break;
480         }
481     }
482     ++i;
483     j = sort_info->max_entries;
484     if (i == j)
485         return;
486
487     if (sort_info->num_entries == j)
488         --j;
489     else
490         j = (sort_info->num_entries)++;
491     
492     new_entry = sort_info->entries[j];
493     while (j != i)
494     {
495         sort_info->entries[j] = sort_info->entries[j-1];
496         --j;
497     }
498     sort_info->entries[i] = new_entry;
499     assert (new_entry);
500     new_entry->sysno = sysno;
501     new_entry->score = score;
502 }
503
504 void resultSetSort (ZebraHandle zh, NMEM nmem,
505                     int num_input_setnames, const char **input_setnames,
506                     const char *output_setname,
507                     Z_SortKeySpecList *sort_sequence, int *sort_status)
508 {
509     ZebraSet sset;
510     RSET rset;
511
512     if (num_input_setnames == 0)
513     {
514         zh->errCode = 208;
515         return ;
516     }
517     if (num_input_setnames > 1)
518     {
519         zh->errCode = 230;
520         return;
521     }
522     logf (LOG_DEBUG, "result set sort input=%s output=%s",
523           *input_setnames, output_setname);
524     sset = resultSetGet (zh, input_setnames[0]);
525     if (!sset)
526     {
527         zh->errCode = 30;
528         zh->errString = nmem_strdup (nmem, input_setnames[0]);
529         return;
530     }
531     if (!(rset = sset->rset))
532     {
533         zh->errCode = 30;
534         zh->errString = nmem_strdup (nmem, input_setnames[0]);
535         return;
536     }
537     if (strcmp (output_setname, input_setnames[0]))
538     {
539         rset = rset_dup (rset);
540         sset = resultSetAdd (zh, output_setname, 1);
541         sset->rset = rset;
542     }
543     resultSetSortSingle (zh, nmem, sset, rset, sort_sequence, sort_status);
544 }
545
546 void resultSetSortSingle (ZebraHandle zh, NMEM nmem,
547                           ZebraSet sset, RSET rset,
548                           Z_SortKeySpecList *sort_sequence, int *sort_status)
549 {
550     int i, psysno = 0;
551     struct it_key key;
552     struct sortKeyInfo sort_criteria[3];
553     int num_criteria;
554     int term_index;
555     RSFD rfd;
556
557     logf (LOG_LOG, "resultSetSortSingle start");
558     sset->sort_info->num_entries = 0;
559
560     sset->hits = 0;
561     num_criteria = sort_sequence->num_specs;
562     if (num_criteria > 3)
563         num_criteria = 3;
564     for (i = 0; i < num_criteria; i++)
565     {
566         Z_SortKeySpec *sks = sort_sequence->specs[i];
567         Z_SortKey *sk;
568
569         if (*sks->sortRelation == Z_SortRelation_ascending)
570             sort_criteria[i].relation = 'A';
571         else if (*sks->sortRelation == Z_SortRelation_descending)
572             sort_criteria[i].relation = 'D';
573         else
574         {
575             zh->errCode = 214;
576             return;
577         }
578         if (sks->sortElement->which == Z_SortElement_databaseSpecific)
579         {
580             zh->errCode = 210;
581             return;
582         }
583         else if (sks->sortElement->which != Z_SortElement_generic)
584         {
585             zh->errCode = 237;
586             return;
587         }       
588         sk = sks->sortElement->u.generic;
589         switch (sk->which)
590         {
591         case Z_SortKey_sortField:
592             logf (LOG_DEBUG, "Sort: key %d is of type sortField", i+1);
593             zh->errCode = 207;
594             return;
595         case Z_SortKey_elementSpec:
596             logf (LOG_DEBUG, "Sort: key %d is of type elementSpec", i+1);
597             zh->errCode = 207;
598             return;
599         case Z_SortKey_sortAttributes:
600             logf (LOG_DEBUG, "Sort: key %d is of type sortAttributes", i+1);
601             sort_criteria[i].attrUse =
602                 zebra_maps_sort (zh->reg->zebra_maps,
603                                  sk->u.sortAttributes,
604                                  &sort_criteria[i].numerical);
605             logf (LOG_DEBUG, "use value = %d", sort_criteria[i].attrUse);
606             if (sort_criteria[i].attrUse == -1)
607             {
608                 zh->errCode = 116;
609                 return;
610             }
611             if (sortIdx_type (zh->reg->sortIdx, sort_criteria[i].attrUse))
612             {
613                 zh->errCode = 207;
614                 return;
615             }
616             break;
617         }
618     }
619     rfd = rset_open (rset, RSETF_READ);
620     while (rset_read (rset, rfd, &key, &term_index))
621     {
622         if (key.sysno != psysno)
623         {
624             (sset->hits)++;
625             psysno = key.sysno;
626             resultSetInsertSort (zh, sset,
627                                  sort_criteria, num_criteria, psysno);
628         }
629     }
630     rset_close (rset, rfd);
631
632     for (i = 0; i < rset->no_rset_terms; i++)
633         yaz_log (LOG_LOG, "term=\"%s\" nn=%d type=%s count=%d",
634                  rset->rset_terms[i]->name,
635                  rset->rset_terms[i]->nn,
636                  rset->rset_terms[i]->flags,
637                  rset->rset_terms[i]->count);
638
639     *sort_status = Z_SortStatus_success;
640     logf (LOG_LOG, "resultSetSortSingle end");
641 }
642
643 RSET resultSetRef (ZebraHandle zh, Z_ResultSetId *resultSetId)
644 {
645     ZebraSet s;
646
647     if ((s = resultSetGet (zh, resultSetId)))
648         return s->rset;
649     return NULL;
650 }
651
652 void resultSetRank (ZebraHandle zh, ZebraSet zebraSet, RSET rset)
653 {
654     int kno = 0;
655     struct it_key key;
656     RSFD rfd;
657     int term_index, i;
658     ZebraRankClass rank_class;
659     struct rank_control *rc;
660     struct zset_sort_info *sort_info;
661
662     sort_info = zebraSet->sort_info;
663     sort_info->num_entries = 0;
664     zebraSet->hits = 0;
665     rfd = rset_open (rset, RSETF_READ);
666
667     yaz_log (LOG_LOG, "resultSetRank");
668
669     rank_class = zebraRankLookup (zh, "rank-1");
670     rc = rank_class->control;
671
672     if (rset_read (rset, rfd, &key, &term_index))
673     {
674         int psysno = key.sysno;
675         int score;
676         void *handle =
677             (*rc->begin) (zh->reg, rank_class->class_handle, rset);
678         (zebraSet->hits)++;
679         do
680         {
681             kno++;
682             if (key.sysno != psysno)
683             {
684                 score = (*rc->calc) (handle, psysno);
685
686                 resultSetInsertRank (zh, sort_info, psysno, score, 'A');
687                 (zebraSet->hits)++;
688                 psysno = key.sysno;
689             }
690             (*rc->add) (handle, key.seqno, term_index);
691         }
692         while (rset_read (rset, rfd, &key, &term_index));
693         score = (*rc->calc) (handle, psysno);
694         resultSetInsertRank (zh, sort_info, psysno, score, 'A');
695         (*rc->end) (zh->reg, handle);
696     }
697     rset_close (rset, rfd);
698
699     for (i = 0; i < rset->no_rset_terms; i++)
700         yaz_log (LOG_LOG, "term=\"%s\" nn=%d type=%s count=%d",
701                  rset->rset_terms[i]->name,
702                  rset->rset_terms[i]->nn,
703                  rset->rset_terms[i]->flags,
704                  rset->rset_terms[i]->count);
705     
706     yaz_log (LOG_LOG, "%d keys, %d distinct sysnos", kno, zebraSet->hits);
707 }
708
709 ZebraRankClass zebraRankLookup (ZebraHandle zh, const char *name)
710 {
711     ZebraRankClass p = zh->reg->rank_classes;
712     while (p && strcmp (p->control->name, name))
713         p = p->next;
714     if (p && !p->init_flag)
715     {
716         if (p->control->create)
717             p->class_handle = (*p->control->create)(zh->reg);
718         p->init_flag = 1;
719     }
720     return p;
721 }
722
723 void zebraRankInstall (struct zebra_register *reg, struct rank_control *ctrl)
724 {
725     ZebraRankClass p = (ZebraRankClass) xmalloc (sizeof(*p));
726     p->control = (struct rank_control *) xmalloc (sizeof(*p->control));
727     memcpy (p->control, ctrl, sizeof(*p->control));
728     p->control->name = xstrdup (ctrl->name);
729     p->init_flag = 0;
730     p->next = reg->rank_classes;
731     reg->rank_classes = p;
732 }
733
734 void zebraRankDestroy (struct zebra_register *reg)
735 {
736     ZebraRankClass p = reg->rank_classes;
737     while (p)
738     {
739         ZebraRankClass p_next = p->next;
740         if (p->init_flag && p->control->destroy)
741             (*p->control->destroy)(reg, p->class_handle);
742         xfree (p->control->name);
743         xfree (p->control);
744         xfree (p);
745         p = p_next;
746     }
747     reg->rank_classes = NULL;
748 }