/*
- * Copyright (C) 1994-1999, Index Data
+ * Copyright (C) 1994-2000, Index Data
* All rights reserved.
* Sebastian Hammer, Adam Dickmeiss
*
* $Log: zsets.c,v $
- * Revision 1.26 2000-03-20 19:08:36 adam
+ * Revision 1.32 2002-02-20 17:30:01 adam
+ * Work on new API. Locking system re-implemented
+ *
+ * Revision 1.31 2001/11/19 23:05:22 adam
+ * Added a few prototypes.
+ *
+ * Revision 1.30 2001/10/15 19:53:43 adam
+ * POSIX thread updates. First work on term sets.
+ *
+ * Revision 1.29 2001/01/22 10:42:56 adam
+ * Added numerical sort.
+ *
+ * Revision 1.28 2000/07/07 12:49:20 adam
+ * Optimized resultSetInsert{Rank,Sort}.
+ *
+ * Revision 1.27 2000/04/05 09:49:36 adam
+ * On Unix, zebra/z'mbol uses automake.
+ *
+ * Revision 1.26 2000/03/20 19:08:36 adam
* Added remote record import using Z39.50 extended services and Segment
* Requests.
*
#define SORT_IDX_ENTRYSIZE 64
#define ZSET_SORT_MAX_LEVEL 3
+struct zebra_set_term_entry {
+ int reg_type;
+ char *db;
+ int set;
+ int use;
+ char *term;
+};
struct zebra_set {
char *name;
RSET rset;
char **basenames;
Z_RPNQuery *rpn;
struct zset_sort_info *sort_info;
+ struct zebra_set_term_entry *term_entries;
+ int term_entries_max;
struct zebra_set *next;
+ int locked;
};
struct zset_sort_entry {
zebraSet = resultSetAdd (zh, setname, 1);
if (!zebraSet)
return 0;
+ zebraSet->locked = 1;
zebraSet->rpn = 0;
zebraSet->num_bases = num_bases;
zebraSet->basenames = basenames;
zh->hits = zebraSet->hits;
if (zebraSet->rset)
zebraSet->rpn = rpn;
+ zebraSet->locked = 0;
return zebraSet;
}
+void resultSetAddTerm (ZebraHandle zh, ZebraSet s, int reg_type,
+ const char *db, int set,
+ int use, const char *term)
+{
+ if (!s->nmem)
+ s->nmem = nmem_create ();
+ if (!s->term_entries)
+ {
+ int i;
+ s->term_entries_max = 1000;
+ s->term_entries =
+ nmem_malloc (s->nmem, s->term_entries_max *
+ sizeof(*s->term_entries));
+ for (i = 0; i < s->term_entries_max; i++)
+ s->term_entries[i].term = 0;
+ }
+ if (s->hits < s->term_entries_max)
+ {
+ s->term_entries[s->hits].reg_type = reg_type;
+ s->term_entries[s->hits].db = nmem_strdup (s->nmem, db);
+ s->term_entries[s->hits].set = set;
+ s->term_entries[s->hits].use = use;
+ s->term_entries[s->hits].term = nmem_strdup (s->nmem, term);
+ }
+ (s->hits)++;
+}
+
ZebraSet resultSetAdd (ZebraHandle zh, const char *name, int ov)
{
ZebraSet s;
if (s)
{
logf (LOG_DEBUG, "updating result set %s", name);
- if (!ov)
+ if (!ov || s->locked)
return NULL;
if (s->rset)
rset_delete (s->rset);
for (i = 0; i < s->sort_info->max_entries; i++)
s->sort_info->entries[i] = s->sort_info->all_entries + i;
}
+ s->locked = 0;
+ s->term_entries = 0;
+ s->hits = 0;
s->rset = 0;
- s->nmem = 0;
+ s->nmem = 0;
+ s->rpn = 0;
return s;
}
for (s = zh->sets; s; s = s->next)
if (!strcmp (s->name, name))
{
- if (!s->rset && s->rpn)
+ if (!s->term_entries && !s->rset && s->rpn)
{
NMEM nmem = nmem_create ();
+ yaz_log (LOG_LOG, "research %s", name);
s->rset =
rpn_search (zh, nmem, s->rpn, s->num_bases,
s->basenames, s->name, s);
nmem_destroy (nmem);
-
}
return s;
}
return NULL;
}
+void resultSetInvalidate (ZebraHandle zh)
+{
+ ZebraSet s = zh->sets;
+
+ for (; s; s = s->next)
+ {
+ if (s->rset)
+ rset_delete (s->rset);
+ s->rset = 0;
+ }
+}
+
void resultSetDestroy (ZebraHandle zh, int num, char **names,int *statuses)
{
- ZebraSet *ss = &zh->sets;
+ ZebraSet * ss = &zh->sets;
int i;
if (statuses)
if (s->nmem)
nmem_destroy (s->nmem);
- rset_delete (s->rset);
+ if (s->rset)
+ rset_delete (s->rset);
xfree (s->name);
xfree (s);
}
int num, int *positions)
{
ZebraSet sset;
- ZebraPosSet sr;
+ ZebraPosSet sr = 0;
RSET rset;
int i;
struct zset_sort_info *sort_info;
if (!(sset = resultSetGet (zh, name)))
return NULL;
if (!(rset = sset->rset))
- return NULL;
- sr = (ZebraPosSet) xmalloc (sizeof(*sr) * num);
- for (i = 0; i<num; i++)
- {
- sr[i].sysno = 0;
- sr[i].score = -1;
- }
- sort_info = sset->sort_info;
- if (sort_info)
{
- int position;
-
+ if (!sset->term_entries)
+ return 0;
+ sr = (ZebraPosSet) xmalloc (sizeof(*sr) * num);
for (i = 0; i<num; i++)
{
- position = positions[i];
- if (position > 0 && position <= sort_info->num_entries)
+ struct zebra_set_term_entry *entry = sset->term_entries;
+
+ sr[i].sysno = 0;
+ sr[i].score = -1;
+ sr[i].term = 0;
+ sr[i].db = 0;
+
+ if (positions[i] <= sset->term_entries_max)
{
- 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;
+ sr[i].term = sset->term_entries[positions[i]-1].term;
+ sr[i].db = sset->term_entries[positions[i]-1].db;
}
}
}
- /* did we really get all entries using sort ? */
- for (i = 0; i<num; i++)
- {
- if (!sr[i].sysno)
- break;
- }
- if (i < num) /* nope, get the rest, unsorted - sorry */
+ else
{
- int position = 0;
- int num_i = 0;
- int psysno = 0;
- int term_index;
- RSFD rfd;
- struct it_key key;
-
+ sr = (ZebraPosSet) xmalloc (sizeof(*sr) * num);
+ for (i = 0; i<num; i++)
+ {
+ sr[i].sysno = 0;
+ sr[i].score = -1;
+ sr[i].term = 0;
+ sr[i].db = 0;
+ }
+ sort_info = sset->sort_info;
if (sort_info)
- position = sort_info->num_entries;
- while (num_i < num && positions[num_i] < position)
- num_i++;
- rfd = rset_open (rset, RSETF_READ);
- while (num_i < num && rset_read (rset, rfd, &key, &term_index))
{
- if (key.sysno != psysno)
+ int position;
+
+ for (i = 0; i<num; i++)
{
- psysno = key.sysno;
- if (sort_info)
+ position = positions[i];
+ if (position > 0 && position <= sort_info->num_entries)
{
- /* determine we alreay have this in our set */
- for (i = sort_info->num_entries; --i >= 0; )
- if (psysno == sort_info->entries[i]->sysno)
- break;
- if (i >= 0)
- continue;
+ 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;
}
- position++;
- assert (num_i < num);
- if (position == positions[num_i])
+ }
+ }
+ /* did we really get all entries using sort ? */
+ for (i = 0; i<num; i++)
+ {
+ if (!sr[i].sysno)
+ break;
+ }
+ if (i < num) /* nope, get the rest, unsorted - sorry */
+ {
+ int position = 0;
+ int num_i = 0;
+ int psysno = 0;
+ int term_index;
+ RSFD rfd;
+ struct it_key key;
+
+ if (sort_info)
+ position = sort_info->num_entries;
+ while (num_i < num && positions[num_i] < position)
+ num_i++;
+ 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);
- sr[num_i].score = -1;
- num_i++;
+ psysno = key.sysno;
+ if (sort_info)
+ {
+ /* determine we alreay have this in our set */
+ for (i = sort_info->num_entries; --i >= 0; )
+ if (psysno == sort_info->entries[i]->sysno)
+ break;
+ if (i >= 0)
+ continue;
+ }
+ position++;
+ assert (num_i < num);
+ if (position == positions[num_i])
+ {
+ sr[num_i].sysno = psysno;
+ logf (LOG_DEBUG, "got pos=%d (unsorted)", position);
+ sr[num_i].score = -1;
+ num_i++;
+ }
}
}
+ rset_close (rset, rfd);
}
- rset_close (rset, rfd);
}
return sr;
}
struct sortKeyInfo {
int relation;
int attrUse;
+ int numerical;
};
void resultSetInsertSort (ZebraHandle zh, ZebraSet sset,
int rel = 0;
for (j = 0; j<num_criteria; j++)
{
- rel = memcmp (this_entry.buf[j], sort_info->entries[i]->buf[j],
+ if (criteria[j].numerical)
+ {
+ double diff = atof(this_entry.buf[j]) -
+ atof(sort_info->entries[i]->buf[j]);
+ rel = 0;
+ if (diff > 0.0)
+ rel = 1;
+ else if (diff < 0.0)
+ rel = -1;
+ }
+ else
+ {
+ rel = memcmp (this_entry.buf[j], sort_info->entries[i]->buf[j],
SORT_IDX_ENTRYSIZE);
+ }
if (rel)
break;
}
break;
}
}
- j = sort_info->max_entries-1;
+ ++i;
+ j = sort_info->max_entries;
if (i == j)
return;
- ++i;
+
+ if (sort_info->num_entries == j)
+ --j;
+ else
+ j = (sort_info->num_entries)++;
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;
+ sort_info->entries[i] = new_entry;
assert (new_entry);
- if (sort_info->num_entries != sort_info->max_entries)
- (sort_info->num_entries)++;
for (i = 0; i<num_criteria; i++)
memcpy (new_entry->buf[i], this_entry.buf[i], SORT_IDX_ENTRYSIZE);
new_entry->sysno = sysno;
break;
}
}
- j = sort_info->max_entries-1;
+ ++i;
+ j = sort_info->max_entries;
if (i == j)
return;
- ++i;
+
+ if (sort_info->num_entries == j)
+ --j;
+ else
+ j = (sort_info->num_entries)++;
+
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;
+ sort_info->entries[i] = 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;
}
logf (LOG_DEBUG, "Sort: key %d is of type sortAttributes", i+1);
sort_criteria[i].attrUse =
zebra_maps_sort (zh->service->zebra_maps,
- sk->u.sortAttributes);
+ sk->u.sortAttributes,
+ &sort_criteria[i].numerical);
logf (LOG_DEBUG, "use value = %d", sort_criteria[i].attrUse);
if (sort_criteria[i].attrUse == -1)
{
}
rset_close (rset, rfd);
- zh->errCode = 0;
*sort_status = Z_SortStatus_success;
logf (LOG_DEBUG, "resultSetSortSingle end");
}
projects / idzebra-moved-to-github.git / blobdiff