From 7887042844aef0c6f3d2b711e315abe91c26d211 Mon Sep 17 00:00:00 2001 From: Heikki Levanto Date: Mon, 16 Aug 2004 16:17:49 +0000 Subject: [PATCH] Added skeleton for multior - not at all functional yet. Call to it implemented, but #ifdef'd out --- include/rsmultior.h | 50 +++++++ index/trunc.c | 30 ++++- rset/Makefile.am | 4 +- rset/rsm_or.c | 4 +- rset/rsmultior.c | 361 +++++++++++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 442 insertions(+), 7 deletions(-) create mode 100644 include/rsmultior.h create mode 100644 rset/rsmultior.c diff --git a/include/rsmultior.h b/include/rsmultior.h new file mode 100644 index 0000000..ff8c3ad --- /dev/null +++ b/include/rsmultior.h @@ -0,0 +1,50 @@ +/* $Id: rsmultior.h,v 1.1 2004-08-16 16:17:49 heikki Exp $ + Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004 + Index Data Aps + +This file is part of the Zebra server. + +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 Zebra; see the file LICENSE.zebra. If not, write to the +Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA +02111-1307, USA. +*/ + + + +#ifndef RSET_MULTIOR_H +#define RSET_MULTIOR_H + +#include + +YAZ_BEGIN_CDECL + +extern const struct rset_control *rset_kind_multior; + +typedef struct rset_multior_parms +{ + int key_size; + int (*cmp)(const void *p1, const void *p2); + + RSET *rsets; + int no_rsets; + + RSET_TERM rset_term; + + int no_isam_positions; + int no_save_positions; +} rset_multior_parms; + +YAZ_END_CDECL + +#endif diff --git a/index/trunc.c b/index/trunc.c index 689415c..f13f1d9 100644 --- a/index/trunc.c +++ b/index/trunc.c @@ -1,4 +1,4 @@ -/* $Id: trunc.c,v 1.33 2004-08-11 13:35:04 adam Exp $ +/* $Id: trunc.c,v 1.34 2004-08-16 16:17:49 heikki Exp $ Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004 Index Data Aps @@ -35,6 +35,7 @@ Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA #if NEW_TRUNC #include #endif +#include struct trunc_info { int *ptr; @@ -469,15 +470,38 @@ RSET rset_trunc (ZebraHandle zi, ISAMS_P *isam_p, int no, if (no == 1) { rset_isamb_parms parms; - parms.key_size = sizeof(struct it_key); parms.cmp = key_compare_it; parms.pos = *isam_p; parms.is = zi->reg->isamb; - parms.rset_term = rset_term_create (term, length, flags, + parms.rset_term = rset_term_create (term, length, flags, term_type); return rset_create (rset_kind_isamb, &parms); } +#if 0 + else if (no <10000 ) /* FIXME - hardcoded number */ + { + rset_multior_parms m_parms; + rset_isamb_parms b_parms; + int i; + m_parms.key_size = sizeof(struct it_key); + m_parms.cmp = key_compare_it; + m_parms.no_rsets=no; + m_parms.rsets=xmalloc(sizeof(*m_parms.rsets)*no); + m_parms.rset_term = rset_term_create (term, length, flags, + term_type); + b_parms.key_size = sizeof(struct it_key); + b_parms.cmp = key_compare_it; + b_parms.is = zi->reg->isamb; + b_parms.rset_term = m_parms.rset_term; + for (i=0;i +#include +#include +#include + +#include +#include +#include + +static void *r_create(RSET ct, const struct rset_control *sel, void *parms); +static RSFD r_open (RSET ct, int flag); +static void r_close (RSFD rfd); +static void r_delete (RSET ct); +static void r_rewind (RSFD rfd); +static int r_read (RSFD rfd, void *buf, int *term_index); +static int r_write (RSFD rfd, const void *buf); + +static const struct rset_control control = +{ + "multi-or", + r_create, + r_open, + r_close, + r_delete, + r_rewind, + rset_default_forward, /* FIXME */ + rset_default_pos, /* FIXME */ + r_read, + r_write, +}; + +const struct rset_control *rset_kind_multior = &control; + +struct rset_multior_info { + int key_size; + int no_rec; + int (*cmp)(const void *p1, const void *p2); + ISAMC isc; + ISAMC_P *isam_positions; + + int no_isam_positions; + int no_save_positions; + struct rset_mor_rfd *rfd_list; +}; + + +struct rset_multior_rfd { + int flag; + int position; + int position_max; +/* ISAMC_PP *ispt; */ + struct rset_mor_rfd *next; + struct rset_mor_info *info; + struct trunc_info *ti; + zint *countp; + char *pbuf; +}; + +#if 0 +static void heap_swap (struct trunc_info *ti, int i1, int i2) +{ + int swap; + + swap = ti->ptr[i1]; + ti->ptr[i1] = ti->ptr[i2]; + ti->ptr[i2] = swap; +} + +static void heap_delete (struct trunc_info *ti) +{ + int cur = 1, child = 2; + + heap_swap (ti, 1, ti->heapnum--); + while (child <= ti->heapnum) { + if (child < ti->heapnum && + (*ti->cmp)(ti->heap[ti->ptr[child]], + ti->heap[ti->ptr[1+child]]) > 0) + child++; + if ((*ti->cmp)(ti->heap[ti->ptr[cur]], + ti->heap[ti->ptr[child]]) > 0) + { + heap_swap (ti, cur, child); + cur = child; + child = 2*cur; + } + else + break; + } +} + +static void heap_insert (struct trunc_info *ti, const char *buf, int indx) +{ + int cur, parent; + + cur = ++(ti->heapnum); + memcpy (ti->heap[ti->ptr[cur]], buf, ti->keysize); + ti->indx[ti->ptr[cur]] = indx; + parent = cur/2; + while (parent && (*ti->cmp)(ti->heap[ti->ptr[parent]], + ti->heap[ti->ptr[cur]]) > 0) + { + heap_swap (ti, cur, parent); + cur = parent; + parent = cur/2; + } +} + +static +struct trunc_info *heap_init (int size, int key_size, + int (*cmp)(const void *p1, const void *p2)) +{ + struct trunc_info *ti = (struct trunc_info *) xmalloc (sizeof(*ti)); + int i; + + ++size; + ti->heapnum = 0; + ti->keysize = key_size; + ti->cmp = cmp; + ti->indx = (int *) xmalloc (size * sizeof(*ti->indx)); + ti->heap = (char **) xmalloc (size * sizeof(*ti->heap)); + ti->ptr = (int *) xmalloc (size * sizeof(*ti->ptr)); + ti->swapbuf = (char *) xmalloc (ti->keysize); + ti->tmpbuf = (char *) xmalloc (ti->keysize); + ti->buf = (char *) xmalloc (size * ti->keysize); + for (i = size; --i >= 0; ) + { + ti->ptr[i] = i; + ti->heap[i] = ti->buf + ti->keysize * i; + } + return ti; +} + +static void heap_close (struct trunc_info *ti) +{ + xfree (ti->buf); + xfree (ti->ptr); + xfree (ti->indx); + xfree (ti->heap); + xfree (ti->swapbuf); + xfree (ti->tmpbuf); + xfree (ti); +} + +#endif +static void *r_create (RSET ct, const struct rset_control *sel, void *parms) +{ + return 0; +/* + rset_multior_parms *r_parms = (rset_multior_parms *) parms; + struct rset_mor_info *info; + + ct->flags |= RSET_FLAG_VOLATILE; + info = (struct rset_mor_info *) xmalloc (sizeof(*info)); + info->key_size = r_parms->key_size; + assert (info->key_size > 1); + info->cmp = r_parms->cmp; + + info->no_save_positions = r_parms->no_save_positions; + + info->isc = r_parms->isc; + info->no_isam_positions = r_parms->no_isam_positions; + info->isam_positions = (ISAMC_P *) + xmalloc (sizeof(*info->isam_positions) * info->no_isam_positions); + memcpy (info->isam_positions, r_parms->isam_positions, + sizeof(*info->isam_positions) * info->no_isam_positions); + info->rfd_list = NULL; + + ct->no_rset_terms = 1; + ct->rset_terms = (RSET_TERM *) xmalloc (sizeof(*ct->rset_terms)); + ct->rset_terms[0] = r_parms->rset_term; + return info; + */ +} + +static RSFD r_open (RSET ct, int flag) +{ + return 0; + /* + struct rset_mor_rfd *rfd; + struct rset_mor_info *info = (struct rset_mor_info *) ct->buf; + int i; + + if (flag & RSETF_WRITE) + { + logf (LOG_FATAL, "m_or set type is read-only"); + return NULL; + } + rfd = (struct rset_mor_rfd *) xmalloc (sizeof(*rfd)); + rfd->flag = flag; + rfd->next = info->rfd_list; + rfd->info = info; + info->rfd_list = rfd; + + rfd->ispt = (ISAMC_PP *) + xmalloc (sizeof(*rfd->ispt) * info->no_isam_positions); + + rfd->ti = heap_init (info->no_isam_positions, info->key_size, info->cmp); + + ct->rset_terms[0]->nn = 0; + for (i = 0; ino_isam_positions; i++) + { + rfd->ispt[i] = isc_pp_open (info->isc, info->isam_positions[i]); + + ct->rset_terms[0]->nn += isc_pp_num (rfd->ispt[i]); + + if (isc_pp_read (rfd->ispt[i], rfd->ti->tmpbuf)) + heap_insert (rfd->ti, rfd->ti->tmpbuf, i); + else + { + isc_pp_close (rfd->ispt[i]); + rfd->ispt[i] = NULL; + } + } + rfd->position = info->no_save_positions; + + if (ct->no_rset_terms == 1) + rfd->countp = &ct->rset_terms[0]->count; + else + rfd->countp = 0; + rfd->pbuf = xmalloc (info->key_size); + + r_rewind (rfd); + return rfd; + */ +} + +static void r_close (RSFD rfd) +{ + /* + struct rset_mor_info *info = ((struct rset_mor_rfd*)rfd)->info; + struct rset_mor_rfd **rfdp; + int i; + + for (rfdp = &info->rfd_list; *rfdp; rfdp = &(*rfdp)->next) + if (*rfdp == rfd) + { + *rfdp = (*rfdp)->next; + + heap_close (((struct rset_mor_rfd *) rfd)->ti); + for (i = 0; ino_isam_positions; i++) + if (((struct rset_mor_rfd *) rfd)->ispt[i]) + isc_pp_close (((struct rset_mor_rfd *) rfd)->ispt[i]); + xfree (((struct rset_mor_rfd *)rfd)->ispt); + xfree (((struct rset_mor_rfd *)rfd)->pbuf); + xfree (rfd); + return; + } + logf (LOG_FATAL, "r_close but no rfd match!"); + assert (0); + */ +} + +static void r_delete (RSET ct) +{ + /* + struct rset_mor_info *info = (struct rset_mor_info *) ct->buf; + int i; + + assert (info->rfd_list == NULL); + xfree (info->isam_positions); + + for (i = 0; ino_rset_terms; i++) + rset_term_destroy (ct->rset_terms[i]); + */ /* FIXME - Watch out! */ + /* + xfree (ct->rset_terms); + + xfree (info); + */ +} + +static void r_rewind (RSFD rfd) +{ +} + + +static int r_read (RSFD rfd, void *buf, int *term_index) +{ + return 0; + /* + struct rset_mor_rfd *mrfd = (struct rset_mor_rfd *) rfd; + struct trunc_info *ti = mrfd->ti; + int n = ti->indx[ti->ptr[1]]; + + if (!ti->heapnum) + return 0; + *term_index = 0; + memcpy (buf, ti->heap[ti->ptr[1]], ti->keysize); + if (((struct rset_mor_rfd *) rfd)->position) + { + if (isc_pp_read (((struct rset_mor_rfd *) rfd)->ispt[n], ti->tmpbuf)) + { + heap_delete (ti); + if ((*ti->cmp)(ti->tmpbuf, ti->heap[ti->ptr[1]]) > 1) + ((struct rset_mor_rfd *) rfd)->position--; + heap_insert (ti, ti->tmpbuf, n); + } + else + heap_delete (ti); + if (mrfd->countp && ( + *mrfd->countp == 0 || (*ti->cmp)(buf, mrfd->pbuf) > 1)) + { + memcpy (mrfd->pbuf, buf, ti->keysize); + (*mrfd->countp)++; + } + return 1; + } + while (1) + { + if (!isc_pp_read (((struct rset_mor_rfd *) rfd)->ispt[n], ti->tmpbuf)) + { + heap_delete (ti); + break; + } + if ((*ti->cmp)(ti->tmpbuf, ti->heap[ti->ptr[1]]) > 1) + { + heap_delete (ti); + heap_insert (ti, ti->tmpbuf, n); + break; + } + } + if (mrfd->countp && ( + *mrfd->countp == 0 || (*ti->cmp)(buf, mrfd->pbuf) > 1)) + { + memcpy (mrfd->pbuf, buf, ti->keysize); + (*mrfd->countp)++; + } + return 1; + */ +} + +static int r_write (RSFD rfd, const void *buf) +{ + logf (LOG_FATAL, "mor set type is read-only"); + return -1; +} -- 1.7.10.4