/*
- * Copyright (C) 1994-1998, Index Data I/S
+ * Copyright (C) 1994-1999, Index Data
* All rights reserved.
* Sebastian Hammer, Adam Dickmeiss
*
* $Log: zsets.c,v $
- * Revision 1.14 1998-02-10 16:39:15 adam
+ * Revision 1.23 1999-05-26 07:49:13 adam
+ * C++ compilation.
+ *
+ * Revision 1.22 1999/02/02 14:51:15 adam
+ * Updated WIN32 code specific sections. Changed header.
+ *
+ * Revision 1.21 1998/11/16 16:03:46 adam
+ * Moved loggin utilities to Yaz. Was implemented in file zlogs.c.
+ *
+ * Revision 1.20 1998/11/16 10:10:53 adam
+ * Fixed problem with zebraPosSetCreate that occurred when positions were
+ * less than 1.
+ *
+ * Revision 1.19 1998/09/22 10:48:22 adam
+ * Minor changes in search API.
+ *
+ * Revision 1.18 1998/09/22 10:03:45 adam
+ * Changed result sets to be persistent in the sense that they can
+ * be re-searched if needed.
+ * Fixed memory leak in rsm_or.
+ *
+ * Revision 1.17 1998/06/23 15:33:36 adam
+ * Added feature to specify sort criteria in query (type 7 specifies
+ * sort flags).
+ *
+ * Revision 1.16 1998/05/20 10:12:24 adam
+ * Implemented automatic EXPLAIN database maintenance.
+ * Modified Zebra to work with ASN.1 compiled version of YAZ.
+ *
+ * Revision 1.15 1998/03/05 08:45:14 adam
+ * New result set model and modular ranking system. Moved towards
+ * descent server API. System information stored as "SGML" records.
+ *
+ * Revision 1.14 1998/02/10 16:39:15 adam
* Minor change.
*
* Revision 1.13 1998/02/10 12:03:06 adam
*/
#include <stdio.h>
#include <assert.h>
-#ifdef WINDOWS
+#ifdef WIN32
#include <io.h>
#else
#include <unistd.h>
#define SORT_IDX_ENTRYSIZE 64
#define ZSET_SORT_MAX_LEVEL 3
+struct zebra_set {
+ char *name;
+ RSET rset;
+ NMEM nmem;
+ int hits;
+ int num_bases;
+ char **basenames;
+ Z_RPNQuery *rpn;
+ struct zset_sort_info *sort_info;
+ struct zebra_set *next;
+};
+
struct zset_sort_entry {
int sysno;
+ int score;
char buf[ZSET_SORT_MAX_LEVEL][SORT_IDX_ENTRYSIZE];
};
struct zset_sort_info {
int max_entries;
int num_entries;
+ struct zset_sort_entry *all_entries;
struct zset_sort_entry **entries;
};
-void resultSetSortReset (struct zset_sort_info **si)
+ZebraSet resultSetAddRPN (ZebraHandle zh, ODR input, ODR output,
+ Z_RPNQuery *rpn, int num_bases, char **basenames,
+ const char *setname)
{
- int i;
- if (!*si)
- return ;
- for (i = 0; i<(*si)->num_entries; i++)
- xfree ((*si)->entries[i]);
- xfree ((*si)->entries);
- xfree (*si);
- *si = NULL;
+ ZebraSet zebraSet;
+
+ zh->errCode = 0;
+ zh->errString = NULL;
+ zh->hits = 0;
+
+ zebraSet = resultSetAdd (zh, setname, 1);
+ if (!zebraSet)
+ return 0;
+ zebraSet->rpn = 0;
+ zebraSet->num_bases = num_bases;
+ zebraSet->basenames = basenames;
+ zebraSet->nmem = odr_extract_mem (input);
+
+ zebraSet->rset = rpn_search (zh, output->mem, rpn,
+ zebraSet->num_bases,
+ zebraSet->basenames, zebraSet->name,
+ zebraSet);
+ zh->hits = zebraSet->hits;
+ if (zebraSet->rset)
+ zebraSet->rpn = rpn;
+ return zebraSet;
}
-ZServerSet *resultSetAdd (ZServerInfo *zi, const char *name, int ov, RSET rset)
+ZebraSet resultSetAdd (ZebraHandle zh, const char *name, int ov)
{
- ZServerSet *s;
+ ZebraSet s;
+ int i;
- for (s = zi->sets; s; s = s->next)
+ for (s = zh->sets; s; s = s->next)
if (!strcmp (s->name, name))
- {
- logf (LOG_DEBUG, "updating result set %s", name);
- if (!ov)
- return NULL;
- resultSetSortReset (&s->sort_info);
- rset_delete (s->rset);
- s->rset = rset;
- return s;
- }
- logf (LOG_DEBUG, "adding result set %s", name);
- s = xmalloc (sizeof(*s));
- s->next = zi->sets;
- zi->sets = s;
- s->name = xmalloc (strlen(name)+1);
- strcpy (s->name, name);
- s->rset = rset;
- s->sort_info = NULL;
+ break;
+ if (s)
+ {
+ logf (LOG_DEBUG, "updating result set %s", name);
+ if (!ov)
+ return NULL;
+ if (s->rset)
+ rset_delete (s->rset);
+ if (s->nmem)
+ nmem_destroy (s->nmem);
+ }
+ else
+ {
+ logf (LOG_DEBUG, "adding result set %s", name);
+ s = (ZebraSet) xmalloc (sizeof(*s));
+ s->next = zh->sets;
+ zh->sets = s;
+ s->name = (char *) xmalloc (strlen(name)+1);
+ strcpy (s->name, name);
+
+ s->sort_info = (struct zset_sort_info *)
+ xmalloc (sizeof(*s->sort_info));
+ s->sort_info->max_entries = 1000;
+ s->sort_info->entries = (struct zset_sort_entry **)
+ xmalloc (sizeof(*s->sort_info->entries) *
+ s->sort_info->max_entries);
+ s->sort_info->all_entries = (struct zset_sort_entry *)
+ xmalloc (sizeof(*s->sort_info->all_entries) *
+ s->sort_info->max_entries);
+ for (i = 0; i < s->sort_info->max_entries; i++)
+ s->sort_info->entries[i] = s->sort_info->all_entries + i;
+ }
+ s->rset = 0;
+ s->nmem = 0;
return s;
}
-ZServerSet *resultSetGet (ZServerInfo *zi, const char *name)
+ZebraSet resultSetGet (ZebraHandle zh, const char *name)
{
- ZServerSet *s;
+ ZebraSet s;
- for (s = zi->sets; s; s = s->next)
+ for (s = zh->sets; s; s = s->next)
if (!strcmp (s->name, name))
+ {
+ if (!s->rset && s->rpn)
+ {
+ NMEM nmem = nmem_create ();
+ s->rset =
+ rpn_search (zh, nmem, s->rpn, s->num_bases,
+ s->basenames, s->name, s);
+ nmem_destroy (nmem);
+
+ }
return s;
+ }
return NULL;
}
-void resultSetDestroy (ZServerInfo *zi)
+void resultSetDestroy (ZebraHandle zh)
{
- ZServerSet *s, *s1;
+ ZebraSet s, s1;
- for (s = zi->sets; s; s = s1)
+ for (s = zh->sets; s; s = s1)
{
s1 = s->next;
- resultSetSortReset (&s->sort_info);
+
+ xfree (s->sort_info->all_entries);
+ xfree (s->sort_info->entries);
+ xfree (s->sort_info);
+
+ if (s->nmem)
+ nmem_destroy (s->nmem);
rset_delete (s->rset);
xfree (s->name);
xfree (s);
}
- zi->sets = NULL;
+ zh->sets = NULL;
}
-ZServerSetSysno *resultSetSysnoGet (ZServerInfo *zi, const char *name,
- int num, int *positions)
+ZebraPosSet zebraPosSetCreate (ZebraHandle zh, const char *name,
+ int num, int *positions)
{
- ZServerSet *sset;
- ZServerSetSysno *sr;
+ ZebraSet sset;
+ ZebraPosSet sr;
RSET rset;
int i;
struct zset_sort_info *sort_info;
- if (!(sset = resultSetGet (zi, name)))
+ if (!(sset = resultSetGet (zh, name)))
return NULL;
if (!(rset = sset->rset))
return NULL;
- sr = xmalloc (sizeof(*sr) * num);
+ sr = (ZebraPosSet) xmalloc (sizeof(*sr) * num);
for (i = 0; i<num; i++)
{
sr[i].sysno = 0;
for (i = 0; i<num; i++)
{
position = positions[i];
- if (position <= sort_info->num_entries)
+ if (position > 0 && position <= sort_info->num_entries)
{
logf (LOG_DEBUG, "got pos=%d (sorted)", position);
sr[i].sysno = sort_info->entries[position-1]->sysno;
+ sr[i].score = sort_info->entries[position-1]->score;
}
}
}
int position = 0;
int num_i = 0;
int psysno = 0;
+ int term_index;
RSFD rfd;
struct it_key key;
position = sort_info->num_entries;
while (num_i < num && positions[num_i] < position)
num_i++;
- rfd = rset_open (rset, RSETF_READ|RSETF_SORT_RANK);
- while (num_i < num && rset_read (rset, rfd, &key))
+ rfd = rset_open (rset, RSETF_READ);
+ while (num_i < num && rset_read (rset, rfd, &key, &term_index))
{
if (key.sysno != psysno)
{
{
sr[num_i].sysno = psysno;
logf (LOG_DEBUG, "got pos=%d (unsorted)", position);
- rset_score (rset, rfd, &sr[num_i].score);
+ sr[num_i].score = -1;
num_i++;
}
}
return sr;
}
-void resultSetSysnoDel (ZServerInfo *zi, ZServerSetSysno *records, int num)
+void zebraPosSetDestroy (ZebraHandle zh, ZebraPosSet records, int num)
{
xfree (records);
}
int attrUse;
};
-void resultSetInsertSort (ZServerInfo *zi, ZServerSet *sset,
+void resultSetInsertSort (ZebraHandle zh, ZebraSet sset,
struct sortKey *criteria, int num_criteria,
int sysno)
{
struct zset_sort_info *sort_info = sset->sort_info;
int i, j;
- sortIdx_sysno (zi->sortIdx, sysno);
+ sortIdx_sysno (zh->sortIdx, sysno);
for (i = 0; i<num_criteria; i++)
{
- sortIdx_type (zi->sortIdx, criteria[i].attrUse);
- sortIdx_read (zi->sortIdx, this_entry.buf[i]);
+ sortIdx_type (zh->sortIdx, criteria[i].attrUse);
+ sortIdx_read (zh->sortIdx, this_entry.buf[i]);
}
i = sort_info->num_entries;
while (--i >= 0)
if (rel)
break;
}
- if (rel)
+ if (!rel)
+ break;
+ if (criteria[j].relation == 'A')
+ {
+ if (rel > 0)
+ break;
+ }
+ else if (criteria[j].relation == 'D')
{
- if (criteria[j].relation == 'D')
- if (rel > 0)
- break;
- if (criteria[j].relation == 'A')
- if (rel < 0)
- break;
+ if (rel < 0)
+ break;
}
}
j = sort_info->max_entries-1;
for (i = 0; i<num_criteria; i++)
memcpy (new_entry->buf[i], this_entry.buf[i], SORT_IDX_ENTRYSIZE);
new_entry->sysno = sysno;
+ new_entry->score = -1;
}
-
-int resultSetSort (ZServerInfo *zi, bend_sort_rr *rr)
+
+void resultSetInsertRank (ZebraHandle zh, struct zset_sort_info *sort_info,
+ int sysno, int score, int relation)
{
- ZServerSet *sset;
+ struct zset_sort_entry *new_entry = NULL;
+ int i, j;
+
+ i = sort_info->num_entries;
+ while (--i >= 0)
+ {
+ int rel = 0;
+
+ rel = score - sort_info->entries[i]->score;
+
+ if (relation == 'D')
+ {
+ if (rel >= 0)
+ break;
+ }
+ else if (relation == 'A')
+ {
+ if (rel <= 0)
+ break;
+ }
+ }
+ j = sort_info->max_entries-1;
+ if (i == j)
+ return;
+ ++i;
+ new_entry = sort_info->entries[j];
+ while (j != i)
+ {
+ sort_info->entries[j] = sort_info->entries[j-1];
+ --j;
+ }
+ sort_info->entries[j] = new_entry;
+ assert (new_entry);
+ if (sort_info->num_entries != sort_info->max_entries)
+ (sort_info->num_entries)++;
+ new_entry->sysno = sysno;
+ new_entry->score = score;
+}
+
+void resultSetSort (ZebraHandle zh, NMEM nmem,
+ int num_input_setnames, const char **input_setnames,
+ const char *output_setname,
+ Z_SortKeySpecList *sort_sequence, int *sort_status)
+{
+ ZebraSet sset;
RSET rset;
- int i, psysno = 0;
- struct it_key key;
- struct sortKey sort_criteria[3];
- int num_criteria;
- RSFD rfd;
- if (rr->num_input_setnames == 0)
+ if (num_input_setnames == 0)
{
- rr->errcode = 208;
- return 0;
+ zh->errCode = 208;
+ return ;
}
- if (rr->num_input_setnames > 1)
+ if (num_input_setnames > 1)
{
- rr->errcode = 230;
- return 0;
+ zh->errCode = 230;
+ return;
}
- sset = resultSetGet (zi, rr->input_setnames[0]);
+ logf (LOG_DEBUG, "result set sort input=%s output=%s",
+ *input_setnames, output_setname);
+ sset = resultSetGet (zh, input_setnames[0]);
if (!sset)
{
- rr->errcode = 30;
- rr->errstring = rr->input_setnames[0];
- return 0;
+ zh->errCode = 30;
+ zh->errString = nmem_strdup (nmem, input_setnames[0]);
+ return;
}
if (!(rset = sset->rset))
{
- rr->errcode = 30;
- rr->errstring = rr->input_setnames[0];
- return 0;
+ zh->errCode = 30;
+ zh->errString = nmem_strdup (nmem, input_setnames[0]);
+ return;
}
- num_criteria = rr->sort_sequence->num_specs;
+ if (strcmp (output_setname, input_setnames[0]))
+ {
+ rset = rset_dup (rset);
+ sset = resultSetAdd (zh, output_setname, 1);
+ sset->rset = rset;
+ }
+ resultSetSortSingle (zh, nmem, sset, rset, sort_sequence, sort_status);
+}
+
+void resultSetSortSingle (ZebraHandle zh, NMEM nmem,
+ ZebraSet sset, RSET rset,
+ Z_SortKeySpecList *sort_sequence, int *sort_status)
+{
+ int i, psysno = 0;
+ struct it_key key;
+ struct sortKey sort_criteria[3];
+ int num_criteria;
+ int term_index;
+ RSFD rfd;
+
+ logf (LOG_DEBUG, "resultSetSortSingle start");
+ sset->sort_info->num_entries = 0;
+
+ sset->hits = 0;
+ num_criteria = sort_sequence->num_specs;
if (num_criteria > 3)
num_criteria = 3;
for (i = 0; i < num_criteria; i++)
{
- Z_SortKeySpec *sks = rr->sort_sequence->specs[i];
+ Z_SortKeySpec *sks = sort_sequence->specs[i];
Z_SortKey *sk;
if (*sks->sortRelation == Z_SortRelation_ascending)
sort_criteria[i].relation = 'D';
else
{
- rr->errcode = 214;
- return 0;
+ zh->errCode = 214;
+ return;
}
if (sks->sortElement->which == Z_SortElement_databaseSpecific)
{
- rr->errcode = 210;
- return 0;
+ zh->errCode = 210;
+ return;
}
else if (sks->sortElement->which != Z_SortElement_generic)
{
- rr->errcode = 237;
- return 0;
+ zh->errCode = 237;
+ return;
}
sk = sks->sortElement->u.generic;
switch (sk->which)
{
case Z_SortKey_sortField:
logf (LOG_DEBUG, "Sort: key %d is of type sortField", i+1);
- rr->errcode = 207;
- return 0;
+ zh->errCode = 207;
+ return;
case Z_SortKey_elementSpec:
logf (LOG_DEBUG, "Sort: key %d is of type elementSpec", i+1);
- return 0;
+ zh->errCode = 207;
+ return;
case Z_SortKey_sortAttributes:
logf (LOG_DEBUG, "Sort: key %d is of type sortAttributes", i+1);
sort_criteria[i].attrUse =
- zebra_maps_sort (zi->zebra_maps, sk->u.sortAttributes);
+ zebra_maps_sort (zh->zebra_maps, sk->u.sortAttributes);
logf (LOG_DEBUG, "use value = %d", sort_criteria[i].attrUse);
if (sort_criteria[i].attrUse == -1)
{
- rr->errcode = 116;
- return 0;
+ zh->errCode = 116;
+ return;
}
- if (sortIdx_type (zi->sortIdx, sort_criteria[i].attrUse))
+ if (sortIdx_type (zh->sortIdx, sort_criteria[i].attrUse))
{
- rr->errcode = 207;
- return 0;
+ zh->errCode = 207;
+ return;
}
break;
}
}
- if (strcmp (rr->output_setname, rr->input_setnames[0]))
- {
- rset = rset_dup (rset);
- sset = resultSetAdd (zi, rr->output_setname, 1, rset);
- }
- resultSetSortReset (&sset->sort_info);
-
- sset->sort_info = xmalloc (sizeof(*sset->sort_info));
- sset->sort_info->max_entries = 100;
- sset->sort_info->num_entries = 0;
- sset->sort_info->entries = xmalloc (sizeof(*sset->sort_info->entries) *
- sset->sort_info->max_entries);
- for (i = 0; i<sset->sort_info->max_entries; i++)
- sset->sort_info->entries[i] =
- xmalloc (sizeof(*sset->sort_info->entries[i]));
-
-
- rfd = rset_open (rset, RSETF_READ|RSETF_SORT_SYSNO);
- while (rset_read (rset, rfd, &key))
+ rfd = rset_open (rset, RSETF_READ);
+ while (rset_read (rset, rfd, &key, &term_index))
{
if (key.sysno != psysno)
{
+ (sset->hits)++;
psysno = key.sysno;
- resultSetInsertSort (zi, sset,
+ resultSetInsertSort (zh, sset,
sort_criteria, num_criteria, psysno);
}
}
rset_close (rset, rfd);
- rr->errcode = 0;
- rr->sort_status = Z_SortStatus_success;
-
- return 0;
+ zh->errCode = 0;
+ *sort_status = Z_SortStatus_success;
+ logf (LOG_DEBUG, "resultSetSortSingle end");
}
+RSET resultSetRef (ZebraHandle zh, Z_ResultSetId *resultSetId)
+{
+ ZebraSet s;
+
+ if ((s = resultSetGet (zh, resultSetId)))
+ return s->rset;
+ return NULL;
+}
+
+void resultSetRank (ZebraHandle zh, ZebraSet zebraSet, RSET rset)
+{
+ int kno = 0;
+ struct it_key key;
+ RSFD rfd;
+ int term_index, i;
+ ZebraRankClass rank_class;
+ struct rank_control *rc;
+ struct zset_sort_info *sort_info;
+
+ sort_info = zebraSet->sort_info;
+ sort_info->num_entries = 0;
+ zebraSet->hits = 0;
+ rfd = rset_open (rset, RSETF_READ);
+
+ logf (LOG_DEBUG, "resultSetRank");
+ for (i = 0; i < rset->no_rset_terms; i++)
+ logf (LOG_DEBUG, "term=\"%s\" cnt=%d type=%s",
+ rset->rset_terms[i]->name,
+ rset->rset_terms[i]->nn,
+ rset->rset_terms[i]->flags);
+
+ rank_class = zebraRankLookup (zh, "rank-1");
+ rc = rank_class->control;
+
+ if (rset_read (rset, rfd, &key, &term_index))
+ {
+ int psysno = key.sysno;
+ int score;
+ void *handle =
+ (*rc->begin) (zh, rank_class->class_handle, rset);
+ (zebraSet->hits)++;
+ do
+ {
+ kno++;
+ if (key.sysno != psysno)
+ {
+ score = (*rc->calc) (handle, psysno);
+
+ resultSetInsertRank (zh, sort_info, psysno, score, 'A');
+ (zebraSet->hits)++;
+ psysno = key.sysno;
+ }
+ (*rc->add) (handle, key.seqno, term_index);
+ }
+ while (rset_read (rset, rfd, &key, &term_index));
+ score = (*rc->calc) (handle, psysno);
+ resultSetInsertRank (zh, sort_info, psysno, score, 'A');
+ (*rc->end) (zh, handle);
+ }
+ rset_close (rset, rfd);
+ logf (LOG_DEBUG, "%d keys, %d distinct sysnos", kno, zebraSet->hits);
+}
+
+ZebraRankClass zebraRankLookup (ZebraHandle zh, const char *name)
+{
+ ZebraRankClass p = zh->rank_classes;
+ while (p && strcmp (p->control->name, name))
+ p = p->next;
+ if (p && !p->init_flag)
+ {
+ if (p->control->create)
+ p->class_handle = (*p->control->create)(zh);
+ p->init_flag = 1;
+ }
+ return p;
+}
+
+void zebraRankInstall (ZebraHandle zh, struct rank_control *ctrl)
+{
+ ZebraRankClass p = (ZebraRankClass) xmalloc (sizeof(*p));
+ p->control = (struct rank_control *) xmalloc (sizeof(*p->control));
+ memcpy (p->control, ctrl, sizeof(*p->control));
+ p->control->name = xstrdup (ctrl->name);
+ p->init_flag = 0;
+ p->next = zh->rank_classes;
+ zh->rank_classes = p;
+}
+
+void zebraRankDestroy (ZebraHandle zh)
+{
+ ZebraRankClass p = zh->rank_classes;
+ while (p)
+ {
+ ZebraRankClass p_next = p->next;
+ if (p->init_flag && p->control->destroy)
+ (*p->control->destroy)(zh, p->class_handle);
+ xfree (p->control->name);
+ xfree (p->control);
+ xfree (p);
+ p = p_next;
+ }
+ zh->rank_classes = NULL;
+}
projects / idzebra-moved-to-github.git / blobdiff