2 * Copyright (C) 1994-1998, Index Data I/S
4 * Sebastian Hammer, Adam Dickmeiss
7 * Revision 1.17 1998-06-23 15:33:36 adam
8 * Added feature to specify sort criteria in query (type 7 specifies
11 * Revision 1.16 1998/05/20 10:12:24 adam
12 * Implemented automatic EXPLAIN database maintenance.
13 * Modified Zebra to work with ASN.1 compiled version of YAZ.
15 * Revision 1.15 1998/03/05 08:45:14 adam
16 * New result set model and modular ranking system. Moved towards
17 * descent server API. System information stored as "SGML" records.
19 * Revision 1.14 1998/02/10 16:39:15 adam
22 * Revision 1.13 1998/02/10 12:03:06 adam
25 * Revision 1.12 1997/09/25 14:57:36 adam
28 * Revision 1.11 1996/12/23 15:30:46 adam
30 * Bug fix: result sets weren't deleted after server shut down.
32 * Revision 1.10 1995/10/30 15:08:08 adam
35 * Revision 1.9 1995/10/17 18:02:14 adam
36 * New feature: databases. Implemented as prefix to words in dictionary.
38 * Revision 1.8 1995/10/10 13:59:25 adam
39 * Function rset_open changed its wflag parameter to general flags.
41 * Revision 1.7 1995/10/06 14:38:01 adam
42 * New result set method: r_score.
43 * Local no (sysno) and score is transferred to retrieveCtrl.
45 * Revision 1.6 1995/09/28 09:19:49 adam
46 * xfree/xmalloc used everywhere.
47 * Extract/retrieve method seems to work for text records.
49 * Revision 1.5 1995/09/27 16:17:32 adam
50 * More work on retrieve.
52 * Revision 1.4 1995/09/07 13:58:36 adam
53 * New parameter: result-set file descriptor (RSFD) to support multiple
54 * positions within the same result-set.
55 * Boolean operators: and, or, not implemented.
56 * Result-set references.
58 * Revision 1.3 1995/09/06 16:11:19 adam
59 * Option: only one word key per file.
61 * Revision 1.2 1995/09/06 10:33:04 adam
62 * More work on present. Some log messages removed.
64 * Revision 1.1 1995/09/05 15:28:40 adam
65 * More work on search engine.
79 #define SORT_IDX_ENTRYSIZE 64
80 #define ZSET_SORT_MAX_LEVEL 3
86 struct zset_sort_info *sort_info;
87 struct zebra_set *next;
90 struct zset_sort_entry {
93 char buf[ZSET_SORT_MAX_LEVEL][SORT_IDX_ENTRYSIZE];
96 struct zset_sort_info {
99 struct zset_sort_entry *all_entries;
100 struct zset_sort_entry **entries;
103 void resultSetRank (ZebraHandle zh, struct zset_sort_info *si,
104 RSET rset, int *hits);
106 ZebraSet resultSetAdd (ZebraHandle zh, const char *name, int ov,
107 RSET rset, int *hits)
112 for (s = zh->sets; s; s = s->next)
113 if (!strcmp (s->name, name))
115 logf (LOG_DEBUG, "updating result set %s", name);
118 rset_delete (s->rset);
120 resultSetRank (zh, s->sort_info, rset, hits);
123 logf (LOG_DEBUG, "adding result set %s", name);
124 s = xmalloc (sizeof(*s));
127 s->name = xmalloc (strlen(name)+1);
128 strcpy (s->name, name);
131 s->sort_info = xmalloc (sizeof(*s->sort_info));
132 s->sort_info->max_entries = 1000;
133 s->sort_info->entries = xmalloc (sizeof(*s->sort_info->entries) *
134 s->sort_info->max_entries);
135 s->sort_info->all_entries = xmalloc (sizeof(*s->sort_info->all_entries) *
136 s->sort_info->max_entries);
137 for (i = 0; i < s->sort_info->max_entries; i++)
138 s->sort_info->entries[i] = s->sort_info->all_entries + i;
139 resultSetRank (zh, s->sort_info, rset, hits);
143 ZebraSet resultSetGet (ZebraHandle zh, const char *name)
147 for (s = zh->sets; s; s = s->next)
148 if (!strcmp (s->name, name))
154 void resultSetDestroy (ZebraHandle zh)
158 for (s = zh->sets; s; s = s1)
162 xfree (s->sort_info->all_entries);
163 xfree (s->sort_info->entries);
164 xfree (s->sort_info);
166 rset_delete (s->rset);
173 ZebraPosSet zebraPosSetCreate (ZebraHandle zh, const char *name,
174 int num, int *positions)
180 struct zset_sort_info *sort_info;
182 if (!(sset = resultSetGet (zh, name)))
184 if (!(rset = sset->rset))
186 sr = xmalloc (sizeof(*sr) * num);
187 for (i = 0; i<num; i++)
192 sort_info = sset->sort_info;
197 for (i = 0; i<num; i++)
199 position = positions[i];
200 if (position <= sort_info->num_entries)
202 logf (LOG_DEBUG, "got pos=%d (sorted)", position);
203 sr[i].sysno = sort_info->entries[position-1]->sysno;
204 sr[i].score = sort_info->entries[position-1]->score;
208 /* did we really get all entries using sort ? */
209 for (i = 0; i<num; i++)
214 if (i < num) /* nope, get the rest, unsorted - sorry */
224 position = sort_info->num_entries;
225 while (num_i < num && positions[num_i] < position)
227 rfd = rset_open (rset, RSETF_READ);
228 while (num_i < num && rset_read (rset, rfd, &key, &term_index))
230 if (key.sysno != psysno)
235 /* determine we alreay have this in our set */
236 for (i = sort_info->num_entries; --i >= 0; )
237 if (psysno == sort_info->entries[i]->sysno)
243 assert (num_i < num);
244 if (position == positions[num_i])
246 sr[num_i].sysno = psysno;
247 logf (LOG_DEBUG, "got pos=%d (unsorted)", position);
248 sr[num_i].score = -1;
253 rset_close (rset, rfd);
258 void zebraPosSetDestroy (ZebraHandle zh, ZebraPosSet records, int num)
268 void resultSetInsertSort (ZebraHandle zh, ZebraSet sset,
269 struct sortKey *criteria, int num_criteria,
272 struct zset_sort_entry this_entry;
273 struct zset_sort_entry *new_entry = NULL;
274 struct zset_sort_info *sort_info = sset->sort_info;
277 sortIdx_sysno (zh->sortIdx, sysno);
278 for (i = 0; i<num_criteria; i++)
280 sortIdx_type (zh->sortIdx, criteria[i].attrUse);
281 sortIdx_read (zh->sortIdx, this_entry.buf[i]);
283 i = sort_info->num_entries;
287 for (j = 0; j<num_criteria; j++)
289 rel = memcmp (this_entry.buf[j], sort_info->entries[i]->buf[j],
296 if (criteria[j].relation == 'A')
301 else if (criteria[j].relation == 'D')
307 j = sort_info->max_entries-1;
311 new_entry = sort_info->entries[j];
314 sort_info->entries[j] = sort_info->entries[j-1];
317 sort_info->entries[j] = new_entry;
319 if (sort_info->num_entries != sort_info->max_entries)
320 (sort_info->num_entries)++;
321 for (i = 0; i<num_criteria; i++)
322 memcpy (new_entry->buf[i], this_entry.buf[i], SORT_IDX_ENTRYSIZE);
323 new_entry->sysno = sysno;
324 new_entry->score = -1;
327 void resultSetInsertRank (ZebraHandle zh, struct zset_sort_info *sort_info,
328 int sysno, int score, int relation)
330 struct zset_sort_entry *new_entry = NULL;
333 i = sort_info->num_entries;
338 rel = score - sort_info->entries[i]->score;
345 else if (relation == 'A')
351 j = sort_info->max_entries-1;
355 new_entry = sort_info->entries[j];
358 sort_info->entries[j] = sort_info->entries[j-1];
361 sort_info->entries[j] = new_entry;
363 if (sort_info->num_entries != sort_info->max_entries)
364 (sort_info->num_entries)++;
365 new_entry->sysno = sysno;
366 new_entry->score = score;
369 void resultSetSort (ZebraHandle zh, ODR stream,
370 int num_input_setnames, const char **input_setnames,
371 const char *output_setname,
372 Z_SortKeySpecList *sort_sequence, int *sort_status)
378 struct sortKey sort_criteria[3];
383 if (num_input_setnames == 0)
388 if (num_input_setnames > 1)
393 logf (LOG_DEBUG, "result set sort input=%s output=%s",
394 *input_setnames, output_setname);
395 sset = resultSetGet (zh, input_setnames[0]);
399 zh->errString = nmem_strdup (stream->mem, input_setnames[0]);
402 if (!(rset = sset->rset))
405 zh->errString = nmem_strdup (stream->mem, input_setnames[0]);
408 num_criteria = sort_sequence->num_specs;
409 if (num_criteria > 3)
411 for (i = 0; i < num_criteria; i++)
413 Z_SortKeySpec *sks = sort_sequence->specs[i];
416 if (*sks->sortRelation == Z_SortRelation_ascending)
417 sort_criteria[i].relation = 'A';
418 else if (*sks->sortRelation == Z_SortRelation_descending)
419 sort_criteria[i].relation = 'D';
425 if (sks->sortElement->which == Z_SortElement_databaseSpecific)
430 else if (sks->sortElement->which != Z_SortElement_generic)
435 sk = sks->sortElement->u.generic;
438 case Z_SortKey_sortField:
439 logf (LOG_DEBUG, "Sort: key %d is of type sortField", i+1);
442 case Z_SortKey_elementSpec:
443 logf (LOG_DEBUG, "Sort: key %d is of type elementSpec", i+1);
446 case Z_SortKey_sortAttributes:
447 logf (LOG_DEBUG, "Sort: key %d is of type sortAttributes", i+1);
448 sort_criteria[i].attrUse =
449 zebra_maps_sort (zh->zebra_maps, sk->u.sortAttributes);
450 logf (LOG_DEBUG, "use value = %d", sort_criteria[i].attrUse);
451 if (sort_criteria[i].attrUse == -1)
456 if (sortIdx_type (zh->sortIdx, sort_criteria[i].attrUse))
464 if (strcmp (output_setname, input_setnames[0]))
467 rset = rset_dup (rset);
468 sset = resultSetAdd (zh, output_setname, 1, rset, &hits);
470 sset->sort_info->num_entries = 0;
472 rfd = rset_open (rset, RSETF_READ);
473 while (rset_read (rset, rfd, &key, &term_index))
475 if (key.sysno != psysno)
478 resultSetInsertSort (zh, sset,
479 sort_criteria, num_criteria, psysno);
482 rset_close (rset, rfd);
485 *sort_status = Z_SortStatus_success;
490 RSET resultSetRef (ZebraHandle zh, Z_ResultSetId *resultSetId)
494 if ((s = resultSetGet (zh, resultSetId)))
499 void resultSetRank (ZebraHandle zh, struct zset_sort_info *sort_info,
500 RSET rset, int *hits)
506 ZebraRankClass rank_class;
507 struct rank_control *rc;
509 sort_info->num_entries = 0;
511 rfd = rset_open (rset, RSETF_READ);
513 logf (LOG_DEBUG, "resultSetRank");
514 for (i = 0; i < rset->no_rset_terms; i++)
515 logf (LOG_DEBUG, "term=\"%s\" cnt=%d type=%s",
516 rset->rset_terms[i]->name,
517 rset->rset_terms[i]->nn,
518 rset->rset_terms[i]->flags);
520 rank_class = zebraRankLookup (zh, "rank-1");
521 rc = rank_class->control;
523 if (rset_read (rset, rfd, &key, &term_index))
525 int psysno = key.sysno;
528 (*rc->begin) (zh, rank_class->class_handle, rset);
533 if (key.sysno != psysno)
535 score = (*rc->calc) (handle, psysno);
537 resultSetInsertRank (zh, sort_info, psysno, score, 'A');
541 (*rc->add) (handle, key.seqno, term_index);
543 while (rset_read (rset, rfd, &key, &term_index));
544 score = (*rc->calc) (handle, psysno);
545 resultSetInsertRank (zh, sort_info, psysno, score, 'A');
546 (*rc->end) (zh, handle);
548 rset_close (rset, rfd);
549 logf (LOG_DEBUG, "%d keys, %d distinct sysnos", kno, *hits);
552 ZebraRankClass zebraRankLookup (ZebraHandle zh, const char *name)
554 ZebraRankClass p = zh->rank_classes;
555 while (p && strcmp (p->control->name, name))
557 if (p && !p->init_flag)
559 if (p->control->create)
560 p->class_handle = (*p->control->create)(zh);
566 void zebraRankInstall (ZebraHandle zh, struct rank_control *ctrl)
568 ZebraRankClass p = xmalloc (sizeof(*p));
569 p->control = xmalloc (sizeof(*p->control));
570 memcpy (p->control, ctrl, sizeof(*p->control));
571 p->control->name = xstrdup (ctrl->name);
573 p->next = zh->rank_classes;
574 zh->rank_classes = p;
577 void zebraRankDestroy (ZebraHandle zh)
579 ZebraRankClass p = zh->rank_classes;
582 ZebraRankClass p_next = p->next;
583 if (p->init_flag && p->control->destroy)
584 (*p->control->destroy)(zh, p->class_handle);
585 xfree (p->control->name);
590 zh->rank_classes = NULL;