2 * Copyright (C) 1994-2000, Index Data
4 * Sebastian Hammer, Adam Dickmeiss
7 * Revision 1.30 2001-10-15 19:53:43 adam
8 * POSIX thread updates. First work on term sets.
10 * Revision 1.29 2001/01/22 10:42:56 adam
11 * Added numerical sort.
13 * Revision 1.28 2000/07/07 12:49:20 adam
14 * Optimized resultSetInsert{Rank,Sort}.
16 * Revision 1.27 2000/04/05 09:49:36 adam
17 * On Unix, zebra/z'mbol uses automake.
19 * Revision 1.26 2000/03/20 19:08:36 adam
20 * Added remote record import using Z39.50 extended services and Segment
23 * Revision 1.25 2000/03/15 15:00:31 adam
24 * First work on threaded version.
26 * Revision 1.24 1999/11/04 15:00:45 adam
27 * Implemented delete result set(s).
29 * Revision 1.23 1999/05/26 07:49:13 adam
32 * Revision 1.22 1999/02/02 14:51:15 adam
33 * Updated WIN32 code specific sections. Changed header.
35 * Revision 1.21 1998/11/16 16:03:46 adam
36 * Moved loggin utilities to Yaz. Was implemented in file zlogs.c.
38 * Revision 1.20 1998/11/16 10:10:53 adam
39 * Fixed problem with zebraPosSetCreate that occurred when positions were
42 * Revision 1.19 1998/09/22 10:48:22 adam
43 * Minor changes in search API.
45 * Revision 1.18 1998/09/22 10:03:45 adam
46 * Changed result sets to be persistent in the sense that they can
47 * be re-searched if needed.
48 * Fixed memory leak in rsm_or.
50 * Revision 1.17 1998/06/23 15:33:36 adam
51 * Added feature to specify sort criteria in query (type 7 specifies
54 * Revision 1.16 1998/05/20 10:12:24 adam
55 * Implemented automatic EXPLAIN database maintenance.
56 * Modified Zebra to work with ASN.1 compiled version of YAZ.
58 * Revision 1.15 1998/03/05 08:45:14 adam
59 * New result set model and modular ranking system. Moved towards
60 * descent server API. System information stored as "SGML" records.
62 * Revision 1.14 1998/02/10 16:39:15 adam
65 * Revision 1.13 1998/02/10 12:03:06 adam
68 * Revision 1.12 1997/09/25 14:57:36 adam
71 * Revision 1.11 1996/12/23 15:30:46 adam
73 * Bug fix: result sets weren't deleted after server shut down.
75 * Revision 1.10 1995/10/30 15:08:08 adam
78 * Revision 1.9 1995/10/17 18:02:14 adam
79 * New feature: databases. Implemented as prefix to words in dictionary.
81 * Revision 1.8 1995/10/10 13:59:25 adam
82 * Function rset_open changed its wflag parameter to general flags.
84 * Revision 1.7 1995/10/06 14:38:01 adam
85 * New result set method: r_score.
86 * Local no (sysno) and score is transferred to retrieveCtrl.
88 * Revision 1.6 1995/09/28 09:19:49 adam
89 * xfree/xmalloc used everywhere.
90 * Extract/retrieve method seems to work for text records.
92 * Revision 1.5 1995/09/27 16:17:32 adam
93 * More work on retrieve.
95 * Revision 1.4 1995/09/07 13:58:36 adam
96 * New parameter: result-set file descriptor (RSFD) to support multiple
97 * positions within the same result-set.
98 * Boolean operators: and, or, not implemented.
99 * Result-set references.
101 * Revision 1.3 1995/09/06 16:11:19 adam
102 * Option: only one word key per file.
104 * Revision 1.2 1995/09/06 10:33:04 adam
105 * More work on present. Some log messages removed.
107 * Revision 1.1 1995/09/05 15:28:40 adam
108 * More work on search engine.
122 #define SORT_IDX_ENTRYSIZE 64
123 #define ZSET_SORT_MAX_LEVEL 3
125 struct zebra_set_term_entry {
140 struct zset_sort_info *sort_info;
141 struct zebra_set_term_entry *term_entries;
142 int term_entries_max;
143 struct zebra_set *next;
147 struct zset_sort_entry {
150 char buf[ZSET_SORT_MAX_LEVEL][SORT_IDX_ENTRYSIZE];
153 struct zset_sort_info {
156 struct zset_sort_entry *all_entries;
157 struct zset_sort_entry **entries;
160 ZebraSet resultSetAddRPN (ZebraHandle zh, ODR input, ODR output,
161 Z_RPNQuery *rpn, int num_bases, char **basenames,
167 zh->errString = NULL;
170 zebraSet = resultSetAdd (zh, setname, 1);
173 zebraSet->locked = 1;
175 zebraSet->num_bases = num_bases;
176 zebraSet->basenames = basenames;
177 zebraSet->nmem = odr_extract_mem (input);
179 zebraSet->rset = rpn_search (zh, output->mem, rpn,
181 zebraSet->basenames, zebraSet->name,
183 zh->hits = zebraSet->hits;
186 zebraSet->locked = 0;
190 void resultSetAddTerm (ZebraHandle zh, ZebraSet s, int reg_type,
191 const char *db, int set,
192 int use, const char *term)
195 s->nmem = nmem_create ();
196 if (!s->term_entries)
199 s->term_entries_max = 1000;
201 nmem_malloc (s->nmem, s->term_entries_max *
202 sizeof(*s->term_entries));
203 for (i = 0; i < s->term_entries_max; i++)
204 s->term_entries[i].term = 0;
206 if (s->hits < s->term_entries_max)
208 s->term_entries[s->hits].reg_type = reg_type;
209 s->term_entries[s->hits].db = nmem_strdup (s->nmem, db);
210 s->term_entries[s->hits].set = set;
211 s->term_entries[s->hits].use = use;
212 s->term_entries[s->hits].term = nmem_strdup (s->nmem, term);
217 ZebraSet resultSetAdd (ZebraHandle zh, const char *name, int ov)
222 for (s = zh->sets; s; s = s->next)
223 if (!strcmp (s->name, name))
227 logf (LOG_DEBUG, "updating result set %s", name);
228 if (!ov || s->locked)
231 rset_delete (s->rset);
233 nmem_destroy (s->nmem);
237 logf (LOG_DEBUG, "adding result set %s", name);
238 s = (ZebraSet) xmalloc (sizeof(*s));
241 s->name = (char *) xmalloc (strlen(name)+1);
242 strcpy (s->name, name);
244 s->sort_info = (struct zset_sort_info *)
245 xmalloc (sizeof(*s->sort_info));
246 s->sort_info->max_entries = 1000;
247 s->sort_info->entries = (struct zset_sort_entry **)
248 xmalloc (sizeof(*s->sort_info->entries) *
249 s->sort_info->max_entries);
250 s->sort_info->all_entries = (struct zset_sort_entry *)
251 xmalloc (sizeof(*s->sort_info->all_entries) *
252 s->sort_info->max_entries);
253 for (i = 0; i < s->sort_info->max_entries; i++)
254 s->sort_info->entries[i] = s->sort_info->all_entries + i;
265 ZebraSet resultSetGet (ZebraHandle zh, const char *name)
269 for (s = zh->sets; s; s = s->next)
270 if (!strcmp (s->name, name))
272 if (!s->term_entries && !s->rset && s->rpn)
274 NMEM nmem = nmem_create ();
276 rpn_search (zh, nmem, s->rpn, s->num_bases,
277 s->basenames, s->name, s);
285 void resultSetDestroy (ZebraHandle zh, int num, char **names,int *statuses)
287 ZebraSet *ss = &zh->sets;
291 for (i = 0; i<num; i++)
292 statuses[i] = Z_DeleteStatus_resultSetDidNotExist;
294 zh->errString = NULL;
301 for (i = 0; i<num; i++)
302 if (!strcmp (s->name, names[i]))
305 statuses[i] = Z_DeleteStatus_success;
314 xfree (s->sort_info->all_entries);
315 xfree (s->sort_info->entries);
316 xfree (s->sort_info);
319 nmem_destroy (s->nmem);
321 rset_delete (s->rset);
330 ZebraPosSet zebraPosSetCreate (ZebraHandle zh, const char *name,
331 int num, int *positions)
337 struct zset_sort_info *sort_info;
339 if (!(sset = resultSetGet (zh, name)))
341 if (!(rset = sset->rset))
343 if (!sset->term_entries)
345 sr = (ZebraPosSet) xmalloc (sizeof(*sr) * num);
346 for (i = 0; i<num; i++)
349 struct zebra_set_term_entry *entry = sset->term_entries;
356 if (positions[i] <= sset->term_entries_max)
358 sr[i].term = sset->term_entries[positions[i]-1].term;
359 sr[i].db = sset->term_entries[positions[i]-1].db;
365 sr = (ZebraPosSet) xmalloc (sizeof(*sr) * num);
366 for (i = 0; i<num; i++)
373 sort_info = sset->sort_info;
378 for (i = 0; i<num; i++)
380 position = positions[i];
381 if (position > 0 && position <= sort_info->num_entries)
383 logf (LOG_DEBUG, "got pos=%d (sorted)", position);
384 sr[i].sysno = sort_info->entries[position-1]->sysno;
385 sr[i].score = sort_info->entries[position-1]->score;
389 /* did we really get all entries using sort ? */
390 for (i = 0; i<num; i++)
395 if (i < num) /* nope, get the rest, unsorted - sorry */
405 position = sort_info->num_entries;
406 while (num_i < num && positions[num_i] < position)
408 rfd = rset_open (rset, RSETF_READ);
409 while (num_i < num && rset_read (rset, rfd, &key, &term_index))
411 if (key.sysno != psysno)
416 /* determine we alreay have this in our set */
417 for (i = sort_info->num_entries; --i >= 0; )
418 if (psysno == sort_info->entries[i]->sysno)
424 assert (num_i < num);
425 if (position == positions[num_i])
427 sr[num_i].sysno = psysno;
428 logf (LOG_DEBUG, "got pos=%d (unsorted)", position);
429 sr[num_i].score = -1;
434 rset_close (rset, rfd);
440 void zebraPosSetDestroy (ZebraHandle zh, ZebraPosSet records, int num)
451 void resultSetInsertSort (ZebraHandle zh, ZebraSet sset,
452 struct sortKeyInfo *criteria, int num_criteria,
455 struct zset_sort_entry this_entry;
456 struct zset_sort_entry *new_entry = NULL;
457 struct zset_sort_info *sort_info = sset->sort_info;
460 sortIdx_sysno (zh->service->sortIdx, sysno);
461 for (i = 0; i<num_criteria; i++)
463 sortIdx_type (zh->service->sortIdx, criteria[i].attrUse);
464 sortIdx_read (zh->service->sortIdx, this_entry.buf[i]);
466 i = sort_info->num_entries;
470 for (j = 0; j<num_criteria; j++)
472 if (criteria[j].numerical)
474 double diff = atof(this_entry.buf[j]) -
475 atof(sort_info->entries[i]->buf[j]);
484 rel = memcmp (this_entry.buf[j], sort_info->entries[i]->buf[j],
492 if (criteria[j].relation == 'A')
497 else if (criteria[j].relation == 'D')
504 j = sort_info->max_entries;
508 if (sort_info->num_entries == j)
511 j = (sort_info->num_entries)++;
512 new_entry = sort_info->entries[j];
515 sort_info->entries[j] = sort_info->entries[j-1];
518 sort_info->entries[i] = new_entry;
520 for (i = 0; i<num_criteria; i++)
521 memcpy (new_entry->buf[i], this_entry.buf[i], SORT_IDX_ENTRYSIZE);
522 new_entry->sysno = sysno;
523 new_entry->score = -1;
526 void resultSetInsertRank (ZebraHandle zh, struct zset_sort_info *sort_info,
527 int sysno, int score, int relation)
529 struct zset_sort_entry *new_entry = NULL;
532 i = sort_info->num_entries;
537 rel = score - sort_info->entries[i]->score;
544 else if (relation == 'A')
551 j = sort_info->max_entries;
555 if (sort_info->num_entries == j)
558 j = (sort_info->num_entries)++;
560 new_entry = sort_info->entries[j];
563 sort_info->entries[j] = sort_info->entries[j-1];
566 sort_info->entries[i] = new_entry;
568 new_entry->sysno = sysno;
569 new_entry->score = score;
572 void resultSetSort (ZebraHandle zh, NMEM nmem,
573 int num_input_setnames, const char **input_setnames,
574 const char *output_setname,
575 Z_SortKeySpecList *sort_sequence, int *sort_status)
580 if (num_input_setnames == 0)
585 if (num_input_setnames > 1)
590 logf (LOG_DEBUG, "result set sort input=%s output=%s",
591 *input_setnames, output_setname);
592 sset = resultSetGet (zh, input_setnames[0]);
596 zh->errString = nmem_strdup (nmem, input_setnames[0]);
599 if (!(rset = sset->rset))
602 zh->errString = nmem_strdup (nmem, input_setnames[0]);
605 if (strcmp (output_setname, input_setnames[0]))
607 rset = rset_dup (rset);
608 sset = resultSetAdd (zh, output_setname, 1);
611 resultSetSortSingle (zh, nmem, sset, rset, sort_sequence, sort_status);
614 void resultSetSortSingle (ZebraHandle zh, NMEM nmem,
615 ZebraSet sset, RSET rset,
616 Z_SortKeySpecList *sort_sequence, int *sort_status)
620 struct sortKeyInfo sort_criteria[3];
625 logf (LOG_DEBUG, "resultSetSortSingle start");
626 sset->sort_info->num_entries = 0;
629 num_criteria = sort_sequence->num_specs;
630 if (num_criteria > 3)
632 for (i = 0; i < num_criteria; i++)
634 Z_SortKeySpec *sks = sort_sequence->specs[i];
637 if (*sks->sortRelation == Z_SortRelation_ascending)
638 sort_criteria[i].relation = 'A';
639 else if (*sks->sortRelation == Z_SortRelation_descending)
640 sort_criteria[i].relation = 'D';
646 if (sks->sortElement->which == Z_SortElement_databaseSpecific)
651 else if (sks->sortElement->which != Z_SortElement_generic)
656 sk = sks->sortElement->u.generic;
659 case Z_SortKey_sortField:
660 logf (LOG_DEBUG, "Sort: key %d is of type sortField", i+1);
663 case Z_SortKey_elementSpec:
664 logf (LOG_DEBUG, "Sort: key %d is of type elementSpec", i+1);
667 case Z_SortKey_sortAttributes:
668 logf (LOG_DEBUG, "Sort: key %d is of type sortAttributes", i+1);
669 sort_criteria[i].attrUse =
670 zebra_maps_sort (zh->service->zebra_maps,
671 sk->u.sortAttributes,
672 &sort_criteria[i].numerical);
673 logf (LOG_DEBUG, "use value = %d", sort_criteria[i].attrUse);
674 if (sort_criteria[i].attrUse == -1)
679 if (sortIdx_type (zh->service->sortIdx, sort_criteria[i].attrUse))
687 rfd = rset_open (rset, RSETF_READ);
688 while (rset_read (rset, rfd, &key, &term_index))
690 if (key.sysno != psysno)
694 resultSetInsertSort (zh, sset,
695 sort_criteria, num_criteria, psysno);
698 rset_close (rset, rfd);
700 *sort_status = Z_SortStatus_success;
701 logf (LOG_DEBUG, "resultSetSortSingle end");
704 RSET resultSetRef (ZebraHandle zh, Z_ResultSetId *resultSetId)
708 if ((s = resultSetGet (zh, resultSetId)))
713 void resultSetRank (ZebraHandle zh, ZebraSet zebraSet, RSET rset)
719 ZebraRankClass rank_class;
720 struct rank_control *rc;
721 struct zset_sort_info *sort_info;
723 sort_info = zebraSet->sort_info;
724 sort_info->num_entries = 0;
726 rfd = rset_open (rset, RSETF_READ);
728 logf (LOG_DEBUG, "resultSetRank");
729 for (i = 0; i < rset->no_rset_terms; i++)
730 logf (LOG_DEBUG, "term=\"%s\" cnt=%d type=%s",
731 rset->rset_terms[i]->name,
732 rset->rset_terms[i]->nn,
733 rset->rset_terms[i]->flags);
735 rank_class = zebraRankLookup (zh, "rank-1");
736 rc = rank_class->control;
738 if (rset_read (rset, rfd, &key, &term_index))
740 int psysno = key.sysno;
743 (*rc->begin) (zh, rank_class->class_handle, rset);
748 if (key.sysno != psysno)
750 score = (*rc->calc) (handle, psysno);
752 resultSetInsertRank (zh, sort_info, psysno, score, 'A');
756 (*rc->add) (handle, key.seqno, term_index);
758 while (rset_read (rset, rfd, &key, &term_index));
759 score = (*rc->calc) (handle, psysno);
760 resultSetInsertRank (zh, sort_info, psysno, score, 'A');
761 (*rc->end) (zh, handle);
763 rset_close (rset, rfd);
764 logf (LOG_DEBUG, "%d keys, %d distinct sysnos", kno, zebraSet->hits);
767 ZebraRankClass zebraRankLookup (ZebraHandle zh, const char *name)
769 ZebraRankClass p = zh->service->rank_classes;
770 while (p && strcmp (p->control->name, name))
772 if (p && !p->init_flag)
774 if (p->control->create)
775 p->class_handle = (*p->control->create)(zh->service);
781 void zebraRankInstall (ZebraService zh, struct rank_control *ctrl)
783 ZebraRankClass p = (ZebraRankClass) xmalloc (sizeof(*p));
784 p->control = (struct rank_control *) xmalloc (sizeof(*p->control));
785 memcpy (p->control, ctrl, sizeof(*p->control));
786 p->control->name = xstrdup (ctrl->name);
788 p->next = zh->rank_classes;
789 zh->rank_classes = p;
792 void zebraRankDestroy (ZebraService zh)
794 ZebraRankClass p = zh->rank_classes;
797 ZebraRankClass p_next = p->next;
798 if (p->init_flag && p->control->destroy)
799 (*p->control->destroy)(zh, p->class_handle);
800 xfree (p->control->name);
805 zh->rank_classes = NULL;