X-Git-Url: http://git.indexdata.com/?a=blobdiff_plain;f=rset%2Frset.c;h=26ba709bc9d6cfc9b1599be9ec6054a1b6b3f578;hb=ecf94fc25324414287d3bbfbeba4440e558edd17;hp=a89191e5bb2696eb9028a65639c725ff2e6fcd33;hpb=2a6f64379961f30bfe6376964ce279ab5242da1f;p=idzebra-moved-to-github.git diff --git a/rset/rset.c b/rset/rset.c index a89191e..26ba709 100644 --- a/rset/rset.c +++ b/rset/rset.c @@ -1,6 +1,6 @@ -/* $Id: rset.c,v 1.19 2004-01-22 11:27:22 adam Exp $ - Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004 - Index Data Aps +/* $Id: rset.c,v 1.44 2005-03-30 09:25:24 adam Exp $ + Copyright (C) 1995-2005 + Index Data ApS This file is part of the Zebra server. @@ -20,103 +20,222 @@ Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ - - #include #include -#include - +#include +#include +#include #include -RSET rset_create(const struct rset_control *sel, void *parms) +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 + */ +RSFD rfd_create_base(RSET rs) +{ + RSFD rnew = rs->free_list; + + if (rnew) + { + rs->free_list = rnew->next; + assert(rnew->rset==rs); + yaz_log(log_level, "rfd_create_base (fl): rfd=%p rs=%p fl=%p priv=%p", + rnew, rs, rs->free_list, rnew->priv); + } + else + { + rnew = nmem_malloc(rs->nmem, sizeof(*rnew)); + rnew->priv = NULL; + rnew->rset = rs; + yaz_log(log_level, "rfd_create_base (new): rfd=%p rs=%p fl=%p priv=%p", + rnew, rs, rs->free_list, rnew->priv); + } + rnew->next = rs->use_list; + rs->use_list = rnew; + 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 rfd_delete_base(RSFD rfd) +{ + RSFD *pfd; + RSET rs = rfd->rset; + 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 rset_create_base(const struct rset_control *sel, + NMEM nmem, const struct key_control *kcontrol, + int scope, TERMID term) { RSET rnew; - int i; + NMEM M; + /* assert(nmem); */ /* can not yet be used, api/t4 fails */ + if (!log_level_initialized) + { + log_level = yaz_log_module_level("rset"); + log_level_initialized = 1; + } - logf (LOG_DEBUG, "rs_create(%s)", sel->desc); - rnew = (RSET) xmalloc(sizeof(*rnew)); + if (nmem) + M = nmem; + else + M = nmem_create(); + rnew = (RSET) nmem_malloc(M, sizeof(*rnew)); + yaz_log(log_level, "rs_create(%s) rs=%p (nm=%p)", sel->desc, rnew, nmem); + rnew->nmem = M; + if (nmem) + rnew->my_nmem = 0; + else + rnew->my_nmem = 1; rnew->control = sel; - rnew->flags = 0; - rnew->count = 1; - rnew->rset_terms = NULL; - rnew->no_rset_terms = 0; - rnew->buf = (*sel->f_create)(rnew, sel, parms); - logf (LOG_DEBUG, "no_rset_terms: %d", rnew->no_rset_terms); - for (i = 0; ino_rset_terms; i++) - logf (LOG_DEBUG, " %s", rnew->rset_terms[i]->name); + rnew->count = 1; /* refcount! */ + rnew->priv = 0; + rnew->free_list = NULL; + rnew->use_list = NULL; + rnew->keycontrol = kcontrol; + rnew->scope = scope; + rnew->term = term; + if (term) + term->rset = rnew; return rnew; } void rset_delete (RSET rs) { (rs->count)--; + yaz_log(log_level, "rs_delete(%s), rs=%p, count=%d", + rs->control->desc, rs, rs->count); if (!rs->count) { - (*rs->control->f_delete)(rs); - xfree(rs); + if (rs->use_list) + yaz_log(YLOG_WARN, "rs_delete(%s) still has RFDs in use", + rs->control->desc); + (*rs->control->f_delete)(rs); + if (rs->my_nmem) + nmem_destroy(rs->nmem); } } +int rfd_is_last(RSFD rfd) +{ + if (rfd->rset->use_list == rfd && rfd->next == 0) + return 1; + return 0; +} + RSET rset_dup (RSET rs) { (rs->count)++; + yaz_log(log_level, "rs_dup(%s), rs=%p, count=%d", + rs->control->desc, rs, rs->count); return rs; } -int rset_default_forward(RSFD rfd, void *buf, const void *untilbuf) +int rset_default_forward(RSFD rfd, void *buf, TERMID *term, + const void *untilbuf) { - logf (LOG_FATAL, "rset_default-forward not yet implemented"); - return 0; + int more = 1; + int cmp = rfd->rset->scope; + if (log_level) + { + yaz_log (log_level, "rset_default_forward starting '%s' (ct=%p rfd=%p)", + rfd->rset->control->desc, rfd->rset, rfd); + /* key_logdump(log_level, untilbuf); */ + } + while (cmp>=rfd->rset->scope && more) + { + if (log_level) /* time-critical, check first */ + yaz_log(log_level, "rset_default_forward looping m=%d c=%d", + more, cmp); + more = rset_read(rfd, buf, term); + if (more) + cmp = (rfd->rset->keycontrol->cmp)(untilbuf, buf); + } + if (log_level) + yaz_log (log_level, "rset_default_forward exiting m=%d c=%d", + more, cmp); + + return more; +} + +/** + * 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); + return (zint) tot; } -RSET_TERM *rset_terms(RSET rs, int *no) + +/** 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) { - *no = rs->no_rset_terms; - return rs->rset_terms; + return; } -RSET_TERM rset_term_create (const char *name, int length, const char *flags, - int type) +/* rset_get_one_term gets that one term from an rset. Used by rsisamX */ +void rset_get_one_term(RSET ct,TERMID *terms,int maxterms,int *curterm) { - RSET_TERM t = (RSET_TERM) xmalloc (sizeof(*t)); + if (ct->term) + { + if (*curterm < maxterms) + terms[*curterm] = ct->term; + (*curterm)++; + } +} + + +TERMID rset_term_create (const char *name, int length, const char *flags, + int type, NMEM nmem) + +{ + TERMID t; + yaz_log (log_level, "term_create '%s' %d f=%s type=%d nmem=%p", + name, length, flags, type, nmem); + t= (TERMID) nmem_malloc(nmem, sizeof(*t)); if (!name) - t->name = NULL; + t->name = NULL; else if (length == -1) - t->name = xstrdup (name); + t->name = nmem_strdup(nmem, name); else { - t->name = (char*) xmalloc (length+1); - memcpy (t->name, name, length); - t->name[length] = '\0'; + t->name = (char*) nmem_malloc(nmem, length+1); + memcpy (t->name, name, length); + t->name[length] = '\0'; } if (!flags) - t->flags = NULL; + t->flags = NULL; else - t->flags = xstrdup (flags); - t->nn = -1; - t->count = 0; + t->flags = nmem_strdup(nmem, flags); t->type = type; + t->rankpriv = 0; + t->rset = 0; return t; } - -void rset_term_destroy (RSET_TERM t) -{ - xfree (t->name); - xfree (t->flags); - xfree (t); -} - -RSET_TERM rset_term_dup (RSET_TERM t) -{ - RSET_TERM nt = (RSET_TERM) xmalloc (sizeof(*nt)); - if (t->name) - nt->name = xstrdup (t->name); - else - nt->name = NULL; - if (t->flags) - nt->flags = xstrdup (t->flags); - else - nt->flags = NULL; - nt->nn = t->nn; - return nt; -}