-/* $Id: zsets.c,v 1.93 2005-08-19 09:21:34 adam Exp $
- Copyright (C) 1995-2005
+/* $Id: zsets.c,v 1.106 2006-06-06 21:01:30 adam Exp $
+ Copyright (C) 1995-2006
Index Data ApS
This file is part of the Zebra server.
#endif
#include "index.h"
+#include "rank.h"
#include <yaz/diagbib1.h>
#include <rset.h>
struct zebra_set_term_entry {
int reg_type;
char *db;
- int set;
- int use;
+ char *index_name;
char *term;
};
int num_bases;
char **basenames;
Z_RPNQuery *rpn;
+ Z_SortKeySpecList *sortSpec;
struct zset_sort_info *sort_info;
struct zebra_set_term_entry *term_entries;
int term_entries_max;
return res;
}
-void resultSetAddTerm (ZebraHandle zh, ZebraSet s, int reg_type,
- const char *db, int set,
- int use, const char *term)
+void resultSetAddTerm(ZebraHandle zh, ZebraSet s, int reg_type,
+ const char *db, const char *index_name,
+ const char *term)
{
assert(zh); /* compiler shut up */
if (!s->nmem)
{
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->term_entries[s->hits].index_name = nmem_strdup(s->nmem, index_name);
+ s->term_entries[s->hits].term = nmem_strdup(s->nmem, term);
}
(s->hits)++;
}
s->rset_nmem = 0;
s->nmem = 0;
s->rpn = 0;
+ s->sortSpec = 0;
s->cache_position = 0;
s->cache_rfd = 0;
s->approx_limit = zh->approx_limit;
if (!s->rset_nmem)
s->rset_nmem=nmem_create();
resultSetSearch(zh, nmem, s->rset_nmem, s->rpn, s);
+ if (s->rset && s->sortSpec)
+ {
+ int sort_status;
+ yaz_log(log_level_resultsets, "resort %s", name);
+ resultSetSortSingle (zh, nmem, s, s->rset, s->sortSpec,
+ &sort_status);
+ }
nmem_destroy (nmem);
}
return s;
struct sortKeyInfo {
int relation;
+#if 0
int attrUse;
+#else
+ int ord;
+#endif
int numerical;
};
sortIdx_sysno (zh->reg->sortIdx, sysno);
for (i = 0; i<num_criteria; i++)
{
- sortIdx_type (zh->reg->sortIdx, criteria[i].attrUse);
- sortIdx_read (zh->reg->sortIdx, this_entry.buf[i]);
+ memset(this_entry.buf[i], '\0', SORT_IDX_ENTRYSIZE);
+ if (criteria[i].ord != -1)
+ {
+ sortIdx_type (zh->reg->sortIdx, criteria[i].ord);
+ sortIdx_read (zh->reg->sortIdx, this_entry.buf[i]);
+ }
}
i = sort_info->num_entries;
while (--i >= 0)
else
{
rel = memcmp (this_entry.buf[j], sort_info->entries[i]->buf[j],
- SORT_IDX_ENTRYSIZE);
+ SORT_IDX_ENTRYSIZE);
}
if (rel)
break;
new_entry->score = score;
}
+static Z_RPNQuery *copy_RPNQuery(Z_RPNQuery *src, NMEM nmem)
+{
+ Z_RPNQuery *dst = 0;
+ ODR encode = odr_createmem(ODR_ENCODE);
+ ODR decode = odr_createmem(ODR_DECODE);
+
+ if (z_RPNQuery(encode, &src, 0, 0))
+ {
+ int len;
+ char *buf = odr_getbuf(encode, &len, 0);
+
+ if (buf)
+ {
+ odr_setbuf(decode, buf, len, 0);
+ z_RPNQuery(decode, &dst, 0, 0);
+ }
+ }
+ nmem_transfer(nmem, decode->mem);
+ odr_destroy(encode);
+ odr_destroy(decode);
+ return dst;
+}
+
+static Z_SortKeySpecList *copy_SortKeySpecList(Z_SortKeySpecList *src, NMEM nmem)
+{
+ Z_SortKeySpecList *dst = 0;
+ ODR encode = odr_createmem(ODR_ENCODE);
+ ODR decode = odr_createmem(ODR_DECODE);
+
+ if (z_SortKeySpecList(encode, &src, 0, 0))
+ {
+ int len;
+ char *buf = odr_getbuf(encode, &len, 0);
+
+ if (buf)
+ {
+ odr_setbuf(decode, buf, len, 0);
+ z_SortKeySpecList(decode, &dst, 0, 0);
+ }
+ }
+ nmem_transfer(nmem, decode->mem);
+ odr_destroy(encode);
+ odr_destroy(decode);
+ return dst;
+}
+
+ZebraSet resultSetClone(ZebraHandle zh, const char *setname,
+ ZebraSet rset)
+{
+ ZebraSet nset;
+ int i;
+
+ nset = resultSetAdd(zh, setname, 1);
+ if (!nset)
+ return 0;
+
+ nset->nmem = nmem_create();
+
+ nset->num_bases = rset->num_bases;
+ nset->basenames =
+ nmem_malloc (nset->nmem, nset->num_bases * sizeof(*rset->basenames));
+ for (i = 0; i<rset->num_bases; i++)
+ nset->basenames[i] = nmem_strdup(nset->nmem, rset->basenames[i]);
+
+ if (rset->rset)
+ nset->rset = rset_dup(rset->rset);
+ if (rset->rpn)
+ nset->rpn = copy_RPNQuery(rset->rpn, nset->nmem);
+ return nset;
+}
+
ZEBRA_RES resultSetSort(ZebraHandle zh, NMEM nmem,
int num_input_setnames, const char **input_setnames,
const char *output_setname,
return ZEBRA_FAIL;
}
if (strcmp (output_setname, input_setnames[0]))
- {
- rset = rset_dup (rset);
- sset = resultSetAdd (zh, output_setname, 1);
- sset->rset = rset;
- }
+ sset = resultSetClone(zh, output_setname, sset);
+ sset->sortSpec = copy_SortKeySpecList(sort_sequence, sset->nmem);
return resultSetSortSingle (zh, nmem, sset, rset, sort_sequence,
sort_status);
}
if (zh->m_staticrank)
sysno_mem_index = 1;
-
assert(nmem); /* compiler shut up about unused param */
sset->sort_info->num_entries = 0;
{
Z_SortKeySpec *sks = sort_sequence->specs[i];
Z_SortKey *sk;
+ ZEBRA_RES res;
+ sort_criteria[i].ord = -1;
+ sort_criteria[i].numerical = 0;
+
+ if (sks->which == Z_SortKeySpec_missingValueData)
+ {
+ zebra_setError(zh, YAZ_BIB1_UNSUPP_MISSING_DATA_ACTION, 0);
+ return ZEBRA_FAIL;
+ }
if (*sks->sortRelation == Z_SortKeySpec_ascending)
sort_criteria[i].relation = 'A';
else if (*sks->sortRelation == Z_SortKeySpec_descending)
case Z_SortKey_sortField:
yaz_log(log_level_sort, "key %d is of type sortField",
i+1);
- zebra_setError(zh, YAZ_BIB1_CANNOT_SORT_ACCORDING_TO_SEQUENCE, 0);
- return ZEBRA_FAIL;
+ sort_criteria[i].numerical = 0;
+ sort_criteria[i].ord =
+ zebraExplain_lookup_attr_str(zh->reg->zei, 's',
+ sk->u.sortField);
+ if (sks->which != Z_SortKeySpec_null
+ && sort_criteria[i].ord == -1)
+ {
+ zebra_setError(zh,
+ YAZ_BIB1_CANNOT_SORT_ACCORDING_TO_SEQUENCE, 0);
+ return ZEBRA_FAIL;
+ }
+ break;
case Z_SortKey_elementSpec:
yaz_log(log_level_sort, "key %d is of type elementSpec",
i+1);
return ZEBRA_FAIL;
case Z_SortKey_sortAttributes:
yaz_log(log_level_sort, "key %d is of type sortAttributes", i+1);
- sort_criteria[i].attrUse =
- zebra_maps_sort (zh->reg->zebra_maps,
- sk->u.sortAttributes,
- &sort_criteria[i].numerical);
- yaz_log(log_level_sort, "use value = %d", sort_criteria[i].attrUse);
- if (sort_criteria[i].attrUse == -1)
- {
- zebra_setError(
- zh, YAZ_BIB1_USE_ATTRIBUTE_REQUIRED_BUT_NOT_SUPPLIED, 0);
- return ZEBRA_FAIL;
- }
- if (sortIdx_type (zh->reg->sortIdx, sort_criteria[i].attrUse))
- {
- zebra_setError(
- zh, YAZ_BIB1_CANNOT_SORT_ACCORDING_TO_SEQUENCE, 0);
+ res = zebra_sort_get_ord(zh, sk->u.sortAttributes,
+ &sort_criteria[i].ord,
+ &sort_criteria[i].numerical);
+ if (sks->which != Z_SortKeySpec_null && res != ZEBRA_OK)
return ZEBRA_FAIL;
- }
break;
}
}
terms, numTerms);
zint psysno = 0; /* previous doc id / sys no */
zint pstaticrank = 0; /* previous static rank */
+ int stop_flag = 0;
while (rset_read(rfd, &key, &termid))
{
zint this_sys = key.mem[sysno_mem_index];
break;
if (psysno)
{ /* only if we did have a previous record */
- score = (*rc->calc) (handle, psysno, pstaticrank);
+ score = (*rc->calc) (handle, psysno, pstaticrank,
+ &stop_flag);
/* insert the hit. A=Ascending */
resultSetInsertRank (zh, sort_info, psysno, score, 'A');
count++;
+ if (stop_flag)
+ break;
}
psysno = this_sys;
if (zh->m_staticrank)
/* no more items */
if (psysno)
{ /* we had - at least - one record */
- score = (*rc->calc)(handle, psysno, pstaticrank);
+ score = (*rc->calc)(handle, psysno, pstaticrank, &stop_flag);
/* insert the hit. A=Ascending */
resultSetInsertRank(zh, sort_info, psysno, score, 'A');
count++;
zint sysno, zebra_snippets *snippets)
{
ZebraSet sset = resultSetGet(zh, setname);
- yaz_log(YLOG_LOG, "zebra_get_hit_vector setname=%s zysno=" ZINT_FORMAT,
+ yaz_log(YLOG_DEBUG, "zebra_get_hit_vector setname=%s zysno=" ZINT_FORMAT,
setname, sysno);
if (!sset)
return ZEBRA_FAIL;
NMEM nmem = nmem_create();
struct it_key key;
RSET rsets[2], rset_comb;
- RSET rset_temp = rstemp_create(nmem, kc, kc->scope,
- res_get (zh->res, "setTmpDir"),0 );
+ RSET rset_temp = rset_create_temp(nmem, kc, kc->scope,
+ res_get (zh->res, "setTmpDir"),0 );
TERMID termid;
RSFD rsfd = rset_open(rset_temp, RSETF_WRITE);
rsets[0] = rset_temp;
rsets[1] = rset_dup(sset->rset);
- rset_comb = rsmulti_and_create(nmem, kc, kc->scope, 2, rsets);
+ rset_comb = rset_create_and(nmem, kc, kc->scope, 2, rsets);
rsfd = rset_open(rset_comb, RSETF_READ);
for (ol = termid->ol; ol; ol = ol->next)
{
zebra_snippets_append(snippets, key.mem[key.len-1],
- termid->reg_type,
ol->ord, termid->name);
}
}
rset_delete(rset_comb);
nmem_destroy(nmem);
+ kc->dec(kc);
}
return ZEBRA_OK;
}
+/*
+ * Local variables:
+ * c-basic-offset: 4
+ * indent-tabs-mode: nil
+ * End:
+ * vim: shiftwidth=4 tabstop=8 expandtab
+ */
+
projects / idzebra-moved-to-github.git / blobdiff