X-Git-Url: http://git.indexdata.com/?p=idzebra-moved-to-github.git;a=blobdiff_plain;f=rset%2Frset.c;h=3da4bd6220f55f037e06aac3bd556cd26fb7b504;hp=16aaf31e1c5bcc5d20806fcb7d1ceab9b54f711d;hb=6c5467571389a21c91196ce1608945633c1cf92a;hpb=2cb08a89ee65d8ae2646b91dcf27bc3883759691 diff --git a/rset/rset.c b/rset/rset.c index 16aaf31..3da4bd6 100644 --- a/rset/rset.c +++ b/rset/rset.c @@ -1,8 +1,5 @@ -/* $Id: rset.c,v 1.46 2005-05-24 11:35:43 adam Exp $ - Copyright (C) 1995-2005 - Index Data ApS - -This file is part of the Zebra server. +/* This file is part of the Zebra server. + Copyright (C) 1994-2011 Index Data Zebra is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free @@ -15,11 +12,14 @@ FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License -along with Zebra; see the file LICENSE.zebra. If not, write to the -Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA -02111-1307, USA. +along with this program; if not, write to the Free Software +Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ +#if HAVE_CONFIG_H +#include +#endif #include #include #include @@ -30,13 +30,16 @@ Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA static int log_level = 0; static int log_level_initialized = 0; -/** \fn rfd_create_base(RSET rs) - * - * creates an rfd. Either allocates a new one, in which case the priv - * pointer is null, and will have to be filled in, or picks up one - * from the freelist, in which case the priv is already allocated, - * and presumably everything that hangs from it as well - */ + +/** + \brief Common constuctor for RFDs + \param rs Result set handle. + + Creates an rfd. Either allocates a new one, in which case the priv + pointer is null, and will have to be filled in, or picks up one + from the freelist, in which case the priv is already allocated, + and presumably everything that hangs from it as well +*/ RSFD rfd_create_base(RSET rs) { RSFD rnew = rs->free_list; @@ -63,26 +66,54 @@ RSFD rfd_create_base(RSET rs) return rnew; } -/** \fn rfd_delete_base - * - * puts an rfd into the freelist of the rset. Only when the rset gets - * deleted, will all the nmem disappear */ -void rset_close(RSFD rfd) +static void rset_close_int(RSET rs, RSFD rfd) { RSFD *pfd; + (*rs->control->f_close)(rfd); + + yaz_log(log_level, "rfd_delete_base: rfd=%p rs=%p priv=%p fl=%p", + rfd, rs, rfd->priv, rs->free_list); + for (pfd = &rs->use_list; *pfd; pfd = &(*pfd)->next) + if (*pfd == rfd) + { + *pfd = (*pfd)->next; + rfd->next = rs->free_list; + rs->free_list = rfd; + return; + } + yaz_log(YLOG_WARN, "rset_close handle not found. type=%s", + rs->control->desc); +} + +void rset_set_hits_limit(RSET rs, zint l) +{ + yaz_log(log_level, "rset_set_hits_limit %p l=" ZINT_FORMAT, rs, l); + rs->hits_limit = l; +} + +/** + \brief Closes a result set RFD handle + \param rfd the RFD handle. +*/ +void rset_close(RSFD rfd) +{ RSET rs = rfd->rset; if (rs->hits_count == 0) { TERMID termid; char buf[100]; - while(rfd->counted_items < rs->hits_limit + + while (rfd->counted_items <= rs->hits_limit && rset_default_read(rfd, buf, &termid)) ; rs->hits_count = rfd->counted_items; + yaz_log(log_level, "rset_close rset=%p hits_count=" ZINT_FORMAT + " hits_limit=" ZINT_FORMAT, + rs, rs->hits_count, rs->hits_limit); rs->hits_approx = 0; - if (rs->hits_count >= rs->hits_limit) + if (rs->hits_count > rs->hits_limit && rs->hits_limit > 0) { double cur, tot; zint est; @@ -108,65 +139,64 @@ void rset_close(RSFD rfd) rs->hits_approx = 1; } } - yaz_log(log_level, "rset_close p=%p count=" ZINT_FORMAT, rs, + yaz_log(log_level, "rset_close(%s) p=%p count=" ZINT_FORMAT, + rs->control->desc, rs, rs->hits_count); } - (*rs->control->f_close)(rfd); - - yaz_log(log_level, "rfd_delete_base: rfd=%p rs=%p priv=%p fl=%p", - rfd, rs, rfd->priv, rs->free_list); - for (pfd = &rs->use_list; *pfd; pfd = &(*pfd)->next) - if (*pfd == rfd) - { - *pfd = (*pfd)->next; - rfd->next = rs->free_list; - rs->free_list = rfd; - return; - } - yaz_log(YLOG_WARN, "rset_close handle not found. type=%s", - rs->control->desc); + rset_close_int(rs, rfd); } +/** + \brief Common constuctor for RSETs + \param sel The interface control handle + \param nmem The memory handle for it. + \param kcontrol Key control info (decode, encode, comparison etc) + \param scope scope for set + \param term Information about term for it (NULL for none). + \param no_children number of child rsets (0 for none) + \param children child rsets (NULL for none). + + Creates an rfd. Either allocates a new one, in which case the priv + pointer is null, and will have to be filled in, or picks up one + from the freelist, in which case the priv is already allocated, + and presumably everything that hangs from it as well +*/ RSET rset_create_base(const struct rset_control *sel, NMEM nmem, struct rset_key_control *kcontrol, int scope, TERMID term, int no_children, RSET *children) { RSET rset; - NMEM M; - assert(nmem); /* can not yet be used, api/t4 fails */ + assert(nmem); if (!log_level_initialized) { log_level = yaz_log_module_level("rset"); log_level_initialized = 1; } - if (nmem) - M = nmem; - else - M = nmem_create(); - rset = (RSET) nmem_malloc(M, sizeof(*rset)); + rset = (RSET) nmem_malloc(nmem, sizeof(*rset)); yaz_log(log_level, "rs_create(%s) rs=%p (nm=%p)", sel->desc, rset, nmem); - rset->nmem = M; - if (nmem) - rset->my_nmem = 0; - else - rset->my_nmem = 1; + yaz_log(log_level, " ref_id=%s", + (term && term->ref_id ? term->ref_id : "null")); + rset->nmem = nmem; rset->control = sel; rset->refcount = 1; rset->priv = 0; rset->free_list = NULL; rset->use_list = NULL; rset->hits_count = 0; - rset->hits_limit = 1000; + rset->hits_limit = 0; rset->hits_round = 1000; rset->keycontrol = kcontrol; + (*kcontrol->inc)(kcontrol); rset->scope = scope; rset->term = term; if (term) + { term->rset = rset; - + rset->hits_limit = term->hits_limit; + } rset->no_children = no_children; rset->children = 0; if (no_children) @@ -178,6 +208,13 @@ RSET rset_create_base(const struct rset_control *sel, return rset; } +/** + \brief Destructor RSETs + \param rs Handle for result set. + + Destroys a result set and all its children. + The f_delete method of control is called for the result set. +*/ void rset_delete(RSET rs) { (rs->refcount)--; @@ -193,11 +230,15 @@ void rset_delete(RSET rs) rset_delete(rs->children[i]); (*rs->control->f_delete)(rs); (*rs->keycontrol->dec)(rs->keycontrol); - if (rs->my_nmem) - nmem_destroy(rs->nmem); } } +/** + \brief Test for last use of RFD + \param rfd RFD handle. + + Returns 1 if this RFD is the last reference to it; 0 otherwise. +*/ int rfd_is_last(RSFD rfd) { if (rfd->rset->use_list == rfd && rfd->next == 0) @@ -205,50 +246,101 @@ int rfd_is_last(RSFD rfd) return 0; } +/** + \brief Duplicate an RSET + \param rs Handle for result set. + + Duplicates a result set by incrementing the reference count to it. +*/ RSET rset_dup (RSET rs) { (rs->refcount)++; yaz_log(log_level, "rs_dup(%s), rs=%p, refcount=%d", rs->control->desc, rs, rs->refcount); - (*rs->keycontrol->inc)(rs->keycontrol); return rs; } /** - * rset_count uses rset_pos to get the total and returns that. - * This is ok for rsisamb/c/s, and for some other rsets, but in case of - * booleans etc it will give bad estimate, as nothing has been read - * from that rset - */ + \brief Estimates hit count for result set. + \param rs Result Set. + + rset_count uses rset_pos to get the total and returns that. + This is ok for rsisamb/c/s, and for some other rsets, but in case of + booleans etc it will give bad estimate, as nothing has been read + from that rset +*/ zint rset_count(RSET rs) { double cur, tot; RSFD rfd = rset_open(rs, 0); rset_pos(rfd, &cur, &tot); - rset_close(rfd); + rset_close_int(rs, rfd); return (zint) tot; } -/** rset_get_no_terms is a getterms function for those that don't have any */ -void rset_get_no_terms(RSET ct, TERMID *terms, int maxterms, int *curterm) -{ - return; -} +/** + \brief is a getterms function for those that don't have any + \param ct result set handle + \param terms array of terms (0..maxterms-1) + \param maxterms length of terms array + \param curterm current size of terms array -/* rset_get_one_term gets that one term from an rset. Used by rsisamX */ + If there is a term associated with rset the term is appeneded; otherwise + the terms array is untouched but curterm is incremented anyway. +*/ void rset_get_one_term(RSET ct, TERMID *terms, int maxterms, int *curterm) { if (ct->term) { if (*curterm < maxterms) terms[*curterm] = ct->term; - (*curterm)++; + (*curterm)++; } } +struct ord_list *ord_list_create(NMEM nmem) +{ + return 0; +} + +struct ord_list *ord_list_append(NMEM nmem, struct ord_list *list, + int ord) +{ + struct ord_list *n = nmem_malloc(nmem, sizeof(*n)); + n->ord = ord; + n->next = list; + return n; +} + +struct ord_list *ord_list_dup(NMEM nmem, struct ord_list *list) +{ + struct ord_list *n = ord_list_create(nmem); + for (; list; list = list->next) + n = ord_list_append(nmem, n, list->ord); + return n; +} +void ord_list_print(struct ord_list *list) +{ + for (; list; list = list->next) + yaz_log(YLOG_LOG, "ord_list %d", list->ord); +} +/** + \brief Creates a TERMID entry. + \param name Term/Name buffer with given length + \param length of term + \param flags for term + \param type Term Type, Z_Term_general, Z_Term_characterString,.. + \param nmem memory for term. + \param ol ord list + \param reg_type register type + \param hits_limit limit before counting stops and gets approximate + \param ref_id supplied ID for term that can be used to identify this +*/ TERMID rset_term_create(const char *name, int length, const char *flags, - int type, NMEM nmem) + int type, NMEM nmem, struct ord_list *ol, + int reg_type, + zint hits_limit, const char *ref_id) { TERMID t; @@ -260,18 +352,21 @@ TERMID rset_term_create(const char *name, int length, const char *flags, else if (length == -1) t->name = nmem_strdup(nmem, name); else - { - t->name = (char*) nmem_malloc(nmem, length+1); - memcpy (t->name, name, length); - t->name[length] = '\0'; - } + t->name = nmem_strdupn(nmem, name, length); + if (!ref_id) + t->ref_id = 0; + else + t->ref_id = nmem_strdup(nmem, ref_id); if (!flags) t->flags = NULL; else t->flags = nmem_strdup(nmem, flags); + t->hits_limit = hits_limit; t->type = type; + t->reg_type = reg_type; t->rankpriv = 0; t->rset = 0; + t->ol = ord_list_dup(nmem, ol); return t; } @@ -281,8 +376,17 @@ int rset_default_read(RSFD rfd, void *buf, TERMID *term) int rc = (*rset->control->f_read)(rfd, buf, term); if (rc > 0) { - if (rfd->counted_items == 0 || - (rset->keycontrol->cmp)(buf, rfd->counted_buf) >= rset->scope) + int got_scope; + if (rfd->counted_items == 0) + got_scope = rset->scope+1; + else + got_scope = rset->keycontrol->cmp(buf, rfd->counted_buf); + +#if 0 + key_logdump_txt(YLOG_LOG, buf, "rset_default_read"); + yaz_log(YLOG_LOG, "rset_scope=%d got_scope=%d", rset->scope, got_scope); +#endif + if (got_scope > rset->scope) { memcpy(rfd->counted_buf, buf, rset->keycontrol->key_size); rfd->counted_items++; @@ -306,12 +410,12 @@ int rset_default_forward(RSFD rfd, void *buf, TERMID *term, while ((more = rset_read(rfd, buf, term)) > 0) { - if ((rfd->rset->keycontrol->cmp)(untilbuf, buf) <= 1) + if ((rfd->rset->keycontrol->cmp)(untilbuf, buf) < rset->scope) break; } if (log_level) - yaz_log (log_level, "rset_default_forward exiting m=%d c=%d", - more, rset->scope); + yaz_log(log_level, "rset_default_forward exiting rfd=%p scope=%d m=%d c=%d", + rfd, rset->scope, more, rset->scope); return more; } @@ -326,3 +430,12 @@ void rset_visit(RSET rset, int level) rset_visit(rset->children[i], level+1); } +/* + * Local variables: + * c-basic-offset: 4 + * c-file-style: "Stroustrup" + * indent-tabs-mode: nil + * End: + * vim: shiftwidth=4 tabstop=8 expandtab + */ +