-/* $Id: rset.h,v 1.36 2004-09-30 13:07:06 heikki Exp $
+/* $Id: rset.h,v 1.37 2004-10-15 10:07:32 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002
Index Data Aps
typedef struct rsfd *RSFD; /* Rset "file descriptor" */
typedef struct rset *RSET; /* Result set */
+/*
+typedef struct terminfo *TERMID;
+*/
+typedef int TERMID;
+ /* term thing for the rsets. They don't need to */
+ /* know what it is. FIXME - define that somewhere */
+/* using int while testing, to get more type checking to work */
+
struct rsfd { /* the stuff common to all rsfd's. */
RSET rset; /* ptr to the rset this FD is opened to */
void *priv; /* private parameters for this type */
void (*f_delete)(RSET ct);
RSFD (*f_open)(RSET ct, int wflag);
void (*f_close)(RSFD rfd);
- int (*f_forward)(RSFD rfd, void *buf, const void *untilbuf);
+ int (*f_forward)(RSFD rfd, void *buf, TERMID *term, const void *untilbuf);
void (*f_pos)(RSFD rfd, double *current, double *total);
/* returns -1,-1 if pos function not implemented for this type */
- int (*f_read)(RSFD rfd, void *buf);
+ int (*f_read)(RSFD rfd, void *buf, TERMID *term);
int (*f_write)(RSFD rfd, const void *buf);
};
-int rset_default_forward(RSFD rfd, void *buf,
+int rset_default_forward(RSFD rfd, void *buf, TERMID *term,
const void *untilbuf);
struct key_control {
/* 1 if created with it, 0 if passed from above */
RSFD free_list; /* all rfd's allocated but not currently in use */
int scope; /* On what level do we count hits and compare them? */
+ TERMID term; /* the term thing for ranking etc */
} rset;
/* rset is a "virtual base class", which will never exist on its own
* all instances are rsets of some specific type, like rsisamb, or rsbool
* occurences, whereas if we are only counting hits, we do not need anything
* below the scope. Again 1 is seqnos, 2 sysnos (or verses), 3 books, etc.
*/
-/* FIXME - Add a resolution, to decide on what level we want to return */
-/* hits. That can well be below scope, if we need to get seqnos for prox */
-/* or suchlike... */
RSFD rfd_create_base(RSET rs);
void rfd_delete_base(RSFD rfd);
RSET rset_create_base(const struct rset_control *sel,
NMEM nmem,
const struct key_control *kcontrol,
- int scope );
+ int scope,
+ TERMID term);
+
void rset_delete(RSET rs);
RSET rset_dup (RSET rs);
/* void rset_close(RSFD rfd); */
#define rset_close(rfd) (*(rfd)->rset->control->f_close)(rfd)
-/* int rset_forward(RSFD rfd, void *buf, void *untilbuf); */
-#define rset_forward(rfd, buf, untilbuf) \
- (*(rfd)->rset->control->f_forward)((rfd),(buf),(untilbuf))
+/* int rset_forward(RSFD rfd, void *buf, TERMID term, void *untilbuf); */
+#define rset_forward(rfd, buf, term, untilbuf) \
+ (*(rfd)->rset->control->f_forward)((rfd),(buf),(term),(untilbuf))
/* int rset_pos(RSFD fd, double *current, double *total); */
#define rset_pos(rfd,cur,tot) \
(*(rfd)->rset->control->f_pos)( (rfd),(cur),(tot))
-/* int rset_read(RSFD rfd, void *buf); */
-#define rset_read(rfd, buf) (*(rfd)->rset->control->f_read)((rfd), (buf))
+/* int rset_read(RSFD rfd, void *buf, TERMID term); */
+#define rset_read(rfd, buf, term) \
+ (*(rfd)->rset->control->f_read)((rfd), (buf), (term))
/* int rset_write(RSFD rfd, const void *buf); */
#define rset_write(rfd, buf) (*(rfd)->rset->control->f_write)((rfd), (buf))
RSET rsisamb_create( NMEM nmem, const struct key_control *kcontrol,
int scope,
- ISAMB is, ISAMB_P pos);
+ ISAMB is, ISAMB_P pos,
+ TERMID term);
RSET rsisamc_create( NMEM nmem, const struct key_control *kcontrol,
int scope,
- ISAMC is, ISAMC_P pos);
+ ISAMC is, ISAMC_P pos,
+ TERMID term);
RSET rsisams_create( NMEM nmem, const struct key_control *kcontrol,
int scope,
- ISAMS is, ISAMS_P pos);
+ ISAMS is, ISAMS_P pos,
+ TERMID term);
-/* $Id: trunc.c,v 1.45 2004-09-29 11:00:56 heikki Exp $
+/* $Id: trunc.c,v 1.46 2004-10-15 10:07:32 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
Index Data Aps
for (i = rscur; --i >= 0; )
{
rsfd[i] = rset_open (rset[i], RSETF_READ);
- if (rset_read(rsfd[i], ti->tmpbuf))
+ if (rset_read(rsfd[i], ti->tmpbuf,0))
heap_insert (ti, ti->tmpbuf, i);
else
{
while (1)
{
- if (!rset_read (rsfd[n], ti->tmpbuf))
+ if (!rset_read (rsfd[n], ti->tmpbuf,0))
{
heap_delete (ti);
rset_close (rsfd[n]);
{
if (no == 1)
return rsisams_create(rset_nmem, kctrl, scope,
- zi->reg->isams, *isam_p);
+ zi->reg->isams, *isam_p,
+ 0 /*FIXME - use proper TERMID*/);
qsort (isam_p, no, sizeof(*isam_p), isams_trunc_cmp);
}
else if (zi->reg->isamc)
{
if (no == 1)
return rsisamc_create(rset_nmem, kctrl, scope,
- zi->reg->isamc, *isam_p);
+ zi->reg->isamc, *isam_p,
+ 0 /*FIXME - use proper TERMID*/);
qsort (isam_p, no, sizeof(*isam_p), isamc_trunc_cmp);
}
else if (zi->reg->isamb)
{
if (no == 1)
return rsisamb_create(rset_nmem,kctrl, scope,
- zi->reg->isamb, *isam_p);
+ zi->reg->isamb, *isam_p, 0 /* FIXME - TERMID */ );
else if (no <10000 ) /* FIXME - hardcoded number */
{
RSET r;
int i;
for (i=0;i<no;i++)
rsets[i]=rsisamb_create(rset_nmem, kctrl, scope,
- zi->reg->isamb, isam_p[i] );
+ zi->reg->isamb, isam_p[i],
+ 0 /* FIXME - use a proper TERMID */ );
r=rsmultior_create( rset_nmem, kctrl, scope, no, rsets);
xfree(rsets);
return r;
-/* $Id: zebraapi.c,v 1.135 2004-10-07 14:18:23 heikki Exp $
+/* $Id: zebraapi.c,v 1.136 2004-10-15 10:07:32 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
Index Data Aps
{
ZebraHandle zh;
const char *default_encoding;
- ASSERTZS;
yaz_log(LOG_API,"zebra_open");
if (!zs)
-/* $Id: zrpn.c,v 1.156 2004-10-01 15:36:15 heikki Exp $
+/* $Id: zrpn.c,v 1.157 2004-10-15 10:07:32 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
Index Data Aps
*count = 0;
rfd = rset_open (r, RSETF_READ);
- while (rset_read (rfd, &key))
+ while (rset_read (rfd, &key,0 /* never mind terms */))
{
if (key.mem[0] != psysno)
{
-/* $Id: zsets.c,v 1.62 2004-09-15 08:13:51 adam Exp $
+/* $Id: zsets.c,v 1.63 2004-10-15 10:07:34 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
Index Data Aps
while (num_i < num && positions[num_i] < position)
num_i++;
rfd = rset_open (rset, RSETF_READ);
- while (num_i < num && rset_read (rfd, &key))
+ while (num_i < num && rset_read (rfd, &key, 0))
{
zint this_sys = key.mem[0];
if (this_sys != psysno)
}
}
rfd = rset_open (rset, RSETF_READ);
- while (rset_read (rfd, &key))
+ while (rset_read (rfd, &key,0))
+ /* FIXME - pass a TERMID *, and use it for something below !! */
{
zint this_sys = key.mem[0];
if (this_sys != psysno)
}
rc = rank_class->control;
- if (rset_read (rfd, &key))
+ if (rset_read (rfd, &key, 0))
+ /* FIXME - Pass a TERMID *, and use it for something ?? */
{
zint psysno = key.mem[0];
int score;
}
}
}
- while (rset_read (rfd, &key) && (est<0) );
-
+ while (rset_read (rfd, &key,0) && (est<0) );
+ /* FIXME - term ?? */
score = (*rc->calc) (handle, psysno);
resultSetInsertRank (zh, sort_info, psysno, score, 'A');
(*rc->end) (zh->reg, handle);
-/* $Id: rsbetween.c,v 1.26 2004-09-30 09:53:04 heikki Exp $
+/* $Id: rsbetween.c,v 1.27 2004-10-15 10:07:34 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002
Index Data Aps
static RSFD r_open_between (RSET ct, int flag);
static void r_close_between (RSFD rfd);
static void r_delete_between (RSET ct);
-static int r_forward_between(RSFD rfd, void *buf, const void *untilbuf);
-static int r_read_between (RSFD rfd, void *buf);
+static int r_forward_between(RSFD rfd, void *buf,
+ TERMID *term, const void *untilbuf);
+static int r_read_between (RSFD rfd, void *buf, TERMID *term );
static int r_write_between (RSFD rfd, const void *buf);
static void r_pos_between (RSFD rfd, double *current, double *total);
void *buf_m;
void *buf_r;
void *buf_attr;
+ TERMID term_m; /* we only return terms for the mid argument */
int level; /* counting start/end tags */
zint hits;
};
int scope,
RSET rset_l, RSET rset_m, RSET rset_r, RSET rset_attr)
{
- RSET rnew=rset_create_base(&control, nmem, kcontrol, scope);
+ RSET rnew=rset_create_base(&control, nmem, kcontrol, scope,0);
struct rset_between_info *info=
(struct rset_between_info *) nmem_malloc(rnew->nmem,sizeof(*info));
info->rset_l = rset_l;
p->rfd_m = rset_open (info->rset_m, RSETF_READ);
p->rfd_r = rset_open (info->rset_r, RSETF_READ);
- p->more_l = rset_read (p->rfd_l, p->buf_l);
- p->more_m = rset_read (p->rfd_m, p->buf_m);
- p->more_r = rset_read (p->rfd_r, p->buf_r);
+ p->more_l = rset_read (p->rfd_l, p->buf_l,NULL);
+ p->more_m = rset_read (p->rfd_m, p->buf_m, &p->term_m);
+ p->more_r = rset_read (p->rfd_r, p->buf_r,NULL);
if (info->rset_attr)
{
p->rfd_attr = rset_open (info->rset_attr, RSETF_READ);
- p->more_attr = rset_read (p->rfd_attr, p->buf_attr);
+ p->more_attr = rset_read (p->rfd_attr, p->buf_attr, NULL);
}
p->level=0;
p->hits=0;
-static int r_forward_between(RSFD rfd, void *buf, const void *untilbuf)
+static int r_forward_between(RSFD rfd, void *buf,
+ TERMID *term, const void *untilbuf)
{
struct rset_between_rfd *p=(struct rset_between_rfd *)rfd->priv;
int rc;
/* It is enough to forward the m pointer here, the read will */
/* naturally forward the l, m, and attr pointers */
if (p->more_m)
- p->more_m=rset_forward(p->rfd_m, p->buf_m,untilbuf);
+ p->more_m=rset_forward(p->rfd_m, p->buf_m, term, untilbuf);
#if RSBETWEEN_DEBUG
log2( p, "fwd: after forward M", 0,0);
#endif
- rc = r_read_between(rfd, buf);
+ rc = r_read_between(rfd, buf, term);
#if RSBETWEEN_DEBUG
log2( p, "fwd: after forward", 0,0);
#endif
-static int r_read_between (RSFD rfd, void *buf)
+static int r_read_between (RSFD rfd, void *buf, TERMID *term)
{
struct rset_between_info *info =(struct rset_between_info *)rfd->rset->priv;
struct rset_between_rfd *p=(struct rset_between_rfd *)rfd->priv;
else if (cmp_attr > 0)
break;
else if (cmp_attr > - rfd->rset->scope) /* == -1 */
- p->more_attr = rset_read (p->rfd_attr, p->buf_attr);
+ p->more_attr = rset_read (p->rfd_attr,
+ p->buf_attr,NULL);
/* if we had a forward that went all the way to
* the seqno, we could use that. But fwd only goes
* to the sysno */
else if (cmp_attr <= - rfd->rset->scope) /* ==-2 */
{
p->more_attr = rset_forward( p->rfd_attr,
- p->buf_attr, p->buf_l);
+ p->buf_attr, NULL, p->buf_l);
#if RSBETWEEN_DEBUG
logf(LOG_DEBUG, "btw: after frowarding attr m=%d",
p->more_attr);
{
if (p->more_l)
{
- p->more_l=rset_forward(p->rfd_l, p->buf_l, p->buf_m);
+ p->more_l=rset_forward(p->rfd_l, p->buf_l, NULL, p->buf_m);
if (p->more_l)
cmp_l= (*kctrl->cmp)(p->buf_l, p->buf_m);
else
}
} else
{
- p->more_l = rset_read (p->rfd_l, p->buf_l);
+ p->more_l = rset_read (p->rfd_l, p->buf_l, NULL);
}
#else
- p->more_l = rset_read (p->rfd_l, p->buf_l);
+ p->more_l = rset_read (p->rfd_l, p->buf_l, NULL);
#endif
if (p->more_l)
{
#if NEWCODE
if (cmp_r <= - rfd->rset->scope) /* == -2 */
{
- p->more_r=rset_forward(p->rfd_r, p->buf_r, p->buf_m);
+ p->more_r=rset_forward(p->rfd_r, p->buf_r, NULL, p->buf_m);
} else
{
- p->more_r = rset_read (p->rfd_r, p->buf_r);
+ p->more_r = rset_read (p->rfd_r, p->buf_r, NULL);
}
if (p->more_r)
cmp_r= (*kctrl->cmp)(p->buf_r, p->buf_m);
#else
- p->more_r = rset_read (p->rfd_r, p->buf_r);
+ p->more_r = rset_read (p->rfd_r, p->buf_r, NULL);
cmp_r= (*kctrl->cmp)(p->buf_r, p->buf_m);
#endif
}
if ( attr_match && p->level > 0) /* within a tag pair (or deeper) */
{
memcpy (buf, p->buf_m, kctrl->key_size);
+ if (term)
+ *term=p->term_m;
#if RSBETWEEN_DEBUG
log2( p, "Returning a hit (and forwarding m)", cmp_l, cmp_r);
#endif
- p->more_m = rset_read (p->rfd_m, p->buf_m);
+ p->more_m = rset_read (p->rfd_m, p->buf_m, NULL);
if (cmp_l >= rfd->rset->scope) /* == 2 */
p->level = 0;
p->hits++;
if (cmp_l >= rfd->rset->scope) /* == 2 */
{
p->level = 0;
- p->more_m=rset_forward(p->rfd_m, p->buf_m, p->buf_l);
+ p->more_m=rset_forward(p->rfd_m, p->buf_m, &p->term_m, p->buf_l);
} else
{
- p->more_m = rset_read (p->rfd_m, p->buf_m);
+ p->more_m = rset_read (p->rfd_m, p->buf_m, &p->term_m);
}
#else
if (cmp_l >= rfd->rset->scope ) /* == 2 */
-/* $Id: rsbool.c,v 1.48 2004-09-30 09:53:05 heikki Exp $
+/* $Id: rsbool.c,v 1.49 2004-10-15 10:07:34 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
Index Data Aps
static RSFD r_open (RSET ct, int flag);
static void r_close (RSFD rfd);
static void r_delete (RSET ct);
-static int r_forward(RSFD rfd, void *buf, const void *untilbuf);
+static int r_forward(RSFD rfd, void *buf, TERMID *term, const void *untilbuf);
static void r_pos (RSFD rfd, double *current, double *total);
-static int r_read_and (RSFD rfd, void *buf);
-static int r_read_or (RSFD rfd, void *buf);
-static int r_read_not (RSFD rfd, void *buf);
+static int r_read_and (RSFD rfd, void *buf, TERMID *term);
+static int r_read_or (RSFD rfd, void *buf, TERMID *term);
+static int r_read_not (RSFD rfd, void *buf, TERMID *term);
static int r_write (RSFD rfd, const void *buf);
static const struct rset_control control_and =
int more_r;
void *buf_l;
void *buf_r;
+ TERMID term_l;
+ TERMID term_r;
int tail;
};
int scope,
RSET rset_l, RSET rset_r)
{
- RSET rnew=rset_create_base(ctrl, nmem, kcontrol, scope);
+ RSET rnew=rset_create_base(ctrl, nmem, kcontrol, scope,0);
struct rset_bool_info *info;
info = (struct rset_bool_info *) nmem_malloc(rnew->nmem,sizeof(*info));
info->rset_l = rset_l;
p->rfd_l = rset_open (info->rset_l, RSETF_READ);
p->rfd_r = rset_open (info->rset_r, RSETF_READ);
- p->more_l = rset_read (p->rfd_l, p->buf_l);
- p->more_r = rset_read (p->rfd_r, p->buf_r);
+ p->more_l = rset_read (p->rfd_l, p->buf_l, &p->term_l);
+ p->more_r = rset_read (p->rfd_r, p->buf_r, &p->term_r);
p->tail = 0;
return rfd;
}
-static int r_forward (RSFD rfd, void *buf,
+static int r_forward (RSFD rfd, void *buf, TERMID *term,
const void *untilbuf)
{
struct rset_bool_rfd *p=(struct rset_bool_rfd *)rfd->priv;
const struct key_control *kctrl=rfd->rset->keycontrol;
if ( p->more_l && ((kctrl->cmp)(untilbuf,p->buf_l)>=rfd->rset->scope) )
- p->more_l = rset_forward(p->rfd_l, p->buf_l, untilbuf);
+ p->more_l = rset_forward(p->rfd_l, p->buf_l, &p->term_l, untilbuf);
if ( p->more_r && ((kctrl->cmp)(untilbuf,p->buf_r)>=rfd->rset->scope))
- p->more_r = rset_forward(p->rfd_r, p->buf_r, untilbuf);
+ p->more_r = rset_forward(p->rfd_r, p->buf_r, &p->term_r, untilbuf);
p->tail=0;
- return rset_read(rfd,buf);
+ return rset_read(rfd,buf,term);
}
3,1
*/
-static int r_read_and (RSFD rfd, void *buf)
+static int r_read_and (RSFD rfd, void *buf, TERMID *term)
{
struct rset_bool_rfd *p=(struct rset_bool_rfd *)rfd->priv;
const struct key_control *kctrl=rfd->rset->keycontrol;
if (!cmp)
{ /* cmp==0 */
memcpy (buf, p->buf_l, kctrl->key_size);
- p->more_l = rset_read (p->rfd_l, p->buf_l);
+ if (term)
+ *term=p->term_l;
+ p->more_l = rset_read (p->rfd_l, p->buf_l, &p->term_l);
p->tail = 1;
}
else if ( (cmp>0) && (cmp<rfd->rset->scope))
{ /* typically cmp == 1 */
memcpy (buf, p->buf_r, kctrl->key_size);
- p->more_r = rset_read (p->rfd_r, p->buf_r);
+ if (term)
+ *term=p->term_r;
+ p->more_r = rset_read (p->rfd_r, p->buf_r, &p->term_r);
p->tail = 1;
#if RSET_DEBUG
logf (LOG_DEBUG, "r_read_and [%p] returning R m=%d/%d c=%d",
else if ( (cmp<0) && (-cmp<rfd->rset->scope))
{ /* cmp == -1 */
memcpy (buf, p->buf_l, kctrl->key_size);
- p->more_l = rset_read (p->rfd_l, p->buf_l);
+ if (term)
+ *term=p->term_l;
+ p->more_l = rset_read (p->rfd_l, p->buf_l,&p->term_l);
p->tail = 1;
#if RSET_DEBUG
logf (LOG_DEBUG, "r_read_and [%p] returning L m=%d/%d c=%d",
if (p->tail)
{
memcpy (buf, p->buf_r, kctrl->key_size);
- p->more_r = rset_read (p->rfd_r, p->buf_r);
+ if (term)
+ *term=p->term_r;
+ p->more_r = rset_read (p->rfd_r, p->buf_r, &p->term_r);
if (!p->more_r || (*kctrl->cmp)(p->buf_r, buf) > 1)
p->tail = 0;
#if RSET_DEBUG
rfd, p->more_l, p->more_r, cmp);
#endif
if (p->more_r && p->more_l)
- p->more_r = rset_forward( p->rfd_r, p->buf_r, p->buf_l);
+ p->more_r = rset_forward( p->rfd_r, p->buf_r,
+ &p->term_r, p->buf_l);
else
return 0; /* no point in reading further */
}
if (p->tail)
{
memcpy (buf, p->buf_l, kctrl->key_size);
- p->more_l = rset_read (p->rfd_l, p->buf_l);
+ if (term)
+ *term=p->term_l;
+ p->more_l = rset_read (p->rfd_l, p->buf_l, &p->term_l);
if (!p->more_l || (*kctrl->cmp)(p->buf_l, buf) > 1)
p->tail = 0;
#if RSET_DEBUG
rfd, p->more_l, p->more_r, cmp);
#endif
if (p->more_r && p->more_l)
- p->more_l = rset_forward(p->rfd_l, p->buf_l, p->buf_r);
+ p->more_l = rset_forward(p->rfd_l, p->buf_l,
+ &p->term_l, p->buf_r);
else
return 0; /* no point in reading further */
}
return 0;
}
-static int r_read_or (RSFD rfd, void *buf)
+static int r_read_or (RSFD rfd, void *buf, TERMID *term)
{
struct rset_bool_rfd *p=(struct rset_bool_rfd *)rfd->priv;
const struct key_control *kctrl=rfd->rset->keycontrol;
if (!cmp)
{ /* cmp==0 */
memcpy (buf, p->buf_l, kctrl->key_size);
- p->more_l = rset_read (p->rfd_l, p->buf_l);
- p->more_r = rset_read (p->rfd_r, p->buf_r);
+ if (term)
+ *term=p->term_l;
+ p->more_l = rset_read (p->rfd_l, p->buf_l, &p->term_l);
+ /* FIXME - is this right, should we not leave _r as it is */
+ /* and return that in the next read, so that ranking etc */
+ /* get to see both? */
+ p->more_r = rset_read (p->rfd_r, p->buf_r, &p->term_r);
#if RSET_DEBUG
logf (LOG_DEBUG, "r_read_or returning A m=%d/%d c=%d",
p->more_l, p->more_r, cmp);
else if (cmp > 0)
{
memcpy (buf, p->buf_r, kctrl->key_size);
- p->more_r = rset_read (p->rfd_r, p->buf_r);
+ if (term)
+ *term=p->term_r;
+ p->more_r = rset_read (p->rfd_r, p->buf_r, &p->term_r);
#if RSET_DEBUG
logf (LOG_DEBUG, "r_read_or returning B m=%d/%d c=%d",
p->more_l, p->more_r, cmp);
else
{
memcpy (buf, p->buf_l, kctrl->key_size);
- p->more_l = rset_read ( p->rfd_l, p->buf_l);
+ if (term)
+ *term=p->term_l;
+ p->more_l = rset_read ( p->rfd_l, p->buf_l, &p->term_l);
#if RSET_DEBUG
logf (LOG_DEBUG, "r_read_or returning C m=%d/%d c=%d",
p->more_l, p->more_r, cmp);
return 0;
}
-static int r_read_not (RSFD rfd, void *buf)
+static int r_read_not (RSFD rfd, void *buf, TERMID *term)
{
struct rset_bool_rfd *p=(struct rset_bool_rfd *)rfd->priv;
const struct key_control *kctrl=rfd->rset->keycontrol;
if (cmp <= -rfd->rset->scope)
{ /* cmp == -2 */
memcpy (buf, p->buf_l, kctrl->key_size);
- p->more_l = rset_read (p->rfd_l, p->buf_l);
+ if (term)
+ *term=p->term_l;
+ p->more_l = rset_read (p->rfd_l, p->buf_l, &p->term_l);
p->hits++;
return 1;
}
else if (cmp >= rfd->rset->scope) /* cmp >1 */
- p->more_r = rset_forward( p->rfd_r, p->buf_r, p->buf_l);
+ p->more_r = rset_forward( p->rfd_r, p->buf_r,
+ &p->term_r, p->buf_l);
else
{ /* cmp== -1, 0, or 1 */
memcpy (buf, p->buf_l, kctrl->key_size);
+ if (term)
+ *term=p->term_l;
do
{
- p->more_l = rset_read (p->rfd_l, p->buf_l);
+ p->more_l = rset_read (p->rfd_l, p->buf_l, &p->term_l);
if (!p->more_l)
break;
cmp = (*kctrl->cmp)(p->buf_l, buf);
/* (cmp >= -1 && cmp <= 1) */
do
{
- p->more_r = rset_read (p->rfd_r, p->buf_r);
+ p->more_r = rset_read (p->rfd_r, p->buf_r, &p->term_r);
if (!p->more_r)
break;
cmp = (*kctrl->cmp)(p->buf_r, buf);
-/* $Id: rset.c,v 1.33 2004-09-09 10:08:06 heikki Exp $
+/* $Id: rset.c,v 1.34 2004-10-15 10:07:34 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
Index Data Aps
RSET rset_create_base(const struct rset_control *sel,
NMEM nmem, const struct key_control *kcontrol,
- int scope)
+ int scope, TERMID term)
{
RSET rnew;
NMEM M;
rnew->free_list=NULL;
rnew->keycontrol=kcontrol;
rnew->scope=scope;
+ rnew->term=term;
return rnew;
}
} /* rset_default_pos */
#endif
-int rset_default_forward(RSFD rfd, void *buf,
+int rset_default_forward(RSFD rfd, void *buf, TERMID *term,
const void *untilbuf)
{
int more=1;
while ( (cmp>=rfd->rset->scope) && (more))
{
logf (LOG_DEBUG, "rset_default_forward looping m=%d c=%d",more,cmp);
- more=rset_read(rfd, buf);
+ more=rset_read(rfd, buf, term);
if (more)
cmp=(rfd->rset->keycontrol->cmp)(untilbuf,buf);
/* if (more)
-/* $Id: rsisamb.c,v 1.23 2004-09-30 09:53:05 heikki Exp $
+/* $Id: rsisamb.c,v 1.24 2004-10-15 10:07:34 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
Index Data Aps
static RSFD r_open (RSET ct, int flag);
static void r_close (RSFD rfd);
static void r_delete (RSET ct);
-static int r_forward(RSFD rfd, void *buf, const void *untilbuf);
+static int r_forward(RSFD rfd, void *buf, TERMID *term, const void *untilbuf);
static void r_pos (RSFD rfd, double *current, double *total);
-static int r_read (RSFD rfd, void *buf);
+static int r_read (RSFD rfd, void *buf, TERMID *term);
static int r_write (RSFD rfd, const void *buf);
static const struct rset_control control =
};
RSET rsisamb_create( NMEM nmem, const struct key_control *kcontrol, int scope,
- ISAMB is, ISAMB_P pos)
+ ISAMB is, ISAMB_P pos, TERMID term)
{
- RSET rnew=rset_create_base(&control, nmem, kcontrol, scope);
+ RSET rnew=rset_create_base(&control, nmem, kcontrol, scope, term);
struct rset_isamb_info *info;
info = (struct rset_isamb_info *) nmem_malloc(rnew->nmem,sizeof(*info));
info->is=is;
}
-static int r_forward(RSFD rfd, void *buf, const void *untilbuf)
+static int r_forward(RSFD rfd, void *buf, TERMID *term, const void *untilbuf)
{
struct rset_pp_info *pinfo=(struct rset_pp_info *)(rfd->priv);
- return isamb_pp_forward(pinfo->pt, buf, untilbuf);
+ int rc;
+ rc=isamb_pp_forward(pinfo->pt, buf, untilbuf);
+ if (rc && term)
+ *term=rfd->rset->term;
+ return rc;
}
static void r_pos (RSFD rfd, double *current, double *total)
#endif
}
-static int r_read (RSFD rfd, void *buf)
+static int r_read (RSFD rfd, void *buf, TERMID *term)
{
struct rset_pp_info *pinfo=(struct rset_pp_info *)(rfd->priv);
-
- return isamb_pp_read(pinfo->pt, buf);
+ int rc;
+ rc=isamb_pp_read(pinfo->pt, buf);
+ if (rc && term)
+ *term=rfd->rset->term;
+ return rc;
}
static int r_write (RSFD rfd, const void *buf)
-/* $Id: rsisamc.c,v 1.26 2004-09-30 09:53:05 heikki Exp $
+/* $Id: rsisamc.c,v 1.27 2004-10-15 10:07:34 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
Index Data Aps
static RSFD r_open (RSET ct, int flag);
static void r_close (RSFD rfd);
static void r_delete (RSET ct);
-static int r_read (RSFD rfd, void *buf);
+static int r_read (RSFD rfd, void *buf, TERMID *term);
static int r_write (RSFD rfd, const void *buf);
static void r_pos (RSFD rfd, double *current, double *total);
};
RSET rsisamc_create( NMEM nmem, const struct key_control *kcontrol, int scope,
- ISAMC is, ISAMC_P pos)
+ ISAMC is, ISAMC_P pos, TERMID term)
{
- RSET rnew=rset_create_base(&control, nmem, kcontrol, scope);
+ RSET rnew=rset_create_base(&control, nmem, kcontrol, scope,term);
struct rset_isamc_info *info;
info = (struct rset_isamc_info *) nmem_malloc(rnew->nmem,sizeof(*info));
info->is=is;
}
-static int r_read (RSFD rfd, void *buf)
+static int r_read (RSFD rfd, void *buf, TERMID *term)
{
struct rset_pp_info *p=(struct rset_pp_info *)(rfd->priv);
int r;
r = isc_pp_read(p->pt, buf);
+ if (term)
+ *term=rfd->rset->term;
return r;
}
-/* $Id: rsisams.c,v 1.14 2004-09-30 09:53:05 heikki Exp $
+/* $Id: rsisams.c,v 1.15 2004-10-15 10:07:34 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002
Index Data Aps
static RSFD r_open (RSET ct, int flag);
static void r_close (RSFD rfd);
static void r_delete (RSET ct);
-static int r_read (RSFD rfd, void *buf);
+static int r_read (RSFD rfd, void *buf, TERMID *term);
static int r_write (RSFD rfd, const void *buf);
static void r_pos (RSFD rfd, double *current, double *total);
RSET rsisams_create( NMEM nmem, const struct key_control *kcontrol, int scope,
- ISAMS is, ISAMS_P pos)
+ ISAMS is, ISAMS_P pos, TERMID term)
{
- RSET rnew=rset_create_base(&control, nmem, kcontrol, scope);
+ RSET rnew=rset_create_base(&control, nmem, kcontrol, scope, term);
struct rset_isams_info *info;
info = (struct rset_isams_info *) nmem_malloc(rnew->nmem,sizeof(*info));
rnew->priv=info;
}
-static int r_read (RSFD rfd, void *buf)
+static int r_read (RSFD rfd, void *buf, TERMID *term)
{
struct rset_pp_info *ptinfo=(struct rset_pp_info *)(rfd->priv);
- return isams_pp_read(ptinfo->pt, buf);
+ int rc;
+ rc=isams_pp_read(ptinfo->pt, buf);
+ if (rc && term)
+ *term=rfd->rset->term;
+ return rc;
}
static int r_write (RSFD rfd, const void *buf)
-/* $Id: rsmultiandor.c,v 1.5 2004-09-30 09:53:05 heikki Exp $
+/* $Id: rsmultiandor.c,v 1.6 2004-10-15 10:07:34 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002
Index Data Aps
static RSFD r_open_or (RSET ct, int flag);
static void r_close (RSFD rfd);
static void r_delete (RSET ct);
-static int r_read_and (RSFD rfd, void *buf);
-static int r_read_or (RSFD rfd, void *buf);
+static int r_read_and (RSFD rfd, void *buf, TERMID *term);
+static int r_read_or (RSFD rfd, void *buf, TERMID *term);
static int r_write (RSFD rfd, const void *buf);
-static int r_forward_and(RSFD rfd, void *buf,
+static int r_forward_and(RSFD rfd, void *buf, TERMID *term,
const void *untilbuf);
-static int r_forward_or(RSFD rfd, void *buf,
+static int r_forward_or(RSFD rfd, void *buf, TERMID *term,
const void *untilbuf);
static void r_pos (RSFD rfd, double *current, double *total);
RSFD fd;
void *buf;
RSET rset;
+ TERMID term;
};
struct heap {
int scope, int no_rsets, RSET* rsets,
const struct rset_control *ctrl)
{
- RSET rnew=rset_create_base(ctrl, nmem,kcontrol, scope);
+ RSET rnew=rset_create_base(ctrl, nmem,kcontrol, scope,0);
struct rset_multiandor_info *info;
info = (struct rset_multiandor_info *) nmem_malloc(rnew->nmem,sizeof(*info));
info->no_rsets=no_rsets;
{ /* read the array and sort it */
for (i=0; i<info->no_rsets; i++){
p->items[i].fd=rset_open(info->rsets[i],RSETF_READ);
- if ( !rset_read(p->items[i].fd, p->items[i].buf) )
+ if (!rset_read(p->items[i].fd, p->items[i].buf, &p->items[i].term))
p->eof=1;
p->tailbits[i]=0;
}
{ /* fill the heap for ORing */
for (i=0; i<info->no_rsets; i++){
p->items[i].fd=rset_open(info->rsets[i],RSETF_READ);
- if ( rset_read(p->items[i].fd, p->items[i].buf) )
+ if ( rset_read(p->items[i].fd, p->items[i].buf, &p->items[i].term))
heap_insert(p->h, &(p->items[i]));
}
}
-static int r_forward_or(RSFD rfd, void *buf, const void *untilbuf)
+static int r_forward_or(RSFD rfd, void *buf,
+ TERMID *term,const void *untilbuf)
{ /* while heap head behind untilbuf, forward it and rebalance heap */
struct rset_multiandor_rfd *p=rfd->priv;
const struct key_control *kctrl=rfd->rset->keycontrol;
return 0;
while ( (*kctrl->cmp)(p->h->heap[1]->buf,untilbuf) < -rfd->rset->scope )
{
- if ( rset_forward(p->h->heap[1]->fd, p->h->heap[1]->buf, untilbuf) )
+ if (rset_forward(p->h->heap[1]->fd,p->h->heap[1]->buf,
+ &p->h->heap[1]->term, untilbuf))
heap_balance(p->h);
else
{
}
}
- return r_read_or(rfd,buf);
+ return r_read_or(rfd,buf,term);
}
-static int r_read_or (RSFD rfd, void *buf)
+static int r_read_or (RSFD rfd, void *buf, TERMID *term)
{
struct rset_multiandor_rfd *mrfd=rfd->priv;
const struct key_control *kctrl=rfd->rset->keycontrol;
return 0;
it = mrfd->h->heap[1];
memcpy(buf,it->buf, kctrl->key_size);
+ if (term)
+ *term=it->term;
(mrfd->hits)++;
- rdres=rset_read(it->fd, it->buf);
+ rdres=rset_read(it->fd, it->buf, &it->term);
if ( rdres )
heap_balance(mrfd->h);
else
}
-static int r_read_and (RSFD rfd, void *buf)
+static int r_read_and (RSFD rfd, void *buf, TERMID *term)
{ /* Has to return all hits where each item points to the */
/* same sysno (scope), in order. Keep an extra key (hitkey) */
/* as long as all records do not point to hitkey, forward */
}
/* return the lowest tail */
memcpy(buf, p->items[mintail].buf, kctrl->key_size);
- if (!rset_read(p->items[mintail].fd, p->items[mintail].buf))
+ if (term)
+ *term=p->items[mintail].term;
+ if (!rset_read(p->items[mintail].fd, p->items[mintail].buf,
+ &p->items[mintail].term))
{
p->eof=1; /* game over, once tails have been returned */
p->tailbits[mintail]=0;
cmp=(*kctrl->cmp)(p->items[0].buf,p->items[i].buf);
if (cmp<=-rfd->rset->scope) { /* [0] was behind, forward it */
if (!rset_forward(p->items[0].fd, p->items[0].buf,
- p->items[i].buf))
+ &p->items[0].term, p->items[i].buf))
{
p->eof=1; /* game over */
return 0;
} else if (cmp>=rfd->rset->scope)
{ /* [0] was ahead, forward i */
if (!rset_forward(p->items[i].fd, p->items[i].buf,
- p->items[0].buf))
+ &p->items[i].term, p->items[0].buf))
{
p->eof=1; /* game over */
return 0;
}
-static int r_forward_and(RSFD rfd, void *buf, const void *untilbuf)
+static int r_forward_and(RSFD rfd, void *buf, TERMID *term,
+ const void *untilbuf)
{
struct rset_multiandor_rfd *p=rfd->priv;
const struct key_control *kctrl=rfd->rset->keycontrol;
{
killtail=1; /* we are moving to a different hit */
if (!rset_forward(p->items[i].fd, p->items[i].buf,
- untilbuf))
+ &p->items[i].term, untilbuf))
{
p->eof=1; /* game over */
p->tailcount=0;
p->tailbits[i]=0;
p->tailcount=0;
}
- return r_read_and(rfd,buf);
+ return r_read_and(rfd,buf,term);
}
static void r_pos (RSFD rfd, double *current, double *total)
-/* $Id: rsnull.c,v 1.27 2004-09-30 09:53:05 heikki Exp $
+/* $Id: rsnull.c,v 1.28 2004-10-15 10:07:34 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002
Index Data Aps
static void r_close (RSFD rfd);
static void r_delete (RSET ct);
static void r_pos (RSFD rfd, double *current, double *total);
-static int r_read (RSFD rfd, void *buf);
+static int r_read (RSFD rfd, void *buf, TERMID *term);
static int r_write (RSFD rfd, const void *buf);
static const struct rset_control control =
RSET rsnull_create(NMEM nmem, const struct key_control *kcontrol )
{
- RSET rnew=rset_create_base(&control, nmem, kcontrol,0);
+ RSET rnew=rset_create_base(&control, nmem, kcontrol,0,0);
rnew->priv=NULL;
return rnew;
}
*current=0;
}
-static int r_read (RSFD rfd, void *buf)
+static int r_read (RSFD rfd, void *buf, TERMID *term)
{
+ if (term)
+ *term=0; /* NULL */
return 0;
}
-/* $Id: rsprox.c,v 1.17 2004-09-30 09:53:05 heikki Exp $
+/* $Id: rsprox.c,v 1.18 2004-10-15 10:07:34 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
Index Data Aps
static RSFD r_open (RSET ct, int flag);
static void r_close (RSFD rfd);
static void r_delete (RSET ct);
-static int r_forward(RSFD rfd, void *buf, const void *untilbuf);
-static int r_read (RSFD rfd, void *buf);
+static int r_forward(RSFD rfd, void *buf, TERMID *term, const void *untilbuf);
+static int r_read (RSFD rfd, void *buf, TERMID *term);
static int r_write (RSFD rfd, const void *buf);
static void r_pos (RSFD rfd, double *current, double *total);
RSFD *rfd;
char **buf; /* lookahead key buffers */
char *more; /* more in each lookahead? */
+ TERMID *terms; /* lookahead terms */
zint hits;
};
int ordered, int exclusion,
int relation, int distance)
{
- RSET rnew=rset_create_base(&control, nmem, kcontrol, scope);
+ RSET rnew=rset_create_base(&control, nmem, kcontrol, scope,0);
struct rset_prox_info *info;
info = (struct rset_prox_info *) nmem_malloc(rnew->nmem,sizeof(*info));
info->rset = nmem_malloc(rnew->nmem,rset_no * sizeof(*info->rset));
rfd->priv=p;
p->more = nmem_malloc (ct->nmem,sizeof(*p->more) * info->rset_no);
p->buf = nmem_malloc(ct->nmem,sizeof(*p->buf) * info->rset_no);
- for (i = 0; i < info->rset_no; i++)
+ p->terms = nmem_malloc(ct->nmem,sizeof(*p->terms) * info->rset_no);
+ for (i = 0; i < info->rset_no; i++)
+ {
p->buf[i] = nmem_malloc(ct->nmem,ct->keycontrol->key_size);
+ p->terms[i] = 0;
+ }
p->rfd = nmem_malloc(ct->nmem,sizeof(*p->rfd) * info->rset_no);
}
logf(LOG_DEBUG,"rsprox (%s) open [%p] n=%d",
for (i = 0; i < info->rset_no; i++) {
p->rfd[i] = rset_open (info->rset[i], RSETF_READ);
- p->more[i] = rset_read (p->rfd[i], p->buf[i]);
+ p->more[i] = rset_read (p->rfd[i], p->buf[i], &p->terms[i]);
}
p->hits=0;
return rfd;
rfd_delete_base(rfd);
}
-static int r_forward (RSFD rfd, void *buf, const void *untilbuf)
+static int r_forward (RSFD rfd, void *buf, TERMID *term, const void *untilbuf)
{
struct rset_prox_info *info = (struct rset_prox_info *)(rfd->rset->priv);
struct rset_prox_rfd *p=(struct rset_prox_rfd *)(rfd->priv);
/* it is enough to forward first one. Other will follow. */
if ( p->more[0] && /* was: cmp >=2 */
((kctrl->cmp)(untilbuf, p->buf[0]) >= rfd->rset->scope) )
- p->more[0] = rset_forward(p->rfd[0], p->buf[0], untilbuf);
+ p->more[0] = rset_forward(p->rfd[0], p->buf[0],
+ &p->terms[0], untilbuf);
}
if (info->ordered && info->relation == 3 && info->exclusion == 0
&& info->distance == 1)
{
p->more[i-1] = rset_forward (p->rfd[i-1],
p->buf[i-1],
+ &p->terms[i-1],
p->buf[i]);
break;
}
if ((*kctrl->getseq)(p->buf[i-1]) +1 !=
(*kctrl->getseq)(p->buf[i]))
{ /* FIXME - We need more flexible multilevel stuff */
- p->more[i-1] = rset_read ( p->rfd[i-1], p->buf[i-1]);
+ p->more[i-1] = rset_read ( p->rfd[i-1], p->buf[i-1],
+ &p->terms[i]);
break;
}
}
else
{
p->more[i] = rset_forward (p->rfd[i],
- p->buf[i], p->buf[i-1]);
+ p->buf[i], &p->terms[i], p->buf[i-1]);
break;
}
}
if (i == info->rset_no)
{
memcpy (buf, p->buf[0], kctrl->key_size);
- p->more[0] = rset_read (p->rfd[0], p->buf[0]);
+ if (term)
+ *term=p->terms[i];
+ p->more[0] = rset_read (p->rfd[0], p->buf[0], &p->terms[i]);
p->hits++;
return 1;
}
{
int cmp = (*kctrl->cmp)(p->buf[0], p->buf[1]);
if ( cmp <= - rfd->rset->scope) /* cmp<-1*/
- p->more[0] = rset_forward (p->rfd[0],
- p->buf[0], p->buf[1]);
+ p->more[0] = rset_forward (p->rfd[0], p->buf[0],
+ &p->terms[0],p->buf[1]);
else if ( cmp >= rfd->rset->scope ) /* cmp>1 */
- p->more[1] = rset_forward (p->rfd[1],
- p->buf[1], p->buf[0]);
+ p->more[1] = rset_forward (p->rfd[1], p->buf[1],
+ &p->terms[1],p->buf[0]);
else
{
zint seqno[500]; /* FIXME - why 500 ?? */
seqno[n++] = (*kctrl->getseq)(p->buf[0]);
while ((p->more[0] = rset_read (p->rfd[0],
- p->buf[0])) >= -1 &&
+ p->buf[0], &p->terms[0])) >= -1 &&
p->more[0] <= -1)
if (n < 500)
seqno[n++] = (*kctrl->getseq)(p->buf[0]);
if (excl)
{
memcpy (buf, p->buf[1], kctrl->key_size);
-
- p->more[1] = rset_read ( p->rfd[1], p->buf[1]);
+ if (term)
+ *term=p->terms[1];
+ p->more[1] = rset_read ( p->rfd[1], p->buf[1],
+ &p->terms[1]);
p->hits++;
return 1;
}
}
- p->more[1] = rset_read (p->rfd[1], p->buf[1]);
+ p->more[1] = rset_read (p->rfd[1], p->buf[1],&p->terms[i]);
}
}
}
}
-static int r_read (RSFD rfd, void *buf)
+static int r_read (RSFD rfd, void *buf, TERMID *term)
{
- return r_forward(rfd, buf, 0);
+ return r_forward(rfd, buf, term, 0);
}
static int r_write (RSFD rfd, const void *buf)
-/* $Id: rstemp.c,v 1.50 2004-09-30 09:53:05 heikki Exp $
+/* $Id: rstemp.c,v 1.51 2004-10-15 10:07:34 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003
Index Data Aps
static RSFD r_open (RSET ct, int flag);
static void r_close (RSFD rfd);
static void r_delete (RSET ct);
-static int r_read (RSFD rfd, void *buf);
+static int r_read (RSFD rfd, void *buf, TERMID *term);
static int r_write (RSFD rfd, const void *buf);
static void r_pos (RSFD rfd, double *current, double *total);
static void r_flush (RSFD rfd, int mk);
int scope,
const char *temp_path)
{
- RSET rnew=rset_create_base(&control, nmem, kcontrol, scope);
+ RSET rnew=rset_create_base(&control, nmem, kcontrol, scope,0);
struct rset_temp_info *info;
info = (struct rset_temp_info *) nmem_malloc(rnew->nmem, sizeof(*info));
}
-static int r_read (RSFD rfd, void *buf)
+static int r_read (RSFD rfd, void *buf, TERMID *term)
{
struct rset_temp_rfd *mrfd = (struct rset_temp_rfd*) rfd->priv;
struct rset_temp_info *info = (struct rset_temp_info *)rfd->rset->priv;
}
memcpy (buf, info->buf_mem + (mrfd->pos_cur - info->pos_buf),
rfd->rset->keycontrol->key_size);
+ if (term)
+ *term=rfd->rset->term;
+ /* FIXME - should we store and return terms ?? */
mrfd->pos_cur = nc;
mrfd->cur++;
return 1;
-/* $Id: t3.c,v 1.9 2004-08-25 09:23:39 adam Exp $
+/* $Id: t3.c,v 1.10 2004-10-15 10:07:34 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
Index Data Aps
"</gils>\n";
yaz_log_init_file("t3.log");
+ yaz_log_init_level(LOG_ALL);
nmem_init ();
-/* $Id: t8.c,v 1.1 2004-10-01 15:36:41 heikki Exp $
+/* $Id: t8.c,v 1.2 2004-10-15 10:07:34 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
Index Data Aps
#include <yaz/pquery.h>
#include <idzebra/api.h>
+#define LOGLEVEL LOG_ALL
static int testno=1;
/* read zebra.cfg from env var srcdir if it exists; otherwise current dir */
ZebraService zs;
ZebraHandle zh;
yaz_log_init_file("t8.log");
- /* yaz_log_init_level(LOG_ALL); */
+#ifdef LOGLEVEL
+ yaz_log_init_level(LOGLEVEL);
+#endif
nmem_init ();