rset.c

Go to the documentation of this file.

/* This file is part of the Zebra server.
   Copyright (C) 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
Software Foundation; either version 2, or (at your option) any later
version.
 
Zebra is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
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 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 <config.h>
#endif
#include <stdio.h>
#include <string.h>
#include <idzebra/util.h>
#include <assert.h>
#include <yaz/nmem.h>
#include <rset.h>
 
static int log_level = 0;
static int log_level_initialized = 0;
 
 
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->counted_buf = nmem_malloc(rs->nmem, rs->keycontrol->key_size);
        rnew->priv = 0;
        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;
    rnew->counted_items = 0;
    return rnew;
}
 
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;
}
 
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
              && 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 && rs->hits_limit > 0)
        {
            double cur, tot;
            zint est;
            rset_pos(rfd, &cur, &tot);
            if (tot > 0) {
                int i;
                double ratio = cur/tot;
                est = (zint)(0.5 + rs->hits_count / ratio);
                yaz_log(log_level, "Estimating hits (%s) "
                        "%0.1f->" ZINT_FORMAT
                        "; %0.1f->" ZINT_FORMAT,
                        rs->control->desc,
                        cur, rs->hits_count,
                        tot, est);
                i = 0; /* round to significant digits */
                while (est > rs->hits_round) {
                    est /= 10;
                    i++;
                }
                while (i--)
                    est *= 10;
                rs->hits_count = est;
                rs->hits_approx = 1;
            }
        }
        yaz_log(log_level, "rset_close(%s) p=%p count=" ZINT_FORMAT,
                rs->control->desc, rs,
                rs->hits_count);
    }
    rset_close_int(rs, rfd);
}
 
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;
    assert(nmem);
    if (!log_level_initialized)
    {
        log_level = yaz_log_module_level("rset");
        log_level_initialized = 1;
    }
 
    rset = (RSET) nmem_malloc(nmem, sizeof(*rset));
    yaz_log(log_level, "rs_create(%s) rs=%p (nm=%p)", sel->desc, rset, nmem);
    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 = 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)
    {
        rset->children = (RSET*)
            nmem_malloc(rset->nmem, no_children*sizeof(RSET *));
        memcpy(rset->children, children, no_children*sizeof(RSET *));
    }
    return rset;
}
 
void rset_delete(RSET rs)
{
    (rs->refcount)--;
    yaz_log(log_level, "rs_delete(%s), rs=%p, refcount=%d",
            rs->control->desc, rs, rs->refcount);
    if (!rs->refcount)
    {
        int i;
        if (rs->use_list)
            yaz_log(YLOG_WARN, "rs_delete(%s) still has RFDs in use",
                    rs->control->desc);
        for (i = 0; i<rs->no_children; i++)
            rset_delete(rs->children[i]);
        (*rs->control->f_delete)(rs);
        (*rs->keycontrol->dec)(rs->keycontrol);
    }
}
 
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->refcount)++;
    yaz_log(log_level, "rs_dup(%s), rs=%p, refcount=%d",
            rs->control->desc, rs, rs->refcount);
    return rs;
}
 
zint rset_count(RSET rs)
{
    double cur, tot;
    RSFD rfd = rset_open(rs, 0);
    rset_pos(rfd, &cur, &tot);
    rset_close_int(rs, rfd);
    return (zint) tot;
}
 
void rset_get_one_term(RSET ct, TERMID *terms, int maxterms, int *curterm)
{
    if (ct->term)
    {
        if (*curterm < maxterms)
            terms[*curterm] = ct->term;
        (*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);
}
TERMID rset_term_create(const char *name, int length, const char *flags,
                        int type, NMEM nmem, struct ord_list *ol,
                        int reg_type,
                        zint hits_limit, const char *ref_id)
 
{
    TERMID t = (TERMID) nmem_malloc(nmem, sizeof(*t));
 
    if (!name)
        name = "";
    if (length == -1)
        t->name = nmem_strdup(nmem, name);
    else
        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;
}
 
int rset_default_read(RSFD rfd, void *buf, TERMID *term)
{
    RSET rset = rfd->rset;
    int rc = (*rset->control->f_read)(rfd, buf, term);
    if (rc > 0)
    {
        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++;
        }
    }
    return rc;
}
 
int rset_default_forward(RSFD rfd, void *buf, TERMID *term,
                         const void *untilbuf)
{
    RSET rset = rfd->rset;
    int more;
 
    if (rset->control->f_forward &&
        rfd->counted_items >= rset->hits_limit)
    {
        assert (rset->control->f_forward != rset_default_forward);
        return rset->control->f_forward(rfd, buf, term, untilbuf);
    }
 
    while ((more = rset_read(rfd, buf, term)) > 0)
    {
        if ((rfd->rset->keycontrol->cmp)(untilbuf, buf) < rset->scope)
            break;
    }
    if (log_level)
        yaz_log(log_level, "rset_default_forward exiting rfd=%p scope=%d m=%d c=%d",
                rfd, rset->scope, more, rset->scope);
 
    return more;
}
 
void rset_visit(RSET rset, int level)
{
    int i;
    yaz_log(YLOG_LOG, "%*s%c " ZINT_FORMAT, level, "",
            rset->hits_approx ? '~' : '=',
            rset->hits_count);
    for (i = 0; i<rset->no_children; i++)
        rset_visit(rset->children[i], level+1);
}
 
int rset_no_write(RSFD rfd, const void *buf)
{
    yaz_log(YLOG_FATAL, "%s set type is read-only", rfd->rset->control->desc);
    return -1;
}
 
/*
 * Local variables:
 * c-basic-offset: 4
 * c-file-style: "Stroustrup"
 * indent-tabs-mode: nil
 * End:
 * vim: shiftwidth=4 tabstop=8 expandtab
 */