-/* $Id: rset.h,v 1.28 2004-08-06 12:55:01 adam Exp $
+/* $Id: rset.h,v 1.29 2004-08-20 14:44:45 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002
Index Data Aps
typedef void *RSFD;
typedef struct rset *RSET;
-typedef struct rset_term *RSET_TERM;
struct rset_control
{
void (*f_close)(RSFD rfd);
void (*f_delete)(RSET ct);
void (*f_rewind)(RSFD rfd);
- int (*f_forward)(RSET ct, RSFD rfd, void *buf, int *term_index,
+ int (*f_forward)(RSET ct, RSFD rfd, void *buf,
int (*cmpfunc)(const void *p1, const void *p2),
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 *term_index);
+ int (*f_read)(RSFD rfd, void *buf);
int (*f_write)(RSFD rfd, const void *buf);
};
-int rset_default_forward(RSET ct, RSFD rfd, void *buf, int *term_index,
+int rset_default_forward(RSET ct, RSFD rfd, void *buf,
int (*cmpfunc)(const void *p1, const void *p2),
const void *untilbuf);
void rset_default_pos(RSFD rfd, double *current, double *total);
int flags;
int count;
void *buf;
- RSET_TERM *rset_terms;
- int no_rset_terms;
} rset;
-RSET_TERM rset_term_create (const char *name, int length, const char *flags,
- int type);
-void rset_term_destroy (RSET_TERM t);
-RSET_TERM rset_term_dup (RSET_TERM t);
-
#define RSETF_READ 0
#define RSETF_WRITE 1
/* void rset_rewind(RSET rs); */
#define rset_rewind(rs, rfd) (*(rs)->control->f_rewind)((rfd))
-/* int rset_forward(RSET rs, void *buf, int *indx, void *untilbuf); */
-#define rset_forward(rs, fd, buf, indx, cmpfunc, untilbuf) \
- (*(rs)->control->f_forward)((rs), (fd), (buf), (indx), (cmpfunc), (untilbuf))
+/* int rset_forward(RSET rs, void *buf, void *untilbuf); */
+#define rset_forward(rs, fd, buf, cmpfunc, untilbuf) \
+ (*(rs)->control->f_forward)((rs), (fd), (buf), (cmpfunc), (untilbuf))
/* int rset_pos(RSET rs, RSFD fd, double *current, double *total); */
#define rset_pos(rs,fd,cur,tot) \
(*(rs)->control->f_pos)( (fd),(cur),(tot))
-/* int rset_read(RSET rs, void *buf, int *indx); */
-#define rset_read(rs, fd, buf, indx) (*(rs)->control->f_read)((fd), (buf), indx)
+/* int rset_read(RSET rs, void *buf); */
+#define rset_read(rs, fd, buf) (*(rs)->control->f_read)((fd), (buf))
/* int rset_write(RSET rs, const void *buf); */
#define rset_write(rs, fd, buf) (*(rs)->control->f_write)((fd), (buf))
-/* $Id: rsisamb.h,v 1.2 2002-08-02 19:26:55 adam Exp $
+/* $Id: rsisamb.h,v 1.3 2004-08-20 14:44:45 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002
Index Data Aps
int key_size;
ISAMB is;
ISAMB_P pos;
- RSET_TERM rset_term;
} rset_isamb_parms;
#ifdef __cplusplus
-/* $Id: rsisamc.h,v 1.7 2002-08-02 19:26:55 adam Exp $
+/* $Id: rsisamc.h,v 1.8 2004-08-20 14:44:45 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002
Index Data Aps
int key_size;
ISAMC is;
ISAMC_P pos;
- RSET_TERM rset_term;
} rset_isamc_parms;
#ifdef __cplusplus
-/* $Id: rsisams.h,v 1.2 2002-08-02 19:26:55 adam Exp $
+/* $Id: rsisams.h,v 1.3 2004-08-20 14:44:45 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002
Index Data Aps
{
ISAMS is;
ISAMS_P pos;
- RSET_TERM rset_term;
} rset_isams_parms;
#ifdef __cplusplus
-/* $Id: rsm_or.h,v 1.7 2004-08-04 08:35:23 adam Exp $
+/* $Id: rsm_or.h,v 1.8 2004-08-20 14:44:45 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
Index Data Aps
ISAMC isc;
ISAMC_P *isam_positions;
- RSET_TERM rset_term;
int no_isam_positions;
int no_save_positions;
-/* $Id: rsmultior.h,v 1.2 2004-08-19 12:49:14 heikki Exp $
+/* $Id: rsmultior.h,v 1.3 2004-08-20 14:44:45 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
Index Data Aps
RSET *rsets; /* array of rsets to multi-or */
/* allocated when creating parms, */
/* rset will free when deleted */
-
- RSET_TERM rset_term;
-
int no_isam_positions;
int no_save_positions;
} rset_multior_parms;
-/* $Id: rsnull.h,v 1.5 2002-08-02 19:26:55 adam Exp $
+/* $Id: rsnull.h,v 1.6 2004-08-20 14:44:45 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002
Index Data Aps
{
int key_size;
char *temp_path;
- RSET_TERM rset_term;
} rset_null_parms;
extern const struct rset_control *rset_kind_null;
-/* $Id: rstemp.h,v 1.9 2004-01-22 11:27:21 adam Exp $
+/* $Id: rstemp.h,v 1.10 2004-08-20 14:44:45 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002
Index Data Aps
int (*cmp)(const void *p1, const void *p2);
int key_size;
const char *temp_path;
- RSET_TERM rset_term;
} rset_temp_parms;
#ifdef __cplusplus
Licensed under the Academic Free License version 1.1.
http://opensource.org/licenses/academic.php
-$Id: livcode.c,v 1.2 2004-08-04 08:35:23 adam Exp $
+$Id: livcode.c,v 1.3 2004-08-20 14:44:46 heikki Exp $
*/
int i;
logf (LOG_DEBUG, "livrank begin");
- si->no_entries = rset->no_rset_terms;
+ /* FIXME - Now that we don't have term counts in rsets, what do we */
+ /* do about this ??? */
+ si->no_entries = 0; /* rset->no_rset_terms; */ /* FIXME ??? */
si->no_rank_entries = 0;
si->entries = (struct rank_term_info *)
xmalloc (sizeof(*si->entries)*si->no_entries);
for (i = 0; i < si->no_entries; i++)
{
- const char *flags = rset->rset_terms[i]->flags;
- int g = rset->rset_terms[i]->nn;
+ const char *flags = ""; /* rset->rset_terms[i]->flags; *//* FIXME ???*/
+ int g = 0; /* rset->rset_terms[i]->nn; */ /* FIXME ??? */
const char *cp = strstr(flags, ",u=");
si->entries[i].rank_flag = 1;
-/* $Id: rank1.c,v 1.16 2004-08-06 13:36:23 adam Exp $
+/* $Id: rank1.c,v 1.17 2004-08-20 14:44:46 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003
Index Data Aps
#if DEBUG_RANK
yaz_log (LOG_LOG, "rank-1 begin");
#endif
- si->no_entries = rset->no_rset_terms;
+ si->no_entries = 0; /* rset->no_rset_terms; */ /* FIXME - what to do here*/
+ /* Now that we don't count term occurrences, ranking will have to */
+ /* different! */
si->no_rank_entries = 0;
si->entries = (struct rank_term_info *)
xmalloc (sizeof(*si->entries)*si->no_entries);
for (i = 0; i < si->no_entries; i++)
{
- zint g = rset->rset_terms[i]->nn;
+ zint g = 0; /* rset->rset_terms[i]->nn; */ /* FIXME ??? */
#if DEBUG_RANK
yaz_log(LOG_LOG, "i=%d flags=%s", i, rset->rset_terms[i]->flags);
#endif
- if (!strncmp (rset->rset_terms[i]->flags, "rank,", 5))
+ if (0) /* (!strncmp (rset->rset_terms[i]->flags, "rank,", 5)) */
+ /* FIXME */ /* ??? */
{
- const char *cp = strstr(rset->rset_terms[i]->flags+4, ",w=");
+ const char *cp = "w";
+ /*= strstr(rset->rset_terms[i]->flags+4, ",w=");*/
+ /* FIXME ??? */
si->entries[i].rank_flag = 1;
if (cp)
si->entries[i].rank_weight = atoi (cp+3);
-/* $Id: trunc.c,v 1.35 2004-08-19 12:49:14 heikki Exp $
+/* $Id: trunc.c,v 1.36 2004-08-20 14:44:46 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
Index Data Aps
parms.cmp = key_compare_it;
parms.key_size = sizeof(struct it_key);
parms.temp_path = res_get (zi->res, "setTmpDir");
- parms.rset_term = rset_term_create (term, length, flags, term_type);
result = rset_create (rset_kind_temp, &parms);
result_rsfd = rset_open (result, RSETF_WRITE);
{
RSFD *rsfd;
RSET *rset;
- int term_index;
int i, i_add = (to-from)/merge_chunk + 1;
struct trunc_info *ti;
int rscur = 0;
for (i = rscur; --i >= 0; )
{
rsfd[i] = rset_open (rset[i], RSETF_READ);
- if (rset_read (rset[i], rsfd[i], ti->tmpbuf, &term_index))
+ if (rset_read (rset[i], rsfd[i], ti->tmpbuf))
heap_insert (ti, ti->tmpbuf, i);
else
{
while (1)
{
- if (!rset_read (rset[n], rsfd[n], ti->tmpbuf, &term_index))
+ if (!rset_read (rset[n], rsfd[n], ti->tmpbuf))
{
heap_delete (ti);
rset_close (rset[n], rsfd[n]);
else
logf (LOG_WARN, "Unknown isam set in rset_trunc_r");
- parms.rset_term->nn = nn;
rset_close (result, result_rsfd);
return result;
}
if (no < 1)
{
rset_null_parms parms;
- parms.rset_term = rset_term_create (term, length, flags, term_type);
return rset_create (rset_kind_null, &parms);
}
if (zi->reg->isams)
parms.pos = *isam_p;
parms.is = zi->reg->isams;
- parms.rset_term = rset_term_create (term, length, flags,
- term_type);
return rset_create (rset_kind_isams, &parms);
}
qsort (isam_p, no, sizeof(*isam_p), isams_trunc_cmp);
parms.cmp = key_compare_it;
parms.pos = *isam_p;
parms.is = zi->reg->isamc;
- parms.rset_term = rset_term_create (term, length, flags,
- term_type);
return rset_create (rset_kind_isamc, &parms);
}
-#if NEW_TRUNC
+#if 0 /* NEW_TRUNC */ /* FIXME - Use the new multi_or instead !! */
else if (no < 10000)
{
rset_m_or_parms parms;
parms.isam_positions = isam_p;
parms.no_isam_positions = no;
parms.no_save_positions = 100000;
- parms.rset_term = rset_term_create (term, length, flags,
- term_type);
return rset_create (rset_kind_m_or, &parms);
}
#endif
parms.cmp = key_compare_it;
parms.pos = *isam_p;
parms.is = zi->reg->isamb;
- parms.rset_term = rset_term_create (term, length, flags,
- term_type);
return rset_create (rset_kind_isamb, &parms);
}
#if 1
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;
for (i=0;i<no;i++)
{
b_parms.pos = isam_p[i];
- b_parms.rset_term = rset_term_create (term, length, flags,
- term_type);
m_parms.rsets[i]=rset_create (rset_kind_isamb, &b_parms);
}
return rset_create (rset_kind_multior, &m_parms);
-/* $Id: zrpn.c,v 1.143 2004-08-06 13:36:23 adam Exp $
+/* $Id: zrpn.c,v 1.144 2004-08-20 14:44:46 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
Index Data Aps
if (rset_no == 0)
{
rset_null_parms parms;
-
- parms.rset_term = rset_term_create (termz, -1, rank_type,
- zapt->term->which);
return rset_create (rset_kind_null, &parms);
}
else if (rset_no == 1)
if (rset_no == 0)
{
rset_null_parms parms;
-
- parms.rset_term = rset_term_create (termz, -1, rank_type,
- zapt->term->which);
return rset_create (rset_kind_null, &parms);
}
result = rset[0];
if (rset_no == 0)
{
rset_null_parms parms;
-
- parms.rset_term = rset_term_create (termz, -1, rank_type,
- zapt->term->which);
return rset_create (rset_kind_null, &parms);
}
result = rset[0];
if (rset_no == 0)
{
rset_null_parms parms;
-
- parms.rset_term = rset_term_create (term_dst, -1, rank_type,
- zapt->term->which);
return rset_create (rset_kind_null, &parms);
}
result = rset[0];
int sys;
rset_temp_parms parms;
- parms.rset_term = rset_term_create (termz, -1, rank_type,
- zapt->term->which);
parms.cmp = key_compare_it;
parms.key_size = sizeof (struct it_key);
parms.temp_path = res_get (zh->res, "setTmpDir");
sks->which = Z_SortKeySpec_null;
sks->u.null = odr_nullval ();
sort_sequence->specs[i] = sks;
-
- parms.rset_term = rset_term_create (termz, -1, rank_type,
- zapt->term->which);
return rset_create (rset_kind_null, &parms);
}
if (grep_info_prepare (zh, 0 /* zapt */, &grep_info, '0', stream))
{
rset_null_parms parms;
-
- parms.rset_term = rset_term_create (term, strlen(term),
- flags, term_type);
- parms.rset_term->nn = 0;
return rset_create (rset_kind_null, &parms);
}
if (ord < 0)
{
rset_null_parms parms;
-
- parms.rset_term = rset_term_create (term, strlen(term),
- flags, term_type);
- parms.rset_term->nn = 0;
return rset_create (rset_kind_null, &parms);
}
if (prefix_len)
int kno = 0;
struct it_key key;
RSFD rfd;
- int term_index;
logf (LOG_DEBUG, "count_set");
*count = 0;
rfd = rset_open (r, RSETF_READ);
- while (rset_read (r, rfd, &key, &term_index))
+ while (rset_read (r, rfd, &key))
{
#if IT_KEY_NEW
if (key.mem[0] != psysno)
-/* $Id: zserver.c,v 1.119 2004-08-06 13:36:23 adam Exp $
+/* $Id: zserver.c,v 1.120 2004-08-20 14:44:46 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
Index Data Aps
Z_SearchInfoReport *sr;
/* get no of terms for result set */
- no_terms = zebra_resultSetTerms (zh, r->setname, 0, 0, 0, 0, 0);
+ no_terms = 0; /* zebra_resultSetTerms (zh, r->setname, 0, 0, 0, 0, 0); */
+ /* FIXME - Rsets don't know number of terms no more ??? */
if (!no_terms)
return;
Z_Term *term;
char outbuf[1024];
size_t len = sizeof(outbuf);
+ /* FIXME - Can we just skip this ??? */
+ /*
zebra_resultSetTerms (zh, r->setname, i,
&count, &type, outbuf, &len);
-
+ */
sr->elements[i] = odr_malloc (r->stream, sizeof(**sr->elements));
sr->elements[i]->subqueryId = 0;
sr->elements[i]->fullQuery = odr_malloc (r->stream,
-/* $Id: zsets.c,v 1.56 2004-08-19 14:47:06 heikki Exp $
+/* $Id: zsets.c,v 1.57 2004-08-20 14:44:46 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
Index Data Aps
};
ZebraSet resultSetAddRPN (ZebraHandle zh, NMEM m,
- Z_RPNQuery *rpn, int num_bases,
+ Z_RPNQuery *rpn, int num_bases,
char **basenames,
- const char *setname)
+ const char *setname)
{
ZebraSet zebraSet;
int i;
zebraSet = resultSetAdd (zh, setname, 1);
if (!zebraSet)
- return 0;
+ return 0;
zebraSet->locked = 1;
zebraSet->rpn = 0;
zebraSet->nmem = m;
zebraSet->rset = rpn_search (zh, zebraSet->nmem, rpn,
zebraSet->num_bases,
- zebraSet->basenames, zebraSet->name,
- zebraSet);
+ zebraSet->basenames, zebraSet->name,
+ zebraSet);
zh->hits = zebraSet->hits;
if (zebraSet->rset)
zebraSet->rpn = rpn;
}
void resultSetAddTerm (ZebraHandle zh, ZebraSet s, int reg_type,
- const char *db, int set,
- int use, const char *term)
+ const char *db, int set,
+ int use, const char *term)
{
assert(zh); /* compiler shut up */
if (!s->nmem)
- s->nmem = nmem_create ();
+ s->nmem = nmem_create ();
if (!s->term_entries)
{
- int i;
- s->term_entries_max = 1000;
- s->term_entries =
- nmem_malloc (s->nmem, s->term_entries_max *
- sizeof(*s->term_entries));
- for (i = 0; i < s->term_entries_max; i++)
- s->term_entries[i].term = 0;
+ int i;
+ s->term_entries_max = 1000;
+ s->term_entries =
+ nmem_malloc (s->nmem, s->term_entries_max *
+ sizeof(*s->term_entries));
+ for (i = 0; i < s->term_entries_max; i++)
+ s->term_entries[i].term = 0;
}
if (s->hits < s->term_entries_max)
{
- s->term_entries[s->hits].reg_type = reg_type;
- s->term_entries[s->hits].db = nmem_strdup (s->nmem, db);
- s->term_entries[s->hits].set = set;
- s->term_entries[s->hits].use = use;
- s->term_entries[s->hits].term = nmem_strdup (s->nmem, term);
+ s->term_entries[s->hits].reg_type = reg_type;
+ s->term_entries[s->hits].db = nmem_strdup (s->nmem, db);
+ s->term_entries[s->hits].set = set;
+ s->term_entries[s->hits].use = use;
+ s->term_entries[s->hits].term = nmem_strdup (s->nmem, term);
}
(s->hits)++;
}
-
+#if 0 /* FIXME - Delete this, we don't count terms no more */
int zebra_resultSetTerms (ZebraHandle zh, const char *setname,
int no, zint *count,
int *type, char *out, size_t *len)
char *inbuf = s->rset->rset_terms[no]->name;
size_t inleft = strlen(inbuf);
size_t outleft = *len - 1;
- int converted = 0;
+ int converted = 0;
if (zh->iconv_from_utf8 != 0)
{
*len = 0;
else
*len = outbuf - out;
- converted = 1;
+ converted = 1;
}
if (!converted)
{
return no_max;
}
+#endif
ZebraSet resultSetAdd (ZebraHandle zh, const char *name, int ov)
{
for (s = zh->sets; s; s = s->next)
if (!strcmp (s->name, name))
- break;
+ break;
if (s)
{
- yaz_log (LOG_DEBUG, "updating result set %s", name);
- if (!ov || s->locked)
- return NULL;
- if (s->rset)
- rset_delete (s->rset);
- if (s->nmem)
- nmem_destroy (s->nmem);
+ yaz_log (LOG_DEBUG, "updating result set %s", name);
+ if (!ov || s->locked)
+ return NULL;
+ if (s->rset)
+ rset_delete (s->rset);
+ if (s->nmem)
+ nmem_destroy (s->nmem);
}
else
{
- const char *sort_max_str = zebra_get_resource(zh, "sortmax", "1000");
-
- yaz_log (LOG_DEBUG, "adding result set %s", name);
- s = (ZebraSet) xmalloc (sizeof(*s));
- s->next = zh->sets;
- zh->sets = s;
- s->name = (char *) xmalloc (strlen(name)+1);
- strcpy (s->name, name);
-
- s->sort_info = (struct zset_sort_info *)
- xmalloc (sizeof(*s->sort_info));
- s->sort_info->max_entries = atoi(sort_max_str);
- if (s->sort_info->max_entries < 2)
- s->sort_info->max_entries = 2;
-
- s->sort_info->entries = (struct zset_sort_entry **)
- xmalloc (sizeof(*s->sort_info->entries) *
- s->sort_info->max_entries);
- s->sort_info->all_entries = (struct zset_sort_entry *)
- xmalloc (sizeof(*s->sort_info->all_entries) *
- s->sort_info->max_entries);
- for (i = 0; i < s->sort_info->max_entries; i++)
- s->sort_info->entries[i] = s->sort_info->all_entries + i;
+ const char *sort_max_str = zebra_get_resource(zh, "sortmax", "1000");
+
+ yaz_log (LOG_DEBUG, "adding result set %s", name);
+ s = (ZebraSet) xmalloc (sizeof(*s));
+ s->next = zh->sets;
+ zh->sets = s;
+ s->name = (char *) xmalloc (strlen(name)+1);
+ strcpy (s->name, name);
+
+ s->sort_info = (struct zset_sort_info *)
+ xmalloc (sizeof(*s->sort_info));
+ s->sort_info->max_entries = atoi(sort_max_str);
+ if (s->sort_info->max_entries < 2)
+ s->sort_info->max_entries = 2;
+
+ s->sort_info->entries = (struct zset_sort_entry **)
+ xmalloc (sizeof(*s->sort_info->entries) *
+ s->sort_info->max_entries);
+ s->sort_info->all_entries = (struct zset_sort_entry *)
+ xmalloc (sizeof(*s->sort_info->all_entries) *
+ s->sort_info->max_entries);
+ for (i = 0; i < s->sort_info->max_entries; i++)
+ s->sort_info->entries[i] = s->sort_info->all_entries + i;
}
s->locked = 0;
s->term_entries = 0;
yaz_log (LOG_LOG, "research %s", name);
s->rset =
rpn_search (zh, nmem, s->rpn, s->num_bases,
- s->basenames, s->name, s);
+ s->basenames, s->name, s);
nmem_destroy (nmem);
}
return s;
int i;
if (statuses)
- for (i = 0; i<num; i++)
- statuses[i] = Z_DeleteStatus_resultSetDidNotExist;
+ for (i = 0; i<num; i++)
+ statuses[i] = Z_DeleteStatus_resultSetDidNotExist;
zh->errCode = 0;
zh->errString = NULL;
while (*ss)
{
- int i = -1;
- ZebraSet s = *ss;
- if (num >= 0)
- {
- for (i = 0; i<num; i++)
- if (!strcmp (s->name, names[i]))
- {
- if (statuses)
- statuses[i] = Z_DeleteStatus_success;
- i = -1;
- break;
- }
- }
- if (i < 0)
- {
- *ss = s->next;
-
- xfree (s->sort_info->all_entries);
- xfree (s->sort_info->entries);
- xfree (s->sort_info);
-
- if (s->nmem)
- nmem_destroy (s->nmem);
- if (s->rset)
- rset_delete (s->rset);
- xfree (s->name);
- xfree (s);
- }
- else
- ss = &s->next;
+ int i = -1;
+ ZebraSet s = *ss;
+ if (num >= 0)
+ {
+ for (i = 0; i<num; i++)
+ if (!strcmp (s->name, names[i]))
+ {
+ if (statuses)
+ statuses[i] = Z_DeleteStatus_success;
+ i = -1;
+ break;
+ }
+ }
+ if (i < 0)
+ {
+ *ss = s->next;
+
+ xfree (s->sort_info->all_entries);
+ xfree (s->sort_info->entries);
+ xfree (s->sort_info);
+
+ if (s->nmem)
+ nmem_destroy (s->nmem);
+ if (s->rset)
+ rset_delete (s->rset);
+ xfree (s->name);
+ xfree (s);
+ }
+ else
+ ss = &s->next;
}
}
ZebraPosSet zebraPosSetCreate (ZebraHandle zh, const char *name,
- int num, int *positions)
+ int num, int *positions)
{
ZebraSet sset;
ZebraPosSet sr = 0;
return NULL;
if (!(rset = sset->rset))
{
- if (!sset->term_entries)
- return 0;
- sr = (ZebraPosSet) xmalloc (sizeof(*sr) * num);
- for (i = 0; i<num; i++)
- {
- sr[i].sysno = 0;
- sr[i].score = -1;
- sr[i].term = 0;
- sr[i].db = 0;
-
- if (positions[i] <= sset->term_entries_max)
- {
- sr[i].term = sset->term_entries[positions[i]-1].term;
- sr[i].db = sset->term_entries[positions[i]-1].db;
- }
- }
+ if (!sset->term_entries)
+ return 0;
+ sr = (ZebraPosSet) xmalloc (sizeof(*sr) * num);
+ for (i = 0; i<num; i++)
+ {
+ sr[i].sysno = 0;
+ sr[i].score = -1;
+ sr[i].term = 0;
+ sr[i].db = 0;
+
+ if (positions[i] <= sset->term_entries_max)
+ {
+ sr[i].term = sset->term_entries[positions[i]-1].term;
+ sr[i].db = sset->term_entries[positions[i]-1].db;
+ }
+ }
}
else
{
- sr = (ZebraPosSet) xmalloc (sizeof(*sr) * num);
- for (i = 0; i<num; i++)
- {
- sr[i].sysno = 0;
- sr[i].score = -1;
- sr[i].term = 0;
- sr[i].db = 0;
- }
- sort_info = sset->sort_info;
- if (sort_info)
- {
- int position;
-
- for (i = 0; i<num; i++)
- {
- position = positions[i];
- if (position > 0 && position <= sort_info->num_entries)
- {
- yaz_log (LOG_DEBUG, "got pos=%d (sorted)", position);
- sr[i].sysno = sort_info->entries[position-1]->sysno;
- sr[i].score = sort_info->entries[position-1]->score;
- }
- }
- }
- /* did we really get all entries using sort ? */
- for (i = 0; i<num; i++)
- {
- if (!sr[i].sysno)
- break;
- }
- if (i < num) /* nope, get the rest, unsorted - sorry */
- {
- int position = 0;
- int num_i = 0;
- zint psysno = 0;
- int term_index;
- RSFD rfd;
- struct it_key key;
-
- if (sort_info)
- position = sort_info->num_entries;
- while (num_i < num && positions[num_i] < position)
- num_i++;
- rfd = rset_open (rset, RSETF_READ);
- while (num_i < num && rset_read (rset, rfd, &key, &term_index))
- {
+ sr = (ZebraPosSet) xmalloc (sizeof(*sr) * num);
+ for (i = 0; i<num; i++)
+ {
+ sr[i].sysno = 0;
+ sr[i].score = -1;
+ sr[i].term = 0;
+ sr[i].db = 0;
+ }
+ sort_info = sset->sort_info;
+ if (sort_info)
+ {
+ int position;
+
+ for (i = 0; i<num; i++)
+ {
+ position = positions[i];
+ if (position > 0 && position <= sort_info->num_entries)
+ {
+ yaz_log (LOG_DEBUG, "got pos=%d (sorted)", position);
+ sr[i].sysno = sort_info->entries[position-1]->sysno;
+ sr[i].score = sort_info->entries[position-1]->score;
+ }
+ }
+ }
+ /* did we really get all entries using sort ? */
+ for (i = 0; i<num; i++)
+ {
+ if (!sr[i].sysno)
+ break;
+ }
+ if (i < num) /* nope, get the rest, unsorted - sorry */
+ {
+ int position = 0;
+ int num_i = 0;
+ zint psysno = 0;
+ RSFD rfd;
+ struct it_key key;
+
+ if (sort_info)
+ position = sort_info->num_entries;
+ while (num_i < num && positions[num_i] < position)
+ num_i++;
+ rfd = rset_open (rset, RSETF_READ);
+ while (num_i < num && rset_read (rset, rfd, &key))
+ {
#if IT_KEY_NEW
- zint this_sys = key.mem[0];
+ zint this_sys = key.mem[0];
#else
- zint this_sys = key.sysno;
+ zint this_sys = key.sysno;
#endif
- if (this_sys != psysno)
- {
- psysno = this_sys;
- if (sort_info)
- {
- /* determine we alreay have this in our set */
- for (i = sort_info->num_entries; --i >= 0; )
- if (psysno == sort_info->entries[i]->sysno)
- break;
- if (i >= 0)
- continue;
- }
- position++;
- assert (num_i < num);
- if (position == positions[num_i])
- {
- sr[num_i].sysno = psysno;
- yaz_log (LOG_DEBUG, "got pos=%d (unsorted)", position);
- sr[num_i].score = -1;
- num_i++;
- }
- }
- }
- rset_close (rset, rfd);
- }
+ if (this_sys != psysno)
+ {
+ psysno = this_sys;
+ if (sort_info)
+ {
+ /* determine we alreay have this in our set */
+ for (i = sort_info->num_entries; --i >= 0; )
+ if (psysno == sort_info->entries[i]->sysno)
+ break;
+ if (i >= 0)
+ continue;
+ }
+ position++;
+ assert (num_i < num);
+ if (position == positions[num_i])
+ {
+ sr[num_i].sysno = psysno;
+ yaz_log (LOG_DEBUG, "got pos=%d (unsorted)", position);
+ sr[num_i].score = -1;
+ num_i++;
+ }
+ }
+ }
+ rset_close (rset, rfd);
+ }
}
return sr;
}
};
void resultSetInsertSort (ZebraHandle zh, ZebraSet sset,
- struct sortKeyInfo *criteria, int num_criteria,
- zint sysno)
+ struct sortKeyInfo *criteria, int num_criteria,
+ zint sysno)
{
struct zset_sort_entry this_entry;
struct zset_sort_entry *new_entry = NULL;
sortIdx_sysno (zh->reg->sortIdx, sysno);
for (i = 0; i<num_criteria; i++)
{
- sortIdx_type (zh->reg->sortIdx, criteria[i].attrUse);
- sortIdx_read (zh->reg->sortIdx, this_entry.buf[i]);
+ sortIdx_type (zh->reg->sortIdx, criteria[i].attrUse);
+ sortIdx_read (zh->reg->sortIdx, this_entry.buf[i]);
}
i = sort_info->num_entries;
while (--i >= 0)
{
- int rel = 0;
- for (j = 0; j<num_criteria; j++)
- {
+ int rel = 0;
+ for (j = 0; j<num_criteria; j++)
+ {
if (criteria[j].numerical)
{
double diff = atof(this_entry.buf[j]) -
}
else
{
- rel = memcmp (this_entry.buf[j], sort_info->entries[i]->buf[j],
- SORT_IDX_ENTRYSIZE);
+ rel = memcmp (this_entry.buf[j], sort_info->entries[i]->buf[j],
+ SORT_IDX_ENTRYSIZE);
}
- if (rel)
- break;
- }
- if (!rel)
- break;
- if (criteria[j].relation == 'A')
+ if (rel)
+ break;
+ }
+ if (!rel)
+ break;
+ if (criteria[j].relation == 'A')
{
- if (rel > 0)
- break;
- }
+ if (rel > 0)
+ break;
+ }
else if (criteria[j].relation == 'D')
- {
- if (rel < 0)
- break;
- }
+ {
+ if (rel < 0)
+ break;
+ }
}
++i;
j = sort_info->max_entries;
if (i == j)
- return;
+ return;
if (sort_info->num_entries == j)
- --j;
+ --j;
else
- j = (sort_info->num_entries)++;
+ j = (sort_info->num_entries)++;
new_entry = sort_info->entries[j];
while (j != i)
{
- sort_info->entries[j] = sort_info->entries[j-1];
- --j;
+ sort_info->entries[j] = sort_info->entries[j-1];
+ --j;
}
sort_info->entries[i] = new_entry;
assert (new_entry);
for (i = 0; i<num_criteria; i++)
- memcpy (new_entry->buf[i], this_entry.buf[i], SORT_IDX_ENTRYSIZE);
+ memcpy (new_entry->buf[i], this_entry.buf[i], SORT_IDX_ENTRYSIZE);
new_entry->sysno = sysno;
new_entry->score = -1;
}
void resultSetInsertRank (ZebraHandle zh, struct zset_sort_info *sort_info,
- zint sysno, int score, int relation)
+ zint sysno, int score, int relation)
{
struct zset_sort_entry *new_entry = NULL;
int i, j;
i = sort_info->num_entries;
while (--i >= 0)
{
- int rel = 0;
-
- rel = score - sort_info->entries[i]->score;
-
- if (relation == 'D')
- {
- if (rel >= 0)
- break;
- }
- else if (relation == 'A')
- {
- if (rel <= 0)
- break;
- }
+ int rel = 0;
+
+ rel = score - sort_info->entries[i]->score;
+
+ if (relation == 'D')
+ {
+ if (rel >= 0)
+ break;
+ }
+ else if (relation == 'A')
+ {
+ if (rel <= 0)
+ break;
+ }
}
++i;
j = sort_info->max_entries;
if (i == j)
- return;
+ return;
if (sort_info->num_entries == j)
- --j;
+ --j;
else
- j = (sort_info->num_entries)++;
+ j = (sort_info->num_entries)++;
new_entry = sort_info->entries[j];
while (j != i)
{
- sort_info->entries[j] = sort_info->entries[j-1];
- --j;
+ sort_info->entries[j] = sort_info->entries[j-1];
+ --j;
}
sort_info->entries[i] = new_entry;
assert (new_entry);
}
void resultSetSort (ZebraHandle zh, NMEM nmem,
- int num_input_setnames, const char **input_setnames,
- const char *output_setname,
- Z_SortKeySpecList *sort_sequence, int *sort_status)
+ int num_input_setnames, const char **input_setnames,
+ const char *output_setname,
+ Z_SortKeySpecList *sort_sequence, int *sort_status)
{
ZebraSet sset;
RSET rset;
if (num_input_setnames == 0)
{
- zh->errCode = 208;
- return ;
+ zh->errCode = 208;
+ return ;
}
if (num_input_setnames > 1)
{
- zh->errCode = 230;
- return;
+ zh->errCode = 230;
+ return;
}
yaz_log (LOG_DEBUG, "result set sort input=%s output=%s",
- *input_setnames, output_setname);
+ *input_setnames, output_setname);
sset = resultSetGet (zh, input_setnames[0]);
if (!sset)
{
- zh->errCode = 30;
- zh->errString = nmem_strdup (nmem, input_setnames[0]);
- return;
+ zh->errCode = 30;
+ zh->errString = nmem_strdup (nmem, input_setnames[0]);
+ return;
}
if (!(rset = sset->rset))
{
- zh->errCode = 30;
- zh->errString = nmem_strdup (nmem, input_setnames[0]);
+ zh->errCode = 30;
+ zh->errString = nmem_strdup (nmem, input_setnames[0]);
return;
}
if (strcmp (output_setname, input_setnames[0]))
{
- rset = rset_dup (rset);
- sset = resultSetAdd (zh, output_setname, 1);
+ rset = rset_dup (rset);
+ sset = resultSetAdd (zh, output_setname, 1);
sset->rset = rset;
}
resultSetSortSingle (zh, nmem, sset, rset, sort_sequence, sort_status);
}
void resultSetSortSingle (ZebraHandle zh, NMEM nmem,
- ZebraSet sset, RSET rset,
- Z_SortKeySpecList *sort_sequence, int *sort_status)
+ ZebraSet sset, RSET rset,
+ Z_SortKeySpecList *sort_sequence, int *sort_status)
{
int i;
zint psysno = 0;
struct it_key key;
struct sortKeyInfo sort_criteria[3];
int num_criteria;
- int term_index;
RSFD rfd;
yaz_log (LOG_LOG, "resultSetSortSingle start");
sset->hits = 0;
num_criteria = sort_sequence->num_specs;
if (num_criteria > 3)
- num_criteria = 3;
+ num_criteria = 3;
for (i = 0; i < num_criteria; i++)
{
- Z_SortKeySpec *sks = sort_sequence->specs[i];
- Z_SortKey *sk;
-
- if (*sks->sortRelation == Z_SortKeySpec_ascending)
- sort_criteria[i].relation = 'A';
- else if (*sks->sortRelation == Z_SortKeySpec_descending)
- sort_criteria[i].relation = 'D';
- else
- {
- zh->errCode = 214;
- return;
- }
- if (sks->sortElement->which == Z_SortElement_databaseSpecific)
- {
- zh->errCode = 210;
- return;
- }
- else if (sks->sortElement->which != Z_SortElement_generic)
- {
- zh->errCode = 237;
- return;
- }
- sk = sks->sortElement->u.generic;
- switch (sk->which)
- {
- case Z_SortKey_sortField:
- yaz_log (LOG_DEBUG, "Sort: key %d is of type sortField", i+1);
- zh->errCode = 207;
- return;
- case Z_SortKey_elementSpec:
- yaz_log (LOG_DEBUG, "Sort: key %d is of type elementSpec", i+1);
- zh->errCode = 207;
- return;
- case Z_SortKey_sortAttributes:
- yaz_log (LOG_DEBUG, "Sort: key %d is of type sortAttributes", i+1);
- sort_criteria[i].attrUse =
- zebra_maps_sort (zh->reg->zebra_maps,
- sk->u.sortAttributes,
+ Z_SortKeySpec *sks = sort_sequence->specs[i];
+ Z_SortKey *sk;
+
+ if (*sks->sortRelation == Z_SortKeySpec_ascending)
+ sort_criteria[i].relation = 'A';
+ else if (*sks->sortRelation == Z_SortKeySpec_descending)
+ sort_criteria[i].relation = 'D';
+ else
+ {
+ zh->errCode = 214;
+ return;
+ }
+ if (sks->sortElement->which == Z_SortElement_databaseSpecific)
+ {
+ zh->errCode = 210;
+ return;
+ }
+ else if (sks->sortElement->which != Z_SortElement_generic)
+ {
+ zh->errCode = 237;
+ return;
+ }
+ sk = sks->sortElement->u.generic;
+ switch (sk->which)
+ {
+ case Z_SortKey_sortField:
+ yaz_log (LOG_DEBUG, "Sort: key %d is of type sortField", i+1);
+ zh->errCode = 207;
+ return;
+ case Z_SortKey_elementSpec:
+ yaz_log (LOG_DEBUG, "Sort: key %d is of type elementSpec", i+1);
+ zh->errCode = 207;
+ return;
+ case Z_SortKey_sortAttributes:
+ yaz_log (LOG_DEBUG, "Sort: key %d is of type sortAttributes", i+1);
+ sort_criteria[i].attrUse =
+ zebra_maps_sort (zh->reg->zebra_maps,
+ sk->u.sortAttributes,
&sort_criteria[i].numerical);
- yaz_log (LOG_DEBUG, "use value = %d", sort_criteria[i].attrUse);
- if (sort_criteria[i].attrUse == -1)
- {
- zh->errCode = 116;
- return;
- }
- if (sortIdx_type (zh->reg->sortIdx, sort_criteria[i].attrUse))
- {
- zh->errCode = 207;
- return;
- }
- break;
- }
+ yaz_log (LOG_DEBUG, "use value = %d", sort_criteria[i].attrUse);
+ if (sort_criteria[i].attrUse == -1)
+ {
+ zh->errCode = 116;
+ return;
+ }
+ if (sortIdx_type (zh->reg->sortIdx, sort_criteria[i].attrUse))
+ {
+ zh->errCode = 207;
+ return;
+ }
+ break;
+ }
}
rfd = rset_open (rset, RSETF_READ);
- while (rset_read (rset, rfd, &key, &term_index))
+ while (rset_read (rset, rfd, &key))
{
#if IT_KEY_NEW
- zint this_sys = key.mem[0];
+ zint this_sys = key.mem[0];
#else
- zint this_sys = key.sysno;
+ zint this_sys = key.sysno;
#endif
if (this_sys != psysno)
{
- (sset->hits)++;
+ (sset->hits)++;
psysno = this_sys;
- resultSetInsertSort (zh, sset,
- sort_criteria, num_criteria, psysno);
+ resultSetInsertSort (zh, sset,
+ sort_criteria, num_criteria, psysno);
}
}
rset_close (rset, rfd);
-
+
+#if 0
for (i = 0; i < rset->no_rset_terms; i++)
- yaz_log (LOG_LOG, "term=\"%s\" nn=" ZINT_FORMAT " type=%s count=" ZINT_FORMAT,
+ yaz_log (LOG_LOG, "term=\"%s\" nn=" ZINT_FORMAT
+ " type=%s count=" ZINT_FORMAT,
rset->rset_terms[i]->name,
rset->rset_terms[i]->nn,
rset->rset_terms[i]->flags,
rset->rset_terms[i]->count);
-
+#endif
*sort_status = Z_SortResponse_success;
yaz_log (LOG_LOG, "resultSetSortSingle end");
}
ZebraSet s;
if ((s = resultSetGet (zh, resultSetId)))
- return s->rset;
+ return s->rset;
return NULL;
}
zint kno = 0;
struct it_key key;
RSFD rfd;
- int term_index, i;
+ /* int term_index; */
+ int i;
ZebraRankClass rank_class;
struct rank_control *rc;
struct zset_sort_info *sort_info;
}
rc = rank_class->control;
- if (rset_read (rset, rfd, &key, &term_index))
+ if (rset_read (rset, rfd, &key))
{
#if IT_KEY_NEW
- zint psysno = key.mem[0];
+ zint psysno = key.mem[0];
#else
- zint psysno = key.sysno;
+ zint psysno = key.sysno;
#endif
- int score;
- void *handle =
- (*rc->begin) (zh->reg, rank_class->class_handle, rset);
- (zebraSet->hits)++;
- esthits=atoi(res_get_def(zh->res,"estimatehits","0"));
- if (!esthits) est=-1; /* can not do */
- do
- {
+ int score;
+ void *handle =
+ (*rc->begin) (zh->reg, rank_class->class_handle, rset);
+ (zebraSet->hits)++;
+ esthits=atoi(res_get_def(zh->res,"estimatehits","0"));
+ if (!esthits)
+ est=-1; /* can not do */
+ do
+ {
#if IT_KEY_NEW
- zint this_sys = key.mem[0];
+ zint this_sys = key.mem[0];
#else
- zint this_sys = key.sysno;
+ zint this_sys = key.sysno;
#endif
- kno++;
- if (this_sys != psysno)
- {
- score = (*rc->calc) (handle, psysno);
-
- resultSetInsertRank (zh, sort_info, psysno, score, 'A');
- (zebraSet->hits)++;
- psysno = this_sys;
- }
- (*rc->add) (handle, this_sys, term_index);
+ kno++;
+ if (this_sys != psysno)
+ {
+ score = (*rc->calc) (handle, psysno);
+
+ resultSetInsertRank (zh, sort_info, psysno, score, 'A');
+ (zebraSet->hits)++;
+ psysno = this_sys;
+ }
+ /* FIXME - Ranking is broken, since rsets no longer have */
+ /* term lists! */
+ /* (*rc->add) (handle, this_sys, term_index); */
+
if ( (est==-2) && (zebraSet->hits==esthits))
{ /* time to estimate the hits */
rset_pos(rset,rfd,&cur,&tot);
zebraSet->hits=est;
}
}
- }
- while (rset_read (rset, rfd, &key, &term_index) && (est<0) );
+ }
+ while (rset_read (rset, rfd, &key) && (est<0) );
- score = (*rc->calc) (handle, psysno);
- resultSetInsertRank (zh, sort_info, psysno, score, 'A');
- (*rc->end) (zh->reg, handle);
+ score = (*rc->calc) (handle, psysno);
+ resultSetInsertRank (zh, sort_info, psysno, score, 'A');
+ (*rc->end) (zh->reg, handle);
}
rset_close (rset, rfd);
-
+/*
for (i = 0; i < rset->no_rset_terms; i++)
{
if (est>0)
rset->rset_terms[i]->flags,
rset->rset_terms[i]->count);
}
-
+*/
yaz_log (LOG_LOG, ZINT_FORMAT " keys, "ZINT_FORMAT" distinct sysnos",
kno, zebraSet->hits);
}
{
ZebraRankClass p = zh->reg->rank_classes;
while (p && strcmp (p->control->name, name))
- p = p->next;
+ p = p->next;
if (p && !p->init_flag)
{
- if (p->control->create)
- p->class_handle = (*p->control->create)(zh);
- p->init_flag = 1;
+ if (p->control->create)
+ p->class_handle = (*p->control->create)(zh);
+ p->init_flag = 1;
}
return p;
}
ZebraRankClass p = reg->rank_classes;
while (p)
{
- ZebraRankClass p_next = p->next;
- if (p->init_flag && p->control->destroy)
- (*p->control->destroy)(reg, p->class_handle);
- xfree (p->control->name);
- xfree (p->control);
- xfree (p);
- p = p_next;
+ ZebraRankClass p_next = p->next;
+ if (p->init_flag && p->control->destroy)
+ (*p->control->destroy)(reg, p->class_handle);
+ xfree (p->control->name);
+ xfree (p->control);
+ xfree (p);
+ p = p_next;
}
reg->rank_classes = NULL;
}
-/* $Id: zvrank.c,v 1.9 2004-08-06 12:28:22 adam Exp $
+/* $Id: zvrank.c,v 1.10 2004-08-20 14:44:46 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003
Index Data Aps
zint gocc;
/**/
yaz_log(LOG_DEBUG, "zv_begin");
- veclen=rset->no_rset_terms; /* smaller vector here */
+ veclen= 0 ; /* rset->no_rset_terms;*/ /* smaller vector here */
+ /* FIXME - Now that we don't have term lists in rsets, what do */
+ /* we do here ??? */
zv_init(rs, ci->rscheme);
rs->veclen=veclen;
prn_rs(rs);
/* yaz_log(LOG_DEBUG, "zv_begin_init"); */
for (i = 0; i < rs->veclen; i++)
{
- gocc=rset->rset_terms[i]->nn;
+ gocc= 0; /* rset->rset_terms[i]->nn; */ /* FIXME ??? */
/* yaz_log(LOG_DEBUG, "zv_begin_init i=%d gocc=%d", i, gocc); */
rs->qdoc->terms[i].gocc=gocc;
rs->qdoc->terms[i].locc=1; /* assume query has no duplicate terms */
-## $Id: Makefile.am,v 1.9 2004-08-16 16:17:49 heikki Exp $
+## $Id: Makefile.am,v 1.10 2004-08-20 14:44:46 heikki Exp $
noinst_LIBRARIES = librset.a
librset_a_SOURCES = rset.c rstemp.c rsnull.c rsbool.c rsbetween.c \
- rsisamc.c rsm_or.c rsmultior.c rsisams.c rsisamb.c rsprox.c
+ rsisamc.c rsmultior.c rsisams.c rsisamb.c rsprox.c
+
+#rsm_or.c removed
AM_CPPFLAGS = -I$(srcdir)/../include $(YAZINC)
-/* $Id: rsbetween.c,v 1.17 2004-08-06 14:09:02 heikki Exp $
+/* $Id: rsbetween.c,v 1.18 2004-08-20 14:44:46 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002
Index Data Aps
static void r_close_between (RSFD rfd);
static void r_delete_between (RSET ct);
static void r_rewind_between (RSFD rfd);
-static int r_forward_between(RSET ct, RSFD rfd, void *buf, int *term_index,
+static int r_forward_between(RSET ct, RSFD rfd, void *buf,
int (*cmpfunc)(const void *p1, const void *p2),
const void *untilbuf);
-static int r_read_between (RSFD rfd, void *buf, int *term_index);
+static int r_read_between (RSFD rfd, void *buf);
static int r_write_between (RSFD rfd, const void *buf);
static void r_pos_between (RSFD rfd, double *current, double *total);
RSET rset_m;
RSET rset_r;
RSET rset_attr;
- int term_index_s;
int (*cmp)(const void *p1, const void *p2);
char *(*printer)(const void *p1, char *buf);
struct rset_between_rfd *rfd_list;
int more_m;
int more_r;
int more_attr;
- int term_index_l;
- int term_index_m;
- int term_index_r;
void *buf_l;
void *buf_m;
void *buf_r;
info->cmp = between_parms->cmp;
info->printer = between_parms->printer;
info->rfd_list = NULL;
-
- info->term_index_s = info->rset_l->no_rset_terms;
- if (info->rset_m)
- {
- ct->no_rset_terms =
- info->rset_l->no_rset_terms +
- info->rset_m->no_rset_terms +
- info->rset_r->no_rset_terms;
- ct->rset_terms = (RSET_TERM *)
- xmalloc (sizeof (*ct->rset_terms) * ct->no_rset_terms);
- memcpy (ct->rset_terms, info->rset_l->rset_terms,
- info->rset_l->no_rset_terms * sizeof(*ct->rset_terms));
- memcpy (ct->rset_terms + info->rset_l->no_rset_terms,
- info->rset_m->rset_terms,
- info->rset_m->no_rset_terms * sizeof(*ct->rset_terms));
- memcpy (ct->rset_terms + info->rset_l->no_rset_terms +
- info->rset_m->no_rset_terms,
- info->rset_r->rset_terms,
- info->rset_r->no_rset_terms * sizeof(*ct->rset_terms));
- }
- else
- {
- ct->no_rset_terms =
- info->rset_l->no_rset_terms +
- info->rset_r->no_rset_terms;
- ct->rset_terms = (RSET_TERM *)
- xmalloc (sizeof (*ct->rset_terms) * ct->no_rset_terms);
- memcpy (ct->rset_terms, info->rset_l->rset_terms,
- info->rset_l->no_rset_terms * sizeof(*ct->rset_terms));
- memcpy (ct->rset_terms + info->rset_l->no_rset_terms,
- info->rset_r->rset_terms,
- info->rset_r->no_rset_terms * sizeof(*ct->rset_terms));
- }
-
return info;
}
rfd->rfd_m = rset_open (info->rset_m, RSETF_READ);
rfd->rfd_r = rset_open (info->rset_r, RSETF_READ);
- rfd->more_l = rset_read (info->rset_l, rfd->rfd_l, rfd->buf_l,
- &rfd->term_index_l);
- rfd->more_m = rset_read (info->rset_m, rfd->rfd_m, rfd->buf_m,
- &rfd->term_index_m);
- rfd->more_r = rset_read (info->rset_r, rfd->rfd_r, rfd->buf_r,
- &rfd->term_index_r);
+ rfd->more_l = rset_read (info->rset_l, rfd->rfd_l, rfd->buf_l);
+ rfd->more_m = rset_read (info->rset_m, rfd->rfd_m, rfd->buf_m);
+ rfd->more_r = rset_read (info->rset_r, rfd->rfd_r, rfd->buf_r);
if (info->rset_attr)
{
- int dummy;
rfd->rfd_attr = rset_open (info->rset_attr, RSETF_READ);
rfd->more_attr = rset_read (info->rset_attr, rfd->rfd_attr,
- rfd->buf_attr, &dummy);
+ rfd->buf_attr);
}
rfd->level=0;
rfd->hits=0;
struct rset_between_info *info = (struct rset_between_info *) ct->buf;
assert (info->rfd_list == NULL);
- xfree (ct->rset_terms);
rset_delete (info->rset_l);
rset_delete (info->rset_m);
rset_delete (info->rset_r);
rset_rewind (info->rset_l, p->rfd_l);
rset_rewind (info->rset_m, p->rfd_m);
rset_rewind (info->rset_r, p->rfd_r);
- p->more_l = rset_read (info->rset_l, p->rfd_l, p->buf_l, &p->term_index_l);
- p->more_m = rset_read (info->rset_m, p->rfd_m, p->buf_m, &p->term_index_m);
- p->more_r = rset_read (info->rset_r, p->rfd_r, p->buf_r, &p->term_index_r);
+ p->more_l = rset_read (info->rset_l, p->rfd_l, p->buf_l);
+ p->more_m = rset_read (info->rset_m, p->rfd_m, p->buf_m);
+ p->more_r = rset_read (info->rset_r, p->rfd_r, p->buf_r);
if (info->rset_attr)
{
- int dummy;
rset_rewind (info->rset_attr, p->rfd_attr);
- p->more_attr = rset_read (info->rset_attr, p->rfd_attr, p->buf_attr,
- &dummy);
+ p->more_attr = rset_read (info->rset_attr, p->rfd_attr, p->buf_attr);
}
p->level=0;
p->hits=0;
-static int r_forward_between(RSET ct, RSFD rfd, void *buf, int *term_index,
+static int r_forward_between(RSET ct, RSFD rfd, void *buf,
int (*cmpfunc)(const void *p1, const void *p2),
const void *untilbuf)
{
/* naturally forward the l, m, and attr pointers */
if (p->more_m)
p->more_m=rset_forward(info->rset_m,p->rfd_m, p->buf_m,
- &p->term_index_m, info->cmp,untilbuf);
+ info->cmp,untilbuf);
#if RSBETWEEN_DEBUG
log2( p, "fwd: after forward M", 0,0);
#endif
- rc = r_read_between(rfd, buf, term_index);
+ rc = r_read_between(rfd, buf);
#if RSBETWEEN_DEBUG
log2( p, "fwd: after forward", 0,0);
#endif
-static int r_read_between (RSFD rfd, void *buf, int *term_index)
+static int r_read_between (RSFD rfd, void *buf)
{
struct rset_between_rfd *p = (struct rset_between_rfd *) rfd;
struct rset_between_info *info = p->info;
else
{
int cmp_attr;
- int dummy_term;
attr_match = 0;
while (p->more_attr)
{
else if (cmp_attr > 0)
break;
else if (cmp_attr==-1)
- p->more_attr = rset_read (info->rset_attr, p->rfd_attr,
- p->buf_attr, &dummy_term);
+ p->more_attr = rset_read (info->rset_attr,
+ p->rfd_attr, p->buf_attr);
/* if we had a forward that went all the way to
* the seqno, we could use that. But fwd only goes
* to the sysno */
{
p->more_attr = rset_forward(
info->rset_attr, p->rfd_attr,
- p->buf_attr, &dummy_term,
- info->cmp, p->buf_l);
+ p->buf_attr, info->cmp, p->buf_l);
#if RSBETWEEN_DEBUG
logf(LOG_DEBUG, "btw: after frowarding attr m=%d",p->more_attr);
#endif
{
if (p->more_l)
{
- p->more_l=rset_forward(
- info->rset_l, p->rfd_l,
- p->buf_l, &p->term_index_l,
- info->cmp, p->buf_m);
+ p->more_l=rset_forward( info->rset_l, p->rfd_l,
+ p->buf_l, info->cmp, p->buf_m);
if (p->more_l)
cmp_l= (*info->cmp)(p->buf_l, p->buf_m);
else
}
} else
{
- p->more_l = rset_read (info->rset_l, p->rfd_l, p->buf_l,
- &p->term_index_l);
+ p->more_l = rset_read (info->rset_l, p->rfd_l, p->buf_l);
}
#else
- p->more_l = rset_read (info->rset_l, p->rfd_l, p->buf_l,
- &p->term_index_l);
+ p->more_l = rset_read (info->rset_l, p->rfd_l, p->buf_l);
#endif
if (p->more_l)
{
#if NEWCODE
if (cmp_r==-2)
{
- p->more_r=rset_forward(
- info->rset_r, p->rfd_r,
- p->buf_r, &p->term_index_r,
- info->cmp, p->buf_m);
+ p->more_r=rset_forward( info->rset_r, p->rfd_r,
+ p->buf_r, info->cmp, p->buf_m);
} else
{
- p->more_r = rset_read (info->rset_r, p->rfd_r, p->buf_r,
- &p->term_index_r);
+ p->more_r = rset_read (info->rset_r, p->rfd_r, p->buf_r);
}
if (p->more_r)
cmp_r= (*info->cmp)(p->buf_r, p->buf_m);
#else
- p->more_r = rset_read (info->rset_r, p->rfd_r, p->buf_r,
- &p->term_index_r);
+ p->more_r = rset_read (info->rset_r, p->rfd_r, p->buf_r);
cmp_r= (*info->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, info->key_size);
- *term_index = p->term_index_m;
#if RSBETWEEN_DEBUG
log2( p, "Returning a hit (and forwarding m)", cmp_l, cmp_r);
#endif
- p->more_m = rset_read (info->rset_m, p->rfd_m, p->buf_m,
- &p->term_index_m);
+ p->more_m = rset_read (info->rset_m, p->rfd_m, p->buf_m);
if (cmp_l == 2)
p->level = 0;
p->hits++;
if (cmp_l == 2)
{
p->level = 0;
- p->more_m=rset_forward(
- info->rset_m, p->rfd_m,
- p->buf_m, &p->term_index_m,
- info->cmp, p->buf_l);
+ p->more_m=rset_forward( info->rset_m, p->rfd_m,
+ p->buf_m, info->cmp, p->buf_l);
} else
{
- p->more_m = rset_read (info->rset_m, p->rfd_m, p->buf_m,
- &p->term_index_m);
+ p->more_m = rset_read (info->rset_m, p->rfd_m, p->buf_m);
}
#else
if (cmp_l == 2)
p->level = 0;
- p->more_m = rset_read (info->rset_m, p->rfd_m, p->buf_m,
- &p->term_index_m);
+ p->more_m = rset_read (info->rset_m, p->rfd_m, p->buf_m);
#endif
#if RSBETWEEN_DEBUG
log2( p, "End of M loop", cmp_l, cmp_r);
-/* $Id: rsbool.c,v 1.37 2004-08-06 14:09:02 heikki Exp $
+/* $Id: rsbool.c,v 1.38 2004-08-20 14:44:46 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
Index Data Aps
static void r_close (RSFD rfd);
static void r_delete (RSET ct);
static void r_rewind (RSFD rfd);
-static int r_forward(RSET ct, RSFD rfd, void *buf, int *term_index,
+static int r_forward(RSET ct, RSFD rfd, void *buf,
int (*cmpfunc)(const void *p1, const void *p2),
const void *untilbuf);
static void r_pos (RSFD rfd, double *current, double *total);
-static int r_read_and (RSFD rfd, void *buf, int *term_index);
-static int r_read_or (RSFD rfd, void *buf, int *term_index);
-static int r_read_not (RSFD rfd, void *buf, int *term_index);
+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_write (RSFD rfd, const void *buf);
static const struct rset_control control_and =
int key_size;
RSET rset_l;
RSET rset_r;
- int term_index_s;
int (*cmp)(const void *p1, const void *p2);
void (*log_item)(int logmask, const void *p, const char *txt);
struct rset_bool_rfd *rfd_list;
RSFD rfd_r;
int more_l;
int more_r;
- int term_index_l;
- int term_index_r;
void *buf_l;
void *buf_r;
int tail;
info->log_item = bool_parms->log_item;
info->rfd_list = NULL;
- info->term_index_s = info->rset_l->no_rset_terms;
- ct->no_rset_terms =
- info->rset_l->no_rset_terms + info->rset_r->no_rset_terms;
- ct->rset_terms = (RSET_TERM *)
- xmalloc (sizeof (*ct->rset_terms) * ct->no_rset_terms);
-
- memcpy (ct->rset_terms, info->rset_l->rset_terms,
- info->rset_l->no_rset_terms * sizeof(*ct->rset_terms));
- memcpy (ct->rset_terms + info->rset_l->no_rset_terms,
- info->rset_r->rset_terms,
- info->rset_r->no_rset_terms * sizeof(*ct->rset_terms));
return info;
}
if (flag & RSETF_WRITE)
{
- logf (LOG_FATAL, "bool set type is read-only");
- return NULL;
+ logf (LOG_FATAL, "bool set type is read-only");
+ return NULL;
}
rfd = (struct rset_bool_rfd *) xmalloc (sizeof(*rfd));
logf(LOG_DEBUG,"rsbool (%s) open [%p]", ct->control->desc, rfd);
rfd->buf_r = xmalloc (info->key_size);
rfd->rfd_l = rset_open (info->rset_l, RSETF_READ);
rfd->rfd_r = rset_open (info->rset_r, RSETF_READ);
- rfd->more_l = rset_read (info->rset_l, rfd->rfd_l, rfd->buf_l,
- &rfd->term_index_l);
- rfd->more_r = rset_read (info->rset_r, rfd->rfd_r, rfd->buf_r,
- &rfd->term_index_r);
+ rfd->more_l = rset_read (info->rset_l, rfd->rfd_l, rfd->buf_l);
+ rfd->more_r = rset_read (info->rset_r, rfd->rfd_r, rfd->buf_r);
rfd->tail = 0;
return rfd;
}
struct rset_bool_info *info = (struct rset_bool_info *) ct->buf;
assert (info->rfd_list == NULL);
- xfree (ct->rset_terms);
rset_delete (info->rset_l);
rset_delete (info->rset_r);
xfree (info);
logf (LOG_DEBUG, "rsbool_rewind");
rset_rewind (info->rset_l, p->rfd_l);
rset_rewind (info->rset_r, p->rfd_r);
- p->more_l = rset_read (info->rset_l, p->rfd_l, p->buf_l, &p->term_index_l);
- p->more_r = rset_read (info->rset_r, p->rfd_r, p->buf_r, &p->term_index_r);
+ p->more_l = rset_read (info->rset_l, p->rfd_l, p->buf_l);
+ p->more_r = rset_read (info->rset_r, p->rfd_r, p->buf_r);
p->hits=0;
}
-static int r_forward (RSET ct, RSFD rfd, void *buf, int *term_index,
+static int r_forward (RSET ct, RSFD rfd, void *buf,
int (*cmpfunc)(const void *p1, const void *p2),
const void *untilbuf)
{
#endif
if ( p->more_l && ((cmpfunc)(untilbuf,p->buf_l)==2) )
p->more_l = rset_forward(info->rset_l, p->rfd_l, p->buf_l,
- &p->term_index_l, info->cmp, untilbuf);
+ info->cmp, untilbuf);
#if RSET_DEBUG
logf (LOG_DEBUG, "rsbool_forward (R) [%p] '%s' (ct=%p rfd=%p m=%d,%d)",
rfd, ct->control->desc, ct, rfd, p->more_l, p->more_r);
#endif
if ( p->more_r && ((cmpfunc)(untilbuf,p->buf_r)==2))
p->more_r = rset_forward(info->rset_r, p->rfd_r, p->buf_r,
- &p->term_index_r, info->cmp, untilbuf);
+ info->cmp, untilbuf);
#if RSET_DEBUG
logf (LOG_DEBUG, "rsbool_forward [%p] calling read, m=%d,%d t=%d",
rfd, p->more_l, p->more_r, p->tail);
#endif
p->tail=0;
- rc = rset_read(ct,rfd,buf,term_index);
+ rc = rset_read(ct,rfd,buf);
#if RSET_DEBUG
logf (LOG_DEBUG, "rsbool_forward returning [%p] %d m=%d,%d",
rfd, rc, p->more_l, p->more_r);
3,1
*/
-static int r_read_and (RSFD rfd, void *buf, int *term_index)
+static int r_read_and (RSFD rfd, void *buf)
{
struct rset_bool_rfd *p = (struct rset_bool_rfd *) rfd;
struct rset_bool_info *info = p->info;
if (!cmp)
{
memcpy (buf, p->buf_l, info->key_size);
- *term_index = p->term_index_l;
- p->more_l = rset_read (info->rset_l, p->rfd_l, p->buf_l,
- &p->term_index_l);
+ p->more_l = rset_read (info->rset_l, p->rfd_l, p->buf_l);
p->tail = 1;
}
else if (cmp == 1)
{
memcpy (buf, p->buf_r, info->key_size);
- *term_index = p->term_index_r + info->term_index_s;
- p->more_r = rset_read (info->rset_r, p->rfd_r, p->buf_r,
- &p->term_index_r);
+ p->more_r = rset_read (info->rset_r, p->rfd_r, p->buf_r);
p->tail = 1;
#if RSET_DEBUG
logf (LOG_DEBUG, "r_read_and [%p] returning R m=%d/%d c=%d",
rfd, p->more_l, p->more_r, cmp);
key_logdump(LOG_DEBUG,buf);
- (*info->log_item)(LOG_DEBUG, buf, "");
+ (*info->log_item)(LOG_DEBUG, buf, "");
#endif
p->hits++;
return 1;
else if (cmp == -1)
{
memcpy (buf, p->buf_l, info->key_size);
- *term_index = p->term_index_l;
- p->more_l = rset_read (info->rset_l, p->rfd_l, p->buf_l,
- &p->term_index_l);
+ p->more_l = rset_read (info->rset_l, p->rfd_l, p->buf_l);
p->tail = 1;
#if RSET_DEBUG
logf (LOG_DEBUG, "r_read_and [%p] returning L m=%d/%d c=%d",
rfd, p->more_l, p->more_r, cmp);
- (*info->log_item)(LOG_DEBUG, buf, "");
+ (*info->log_item)(LOG_DEBUG, buf, "");
#endif
p->hits++;
return 1;
#define OLDCODE 0
#if OLDCODE
memcpy (buf, p->buf_r, info->key_size);
- *term_index = p->term_index_r + info->term_index_s;
- p->more_r = rset_read (info->rset_r, p->rfd_r, p->buf_r,
- &p->term_index_r);
+ p->more_r = rset_read (info->rset_r, p->rfd_r, p->buf_r);
if (p->tail)
{
if (!p->more_r || (*info->cmp)(p->buf_r, buf) > 1)
#if RSET_DEBUG
logf (LOG_DEBUG, "r_read_and returning C m=%d/%d c=%d",
p->more_l, p->more_r, cmp);
- (*info->log_item)(LOG_DEBUG, buf, "");
+ (*info->log_item)(LOG_DEBUG, buf, "");
#endif
p->hits++;
return 1;
if (p->tail)
{
memcpy (buf, p->buf_r, info->key_size);
- *term_index = p->term_index_r + info->term_index_s;
- p->more_r = rset_read (info->rset_r, p->rfd_r, p->buf_r,
- &p->term_index_r);
+ p->more_r = rset_read (info->rset_r, p->rfd_r, p->buf_r);
if (!p->more_r || (*info->cmp)(p->buf_r, buf) > 1)
p->tail = 0;
#if RSET_DEBUG
logf (LOG_DEBUG, "r_read_and [%p] returning R tail m=%d/%d c=%d",
rfd, p->more_l, p->more_r, cmp);
- (*info->log_item)(LOG_DEBUG, buf, "");
+ (*info->log_item)(LOG_DEBUG, buf, "");
#endif
p->hits++;
return 1;
}
- else
+ else
{
#if RSET_DEBUG
logf (LOG_DEBUG, "r_read_and [%p] about to forward R m=%d/%d c=%d",
rfd, p->more_l, p->more_r, cmp);
#endif
if (p->more_r && p->more_l)
- p->more_r = rset_forward(
- info->rset_r, p->rfd_r,
- p->buf_r, &p->term_index_r,
- (info->cmp), p->buf_l);
+ p->more_r = rset_forward( info->rset_r, p->rfd_r,
+ p->buf_r, (info->cmp), p->buf_l);
else
return 0; /* no point in reading further */
}
{
#if OLDCODE
memcpy (buf, p->buf_l, info->key_size);
- *term_index = p->term_index_l;
- p->more_l = rset_read (info->rset_l, p->rfd_l, p->buf_l,
- &p->term_index_l);
+ p->more_l = rset_read (info->rset_l, p->rfd_l, p->buf_l);
if (p->tail)
{
if (!p->more_l || (*info->cmp)(p->buf_l, buf) > 1)
#if RSET_DEBUG
logf (LOG_DEBUG, "r_read_and [%p] returning R tail m=%d/%d c=%d",
rfd, p->more_l, p->more_r, cmp);
- (*info->log_item)(LOG_DEBUG, buf, "");
+ (*info->log_item)(LOG_DEBUG, buf, "");
#endif
p->hits++;
return 1;
if (p->tail)
{
memcpy (buf, p->buf_l, info->key_size);
- *term_index = p->term_index_l;
- p->more_l = rset_read (info->rset_l, p->rfd_l, p->buf_l,
- &p->term_index_l);
+ p->more_l = rset_read (info->rset_l, p->rfd_l, p->buf_l);
if (!p->more_l || (*info->cmp)(p->buf_l, buf) > 1)
p->tail = 0;
#if RSET_DEBUG
logf (LOG_DEBUG, "r_read_and [%p] returning L tail m=%d/%d c=%d",
rfd, p->more_l, p->more_r, cmp);
- (*info->log_item)(LOG_DEBUG, buf, "");
+ (*info->log_item)(LOG_DEBUG, buf, "");
#endif
p->hits++;
return 1;
#endif
if (p->more_r && p->more_l)
p->more_l = rset_forward(
- /* p->more_l = rset_default_forward( */
info->rset_l, p->rfd_l,
- p->buf_l, &p->term_index_l,
- (info->cmp), p->buf_r);
+ p->buf_l, (info->cmp), p->buf_r);
else
return 0; /* no point in reading further */
}
return 0;
}
-static int r_read_or (RSFD rfd, void *buf, int *term_index)
+static int r_read_or (RSFD rfd, void *buf)
{
struct rset_bool_rfd *p = (struct rset_bool_rfd *) rfd;
struct rset_bool_info *info = p->info;
if (!cmp)
{
memcpy (buf, p->buf_l, info->key_size);
- *term_index = p->term_index_l;
- p->more_l = rset_read (info->rset_l, p->rfd_l, p->buf_l,
- &p->term_index_l);
- p->more_r = rset_read (info->rset_r, p->rfd_r, p->buf_r,
- &p->term_index_r);
+ p->more_l = rset_read (info->rset_l, p->rfd_l, p->buf_l);
+ p->more_r = rset_read (info->rset_r, p->rfd_r, p->buf_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, info->key_size);
- *term_index = p->term_index_r + info->term_index_s;
- p->more_r = rset_read (info->rset_r, p->rfd_r, p->buf_r,
- &p->term_index_r);
+ p->more_r = rset_read (info->rset_r, p->rfd_r, p->buf_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, info->key_size);
- *term_index = p->term_index_l;
- p->more_l = rset_read (info->rset_l, p->rfd_l, p->buf_l,
- &p->term_index_l);
+ p->more_l = rset_read (info->rset_l, p->rfd_l, p->buf_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, int *term_index)
+static int r_read_not (RSFD rfd, void *buf)
{
struct rset_bool_rfd *p = (struct rset_bool_rfd *) rfd;
struct rset_bool_info *info = p->info;
if (cmp < -1)
{
memcpy (buf, p->buf_l, info->key_size);
- *term_index = p->term_index_l;
- p->more_l = rset_read (info->rset_l, p->rfd_l, p->buf_l,
- &p->term_index_l);
+ p->more_l = rset_read (info->rset_l, p->rfd_l, p->buf_l);
p->hits++;
return 1;
}
else if (cmp > 1)
{
- p->more_r = rset_forward(
- info->rset_r, p->rfd_r,
- p->buf_r, &p->term_index_r,
- (info->cmp), p->buf_l);
+ p->more_r = rset_forward(
+ info->rset_r, p->rfd_r,
+ p->buf_r, (info->cmp), p->buf_l);
}
else
{
memcpy (buf, p->buf_l, info->key_size);
do
{
- p->more_l = rset_read (info->rset_l, p->rfd_l, p->buf_l,
- &p->term_index_l);
+ p->more_l = rset_read (info->rset_l, p->rfd_l, p->buf_l);
if (!p->more_l)
break;
cmp = (*info->cmp)(p->buf_l, buf);
} while (cmp >= -1 && cmp <= 1);
do
{
- p->more_r = rset_read (info->rset_r, p->rfd_r, p->buf_r,
- &p->term_index_r);
+ p->more_r = rset_read (info->rset_r, p->rfd_r, p->buf_r);
if (!p->more_r)
break;
cmp = (*info->cmp)(p->buf_r, buf);
-/* $Id: rset.c,v 1.24 2004-08-19 12:49:15 heikki Exp $
+/* $Id: rset.c,v 1.25 2004-08-20 14:44:46 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
Index Data Aps
#include <assert.h>
#include <rset.h>
-#include <../index/index.h> /* for log_keydump. Debugging only */
+/* #include <../index/index.h> */ /* for log_keydump. Debugging only */
RSET rset_create(const struct rset_control *sel, void *parms)
{
RSET rnew;
- int i;
logf (LOG_DEBUG, "rs_create(%s)", sel->desc);
rnew = (RSET) xmalloc(sizeof(*rnew));
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; i<rnew->no_rset_terms; i++)
- logf (LOG_DEBUG, " %s", rnew->rset_terms[i]->name);
return rnew;
}
(rs->count)--;
if (!rs->count)
{
- (*rs->control->f_delete)(rs);
- xfree(rs);
+ (*rs->control->f_delete)(rs);
+ xfree(rs);
}
}
*total=-1;
} /* rset_default_pos */
-int rset_default_forward(RSET ct, RSFD rfd, void *buf, int *term_index,
+int rset_default_forward(RSET ct, RSFD rfd, void *buf,
int (*cmpfunc)(const void *p1, const void *p2),
const void *untilbuf)
{
int cmp=2;
logf (LOG_DEBUG, "rset_default_forward starting '%s' (ct=%p rfd=%p)",
ct->control->desc, ct,rfd);
- key_logdump(LOG_DEBUG, untilbuf);
+ /* key_logdump(LOG_DEBUG, untilbuf); */
while ( (cmp==2) && (more))
{
logf (LOG_DEBUG, "rset_default_forward looping m=%d c=%d",more,cmp);
- more=rset_read(ct, rfd, buf, term_index);
+ more=rset_read(ct, rfd, buf);
if (more)
cmp=(*cmpfunc)(untilbuf,buf);
- if (more)
- key_logdump(LOG_DEBUG,buf);
+/* if (more)
+ key_logdump(LOG_DEBUG,buf); */
}
logf (LOG_DEBUG, "rset_default_forward exiting m=%d c=%d",more,cmp);
return more;
}
-RSET_TERM *rset_terms(RSET rs, int *no)
-{
- *no = rs->no_rset_terms;
- return rs->rset_terms;
-}
-
-RSET_TERM rset_term_create (const char *name, int length, const char *flags,
- int type)
-{
- RSET_TERM t = (RSET_TERM) xmalloc (sizeof(*t));
- if (!name)
- t->name = NULL;
- else if (length == -1)
- t->name = xstrdup (name);
- else
- {
- t->name = (char*) xmalloc (length+1);
- memcpy (t->name, name, length);
- t->name[length] = '\0';
- }
- if (!flags)
- t->flags = NULL;
- else
- t->flags = xstrdup (flags);
- t->nn = -1;
- t->count = 0;
- t->type = type;
- return t;
-}
-
-void rset_term_destroy (RSET_TERM t)
-{
- if (t) { /* rsmultior uses things without terms at all ! */
- 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;
-}
-/* $Id: rsisamb.c,v 1.14 2004-08-06 12:55:03 adam Exp $
+/* $Id: rsisamb.c,v 1.15 2004-08-20 14:44:46 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
Index Data Aps
static void r_close (RSFD rfd);
static void r_delete (RSET ct);
static void r_rewind (RSFD rfd);
-static int r_forward(RSET ct, RSFD rfd, void *buf, int *term_index,
+static int r_forward(RSET ct, RSFD rfd, void *buf,
int (*cmpfunc)(const void *p1, const void *p2),
const void *untilbuf);
static void r_pos (RSFD rfd, double *current, double *total);
-static int r_read (RSFD rfd, void *buf, int *term_index);
+static int r_read (RSFD rfd, void *buf);
static int r_write (RSFD rfd, const void *buf);
static const struct rset_control control =
ISAMB_PP pt;
struct rset_pp_info *next;
struct rset_isamb_info *info;
- zint *countp;
void *buf;
};
info->key_size = pt->key_size;
info->cmp = pt->cmp;
info->ispt_list = NULL;
- ct->no_rset_terms = 1;
- ct->rset_terms = (RSET_TERM *) xmalloc (sizeof(*ct->rset_terms));
- ct->rset_terms[0] = pt->rset_term;
return info;
}
info->ispt_list = ptinfo;
ptinfo->pt = isamb_pp_open (info->is, info->pos);
ptinfo->info = info;
- if (ct->rset_terms[0]->nn < 0)
- ct->rset_terms[0]->nn = isamb_pp_num (ptinfo->pt);
- ct->rset_terms[0]->count = 0;
- ptinfo->countp = &ct->rset_terms[0]->count;
ptinfo->buf = xmalloc (info->key_size);
return ptinfo;
}
logf (LOG_DEBUG, "rsisamb_delete");
assert (info->ispt_list == NULL);
- rset_term_destroy (ct->rset_terms[0]);
- xfree (ct->rset_terms);
xfree (info);
}
abort ();
}
-static int r_forward(RSET ct, RSFD rfd, void *buf, int *term_index,
+static int r_forward(RSET ct, RSFD rfd, void *buf,
int (*cmpfunc)(const void *p1, const void *p2),
const void *untilbuf)
{
#endif
}
-static int r_read (RSFD rfd, void *buf, int *term_index)
+static int r_read (RSFD rfd, void *buf)
{
struct rset_pp_info *pinfo = (struct rset_pp_info *) rfd;
int r;
- *term_index = 0;
r = isamb_pp_read(pinfo->pt, buf);
- if (r > 0)
- {
- if (*pinfo->countp == 0 || (*pinfo->info->cmp)(buf, pinfo->buf) > 1)
- {
- memcpy (pinfo->buf, buf, pinfo->info->key_size);
- (*pinfo->countp)++;
- }
- }
return r;
}
-/* $Id: rsisamc.c,v 1.17 2004-08-06 12:55:03 adam Exp $
+/* $Id: rsisamc.c,v 1.18 2004-08-20 14:44:46 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
Index Data Aps
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_read (RSFD rfd, void *buf);
static int r_write (RSFD rfd, const void *buf);
static const struct rset_control control =
info->key_size = pt->key_size;
info->cmp = pt->cmp;
info->ispt_list = NULL;
- ct->no_rset_terms = 1;
- ct->rset_terms = (RSET_TERM *) xmalloc (sizeof(*ct->rset_terms));
- ct->rset_terms[0] = pt->rset_term;
return info;
}
info->ispt_list = ptinfo;
ptinfo->pt = isc_pp_open (info->is, info->pos);
ptinfo->info = info;
- if (ct->rset_terms[0]->nn < 0)
- ct->rset_terms[0]->nn = isc_pp_num (ptinfo->pt);
- ct->rset_terms[0]->count = 0;
- ptinfo->countp = &ct->rset_terms[0]->count;
ptinfo->buf = xmalloc (info->key_size);
return ptinfo;
}
logf (LOG_DEBUG, "rsisamc_delete");
assert (info->ispt_list == NULL);
- rset_term_destroy (ct->rset_terms[0]);
- xfree (ct->rset_terms);
xfree (info);
}
abort ();
}
-static int r_read (RSFD rfd, void *buf, int *term_index)
+static int r_read (RSFD rfd, void *buf)
{
struct rset_pp_info *pinfo = (struct rset_pp_info *) rfd;
int r;
- *term_index = 0;
r = isc_pp_read(pinfo->pt, buf);
if (r > 0)
{
-/* $Id: rsisams.c,v 1.7 2004-08-04 09:59:03 heikki Exp $
+/* $Id: rsisams.c,v 1.8 2004-08-20 14:44:46 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_rewind (RSFD rfd);
-static int r_read (RSFD rfd, void *buf, int *term_index);
+static int r_read (RSFD rfd, void *buf);
static int r_write (RSFD rfd, const void *buf);
static const struct rset_control control =
info->is = pt->is;
info->pos = pt->pos;
info->ispt_list = NULL;
- ct->no_rset_terms = 1;
- ct->rset_terms = (RSET_TERM *) xmalloc (sizeof(*ct->rset_terms));
- ct->rset_terms[0] = pt->rset_term;
return info;
}
logf (LOG_DEBUG, "risams_open");
if (flag & RSETF_WRITE)
{
- logf (LOG_FATAL, "ISAMS set type is read-only");
- return NULL;
+ logf (LOG_FATAL, "ISAMS set type is read-only");
+ return NULL;
}
ptinfo = (struct rset_pp_info *) xmalloc (sizeof(*ptinfo));
ptinfo->next = info->ispt_list;
info->ispt_list = ptinfo;
ptinfo->pt = isams_pp_open (info->is, info->pos);
ptinfo->info = info;
- if (ct->rset_terms[0]->nn < 0)
- ct->rset_terms[0]->nn = isams_pp_num (ptinfo->pt);
return ptinfo;
}
logf (LOG_DEBUG, "rsisams_delete");
assert (info->ispt_list == NULL);
- rset_term_destroy (ct->rset_terms[0]);
- xfree (ct->rset_terms);
xfree (info);
}
}
-static int r_read (RSFD rfd, void *buf, int *term_index)
+static int r_read (RSFD rfd, void *buf)
{
- *term_index = 0;
return isams_pp_read( ((struct rset_pp_info*) rfd)->pt, buf);
}
-/* $Id: rsm_or.c,v 1.19 2004-08-16 16:17:49 heikki Exp $
+/* $Id: rsm_or.c,v 1.20 2004-08-20 14:44:46 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_rewind (RSFD rfd);
-static int r_read (RSFD rfd, void *buf, int *term_index);
+static int r_read (RSFD rfd, void *buf);
static int r_write (RSFD rfd, const void *buf);
static const struct rset_control control =
struct rset_mor_rfd *next;
struct rset_mor_info *info;
struct trunc_info *ti;
- zint *countp;
char *pbuf;
};
}
}
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);
-
+ rfd->pbuf = 0;
r_rewind (rfd);
return rfd;
}
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; i<ct->no_rset_terms; i++)
- rset_term_destroy (ct->rset_terms[i]);
- xfree (ct->rset_terms);
-
xfree (info);
}
}
-static int r_read (RSFD rfd, void *buf, int *term_index)
+static int r_read (RSFD rfd, void *buf)
{
struct rset_mor_rfd *mrfd = (struct rset_mor_rfd *) rfd;
struct trunc_info *ti = mrfd->ti;
if (!ti->heapnum)
return 0;
- *term_index = 0;
memcpy (buf, ti->heap[ti->ptr[1]], ti->keysize);
if (((struct rset_mor_rfd *) rfd)->position)
{
}
else
heap_delete (ti);
+ rfd->pbuf = xmalloc (info->key_size);
if (mrfd->countp && (
*mrfd->countp == 0 || (*ti->cmp)(buf, mrfd->pbuf) > 1))
{
-/* $Id: rsmultior.c,v 1.3 2004-08-19 14:11:54 heikki Exp $
+/* $Id: rsmultior.c,v 1.4 2004-08-20 14:44:46 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_rewind (RSFD rfd);
-static int r_read (RSFD rfd, void *buf, int *term_index);
+static int r_read (RSFD rfd, void *buf);
static int r_write (RSFD rfd, const void *buf);
-static int r_forward(RSET ct, RSFD rfd, void *buf, int *term_index,
+static int r_forward(RSET ct, RSFD rfd, void *buf,
int (*cmpfunc)(const void *p1, const void *p2),
const void *untilbuf);
static void r_pos (RSFD rfd, double *current, double *total);
int (*cmp)(const void *p1, const void *p2);
int no_rsets;
RSET *rsets;
- int term_index;
struct rset_multior_rfd *rfd_list;
};
HEAP h;
struct rset_multior_rfd *next;
struct rset_multior_info *info;
- zint *countp; /* inc at every new record we see */
zint hits; /* returned so far */
char *prevvalue; /* to see if we are in another record */
+ /* FIXME - is this really needed? */
};
#if 0
info->no_rsets= r_parms->no_rsets;
info->rsets=r_parms->rsets; /* now we own it! */
info->rfd_list=0;
- info->term_index=0 ; /* r_parms->rset_term; */ /*??*/ /*FIXME */
- 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;
}
struct rset_multior_rfd *rfd;
struct rset_multior_info *info = (struct rset_multior_info *) ct->buf;
int i;
- int dummy_termindex;
if (flag & RSETF_WRITE)
{
rfd->next = info->rfd_list;
rfd->info = info;
info->rfd_list = rfd;
- if (ct->no_rset_terms==1)
- rfd->countp=&ct->rset_terms[0]->count;
- else
- rfd->countp=0;
rfd->h = heap_create( info->no_rsets, info->key_size, info->cmp);
rfd->prevvalue=0;
rfd->hits=0;
rfd->items[i].fd=rset_open(info->rsets[i],RSETF_READ);
/* if (item_readbuf(&(rfd->items[i]))) */
if ( rset_read(rfd->items[i].rset, rfd->items[i].fd,
- rfd->items[i].buf, &dummy_termindex) )
+ rfd->items[i].buf) )
heap_insert(rfd->h, &(rfd->items[i]));
}
return rfd;
rset_delete(info->rsets[i]);
xfree(info->rsets);
xfree(info);
-
- for (i = 0; i<ct->no_rset_terms; i++) /* usually only 1 */
- rset_term_destroy (ct->rset_terms[i]);
- xfree (ct->rset_terms);
}
static void r_rewind (RSFD rfd)
}
-static int r_forward(RSET ct, RSFD rfd, void *buf, int *term_index,
+static int r_forward(RSET ct, RSFD rfd, void *buf,
int (*cmpfunc)(const void *p1, const void *p2),
const void *untilbuf)
{
struct rset_multior_info *info = mrfd->info;
struct heap_item it;
int rdres;
- int dummycount=0;
if (heap_empty(mrfd->h))
return 0;
if (cmpfunc)
assert(cmpfunc==mrfd->info->cmp);
- *term_index=0;
it = *(mrfd->h->heap[1]);
memcpy(buf,it.buf, info->key_size);
(mrfd->hits)++;
- if (mrfd->countp) {
- if (mrfd->prevvalue) { /* in another record */
- if ( (*mrfd->info->cmp)(mrfd->prevvalue,it.buf) < -1)
- (*mrfd->countp)++;
- } else {
- mrfd->prevvalue=xmalloc(info->key_size);
- (*mrfd->countp)++;
- }
- memcpy(mrfd->prevvalue,it.buf, info->key_size);
- }
if (untilbuf)
- rdres=rset_forward(it.rset, it.fd, it.buf, &dummycount,
- cmpfunc,untilbuf);
+ rdres=rset_forward(it.rset, it.fd, it.buf, cmpfunc,untilbuf);
else
- rdres=rset_read(it.rset, it.fd, it.buf, &dummycount);
+ rdres=rset_read(it.rset, it.fd, it.buf);
if ( rdres )
heap_balance(mrfd->h);
else
}
-static int r_read (RSFD rfd, void *buf, int *term_index)
+static int r_read (RSFD rfd, void *buf)
{
- return r_forward(0,rfd, buf, term_index,0,0);
+ return r_forward(0,rfd, buf,0,0);
}
static void r_pos (RSFD rfd, double *current, double *total)
-/* $Id: rsnull.c,v 1.20 2004-08-06 10:09:28 heikki Exp $
+/* $Id: rsnull.c,v 1.21 2004-08-20 14:44:46 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002
Index Data Aps
static void r_delete (RSET ct);
static void r_rewind (RSFD rfd);
static void r_pos (RSFD rfd, double *current, double *total);
-static int r_read (RSFD rfd, void *buf, int *term_index);
+static int r_read (RSFD rfd, void *buf);
static int r_write (RSFD rfd, const void *buf);
static const struct rset_control control =
static void *r_create(RSET ct, const struct rset_control *sel, void *parms)
{
- rset_null_parms *null_parms = (rset_null_parms *) parms;
-
- ct->no_rset_terms = 1;
- ct->rset_terms = (RSET_TERM *) xmalloc (sizeof(*ct->rset_terms));
- if (parms && null_parms->rset_term)
- ct->rset_terms[0] = null_parms->rset_term;
- else
- ct->rset_terms[0] = rset_term_create ("term", -1, "rank-0",
- 0);
- ct->rset_terms[0]->nn = 0;
-
return NULL;
}
static void r_delete (RSET ct)
{
- rset_term_destroy (ct->rset_terms[0]);
- xfree (ct->rset_terms);
}
static void r_rewind (RSFD rfd)
*current=0;
}
-static int r_read (RSFD rfd, void *buf, int *term_index)
+static int r_read (RSFD rfd, void *buf)
{
- *term_index = -1;
return 0;
}
-/* $Id: rsprox.c,v 1.8 2004-08-06 14:09:02 heikki Exp $
+/* $Id: rsprox.c,v 1.9 2004-08-20 14:44:46 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
Index Data Aps
static void r_close (RSFD rfd);
static void r_delete (RSET ct);
static void r_rewind (RSFD rfd);
-static int r_forward(RSET ct, RSFD rfd, void *buf, int *term_index,
+static int r_forward(RSET ct, RSFD rfd, void *buf,
int (*cmpfunc)(const void *p1, const void *p2),
const void *untilbuf);
-static int r_read (RSFD rfd, void *buf, int *term_index);
+static int r_read (RSFD rfd, void *buf);
static int r_write (RSFD rfd, const void *buf);
static void r_pos (RSFD rfd, double *current, double *total);
rset_prox_parms *prox_parms = (rset_prox_parms *) parms;
struct rset_prox_info *info;
int i;
+ /*
char prox_term[512];
int length_prox_term = 0;
zint min_nn = 10000000;
const char *flags = NULL;
int term_type = 0;
-
+*/
info = (struct rset_prox_info *) xmalloc (sizeof(*info));
memcpy(&info->p, prox_parms, sizeof(struct rset_prox_parms));
assert(info->p.rset_no >= 2);
info->p.rset = xmalloc(info->p.rset_no * sizeof(*info->p.rset));
memcpy(info->p.rset, prox_parms->rset,
- info->p.rset_no * sizeof(*info->p.rset));
+ info->p.rset_no * sizeof(*info->p.rset));
info->rfd_list = NULL;
for (i = 0; i<info->p.rset_no; i++)
- if (rset_is_volatile(info->p.rset[i]))
- ct->flags |= RSET_FLAG_VOLATILE;
+ if (rset_is_volatile(info->p.rset[i]))
+ ct->flags |= RSET_FLAG_VOLATILE;
+#if 0 /* This should all be about terms! */
*prox_term = '\0';
for (i = 0; i<info->p.rset_no; i++)
{
- int j;
- for (j = 0; j < info->p.rset[i]->no_rset_terms; j++)
- {
- const char *nflags = info->p.rset[i]->rset_terms[j]->flags;
- char *term = info->p.rset[i]->rset_terms[j]->name;
- int lterm = strlen(term);
- if (lterm + length_prox_term < sizeof(prox_term)-1)
- {
- if (length_prox_term)
- prox_term[length_prox_term++] = ' ';
- strcpy (prox_term + length_prox_term, term);
- length_prox_term += lterm;
- }
- if (min_nn > info->p.rset[i]->rset_terms[j]->nn)
- min_nn = info->p.rset[i]->rset_terms[j]->nn;
- flags = nflags;
+ int j;
+ for (j = 0; j < info->p.rset[i]->no_rset_terms; j++)
+ {
+ const char *nflags = info->p.rset[i]->rset_terms[j]->flags;
+ char *term = info->p.rset[i]->rset_terms[j]->name;
+ int lterm = strlen(term);
+ if (lterm + length_prox_term < sizeof(prox_term)-1)
+ {
+ if (length_prox_term)
+ prox_term[length_prox_term++] = ' ';
+ strcpy (prox_term + length_prox_term, term);
+ length_prox_term += lterm;
+ }
+ if (min_nn > info->p.rset[i]->rset_terms[j]->nn)
+ min_nn = info->p.rset[i]->rset_terms[j]->nn;
+ flags = nflags;
term_type = info->p.rset[i]->rset_terms[j]->type;
- }
+ }
}
-
- ct->no_rset_terms = 1;
- ct->rset_terms = (RSET_TERM *)
- xmalloc (sizeof (*ct->rset_terms) * ct->no_rset_terms);
-
- ct->rset_terms[0] = rset_term_create (prox_term, length_prox_term,
- flags, term_type);
+#endif
return info;
}
{
struct rset_prox_info *info = (struct rset_prox_info *) ct->buf;
struct rset_prox_rfd *rfd;
- int i, dummy;
+ int i;
if (flag & RSETF_WRITE)
{
- logf (LOG_FATAL, "prox set type is read-only");
- return NULL;
+ logf (LOG_FATAL, "prox set type is read-only");
+ return NULL;
}
rfd = (struct rset_prox_rfd *) xmalloc (sizeof(*rfd));
logf(LOG_DEBUG,"rsprox (%s) open [%p]", ct->control->desc, rfd);
rfd->buf = xmalloc(sizeof(*rfd->buf) * info->p.rset_no);
for (i = 0; i < info->p.rset_no; i++)
- rfd->buf[i] = xmalloc (info->p.key_size);
+ rfd->buf[i] = xmalloc (info->p.key_size);
rfd->rfd = xmalloc(sizeof(*rfd->rfd) * info->p.rset_no);
for (i = 0; i < info->p.rset_no; i++)
- rfd->rfd[i] = rset_open (info->p.rset[i], RSETF_READ);
+ rfd->rfd[i] = rset_open (info->p.rset[i], RSETF_READ);
for (i = 0; i < info->p.rset_no; i++)
- rfd->more[i] = rset_read (info->p.rset[i], rfd->rfd[i],
- rfd->buf[i], &dummy);
+ rfd->more[i] = rset_read (info->p.rset[i], rfd->rfd[i],
+ rfd->buf[i]);
rfd->hits=0;
return rfd;
}
for (rfdp = &info->rfd_list; *rfdp; rfdp = &(*rfdp)->next)
if (*rfdp == rfd)
{
- int i;
- for (i = 0; i<info->p.rset_no; i++)
- xfree ((*rfdp)->buf[i]);
- xfree ((*rfdp)->buf);
+ int i;
+ for (i = 0; i<info->p.rset_no; i++)
+ xfree ((*rfdp)->buf[i]);
+ xfree ((*rfdp)->buf);
xfree ((*rfdp)->more);
- for (i = 0; i<info->p.rset_no; i++)
- rset_close (info->p.rset[i], (*rfdp)->rfd[i]);
- xfree ((*rfdp)->rfd);
+ for (i = 0; i<info->p.rset_no; i++)
+ rset_close (info->p.rset[i], (*rfdp)->rfd[i]);
+ xfree ((*rfdp)->rfd);
*rfdp = (*rfdp)->next;
xfree (rfd);
int i;
assert (info->rfd_list == NULL);
- rset_term_destroy(ct->rset_terms[0]);
- xfree (ct->rset_terms);
for (i = 0; i<info->p.rset_no; i++)
- rset_delete (info->p.rset[i]);
+ rset_delete (info->p.rset[i]);
xfree (info->p.rset);
xfree (info);
}
{
struct rset_prox_info *info = ((struct rset_prox_rfd*)rfd)->info;
struct rset_prox_rfd *p = (struct rset_prox_rfd *) rfd;
- int dummy, i;
+ int i;
logf (LOG_DEBUG, "rsprox_rewind");
for (i = 0; i < info->p.rset_no; i++)
{
- rset_rewind (info->p.rset[i], p->rfd[i]);
- p->more[i] = rset_read (info->p.rset[i], p->rfd[i], p->buf[i], &dummy);
+ rset_rewind (info->p.rset[i], p->rfd[i]);
+ p->more[i] = rset_read (info->p.rset[i], p->rfd[i], p->buf[i]);
}
p->hits=0;
}
-static int r_forward (RSET ct, RSFD rfd, void *buf, int *term_index,
- int (*cmpfunc)(const void *p1, const void *p2),
- const void *untilbuf)
+static int r_forward (RSET ct, RSFD rfd, void *buf,
+ int (*cmpfunc)(const void *p1, const void *p2),
+ const void *untilbuf)
{
/* Note: CT is not used. We _can_ pass NULL for it */
struct rset_prox_info *info = ((struct rset_prox_rfd*)rfd)->info;
struct rset_prox_rfd *p = (struct rset_prox_rfd *) rfd;
int cmp=0;
int i;
- int dummy;
if (untilbuf)
{
- /* it's enough to forward first one. Other will follow
- automatically */
- if ( p->more[0] && ((cmpfunc)(untilbuf, p->buf[0]) >= 2) )
- p->more[0] = rset_forward(info->p.rset[0], p->rfd[0],
- p->buf[0], &dummy, info->p.cmp,
- untilbuf);
+ /* it's enough to forward first one. Other will follow
+ automatically */
+ if ( p->more[0] && ((cmpfunc)(untilbuf, p->buf[0]) >= 2) )
+ p->more[0] = rset_forward(info->p.rset[0], p->rfd[0],
+ p->buf[0], info->p.cmp,
+ untilbuf);
}
if (info->p.ordered && info->p.relation == 3 && info->p.exclusion == 0
- && info->p.distance == 1)
+ && info->p.distance == 1)
{
- while (p->more[0])
- {
- for (i = 1; i < info->p.rset_no; i++)
- {
- if (!p->more[i])
- {
- p->more[0] = 0; /* saves us a goto out of while loop. */
- break;
- }
- cmp = (*info->p.cmp) (p->buf[i], p->buf[i-1]);
- if (cmp > 1)
- {
- p->more[i-1] = rset_forward (info->p.rset[i-1],
- p->rfd[i-1],
- p->buf[i-1], &dummy,
- info->p.cmp,
- p->buf[i]);
- break;
- }
- else if (cmp == 1)
- {
- if ((*info->p.getseq)(p->buf[i-1]) +1 !=
- (*info->p.getseq)(p->buf[i]))
- {
- p->more[i-1] = rset_read (
- info->p.rset[i-1], p->rfd[i-1],
- p->buf[i-1], &dummy);
- break;
- }
- }
- else
- {
- p->more[i] = rset_forward (info->p.rset[i], p->rfd[i],
- p->buf[i], &dummy,
- info->p.cmp,
- p->buf[i-1]);
- break;
- }
- }
- if (i == p->info->p.rset_no)
- {
- memcpy (buf, p->buf[0], info->p.key_size);
- *term_index = 0;
-
- p->more[0] = rset_read (info->p.rset[0], p->rfd[0],
- p->buf[0], &dummy);
- p->hits++;
- return 1;
- }
- }
+ while (p->more[0])
+ {
+ for (i = 1; i < info->p.rset_no; i++)
+ {
+ if (!p->more[i])
+ {
+ p->more[0] = 0; /* saves us a goto out of while loop. */
+ break;
+ }
+ cmp = (*info->p.cmp) (p->buf[i], p->buf[i-1]);
+ if (cmp > 1)
+ {
+ p->more[i-1] = rset_forward (info->p.rset[i-1],
+ p->rfd[i-1],
+ p->buf[i-1],
+ info->p.cmp,
+ p->buf[i]);
+ break;
+ }
+ else if (cmp == 1)
+ {
+ if ((*info->p.getseq)(p->buf[i-1]) +1 !=
+ (*info->p.getseq)(p->buf[i]))
+ {
+ p->more[i-1] = rset_read ( info->p.rset[i-1],
+ p->rfd[i-1], p->buf[i-1]);
+ break;
+ }
+ }
+ else
+ {
+ p->more[i] = rset_forward (info->p.rset[i], p->rfd[i],
+ p->buf[i], info->p.cmp,
+ p->buf[i-1]);
+ break;
+ }
+ }
+ if (i == p->info->p.rset_no)
+ {
+ memcpy (buf, p->buf[0], info->p.key_size);
+ p->more[0] = rset_read (info->p.rset[0], p->rfd[0], p->buf[0]);
+ p->hits++;
+ return 1;
+ }
+ }
}
else if (info->p.rset_no == 2)
{
- while (p->more[0] && p->more[1])
- {
- int cmp = (*info->p.cmp)(p->buf[0], p->buf[1]);
- if (cmp < -1)
- p->more[0] = rset_forward (info->p.rset[0], p->rfd[0],
- p->buf[0],
- term_index, info->p.cmp, p->buf[0]);
- else if (cmp > 1)
- p->more[1] = rset_forward (info->p.rset[1], p->rfd[1],
- p->buf[1],
- term_index, info->p.cmp, p->buf[1]);
- else
- {
- int seqno[500];
- int n = 0;
-
- seqno[n++] = (*info->p.getseq)(p->buf[0]);
- while ((p->more[0] = rset_read (info->p.rset[0], p->rfd[0],
- p->buf[0],
- term_index)) >= -1 &&
- p->more[0] <= -1)
- if (n < 500)
- seqno[n++] = (*info->p.getseq)(p->buf[0]);
-
- for (i = 0; i<n; i++)
- {
- int diff = (*info->p.getseq)(p->buf[1]) - seqno[i];
- int excl = info->p.exclusion;
- if (!info->p.ordered && diff < 0)
- diff = -diff;
- switch (info->p.relation)
- {
- case 1: /* < */
- if (diff < info->p.distance && diff >= 0)
- excl = !excl;
- break;
- case 2: /* <= */
- if (diff <= info->p.distance && diff >= 0)
- excl = !excl;
- break;
- case 3: /* == */
- if (diff == info->p.distance && diff >= 0)
- excl = !excl;
- break;
- case 4: /* >= */
- if (diff >= info->p.distance && diff >= 0)
- excl = !excl;
- break;
- case 5: /* > */
- if (diff > info->p.distance && diff >= 0)
- excl = !excl;
- break;
- case 6: /* != */
- if (diff != info->p.distance && diff >= 0)
- excl = !excl;
- break;
- }
- if (excl)
- {
- memcpy (buf, p->buf[1], info->p.key_size);
- *term_index = 0;
-
- p->more[1] = rset_read (info->p.rset[1],
- p->rfd[1], p->buf[1],
- term_index);
- p->hits++;
- return 1;
- }
- }
- p->more[1] = rset_read (info->p.rset[1], p->rfd[1],
- p->buf[1],
- term_index);
- }
- }
+ while (p->more[0] && p->more[1])
+ {
+ int cmp = (*info->p.cmp)(p->buf[0], p->buf[1]);
+ if (cmp < -1)
+ p->more[0] = rset_forward (info->p.rset[0], p->rfd[0],
+ p->buf[0], info->p.cmp, p->buf[0]);
+ else if (cmp > 1)
+ p->more[1] = rset_forward (info->p.rset[1], p->rfd[1],
+ p->buf[1], info->p.cmp, p->buf[1]);
+ else
+ {
+ int seqno[500];
+ int n = 0;
+
+ seqno[n++] = (*info->p.getseq)(p->buf[0]);
+ while ((p->more[0] = rset_read (info->p.rset[0], p->rfd[0],
+ p->buf[0])) >= -1 &&
+ p->more[0] <= -1)
+ if (n < 500)
+ seqno[n++] = (*info->p.getseq)(p->buf[0]);
+
+ for (i = 0; i<n; i++)
+ {
+ int diff = (*info->p.getseq)(p->buf[1]) - seqno[i];
+ int excl = info->p.exclusion;
+ if (!info->p.ordered && diff < 0)
+ diff = -diff;
+ switch (info->p.relation)
+ {
+ case 1: /* < */
+ if (diff < info->p.distance && diff >= 0)
+ excl = !excl;
+ break;
+ case 2: /* <= */
+ if (diff <= info->p.distance && diff >= 0)
+ excl = !excl;
+ break;
+ case 3: /* == */
+ if (diff == info->p.distance && diff >= 0)
+ excl = !excl;
+ break;
+ case 4: /* >= */
+ if (diff >= info->p.distance && diff >= 0)
+ excl = !excl;
+ break;
+ case 5: /* > */
+ if (diff > info->p.distance && diff >= 0)
+ excl = !excl;
+ break;
+ case 6: /* != */
+ if (diff != info->p.distance && diff >= 0)
+ excl = !excl;
+ break;
+ }
+ if (excl)
+ {
+ memcpy (buf, p->buf[1], info->p.key_size);
+
+ p->more[1] = rset_read (info->p.rset[1],
+ p->rfd[1], p->buf[1]);
+ p->hits++;
+ return 1;
+ }
+ }
+ p->more[1] = rset_read (info->p.rset[1], p->rfd[1],
+ p->buf[1]);
+ }
+ }
}
return 0;
}
-static int r_read (RSFD rfd, void *buf, int *term_index)
+static int r_read (RSFD rfd, void *buf)
{
{ double cur,tot; r_pos(rfd,&cur,&tot); } /*!*/
- return r_forward(0, rfd, buf, term_index, 0, 0);
+ return r_forward(0, rfd, buf, 0, 0);
}
static int r_write (RSFD rfd, const void *buf)
-/* $Id: rstemp.c,v 1.42 2004-08-06 12:55:03 adam Exp $
+/* $Id: rstemp.c,v 1.43 2004-08-20 14:44:46 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003
Index Data Aps
static void r_delete (RSET ct);
static void r_rewind (RSFD rfd);
/* static int r_count (RSET ct);*/
-static int r_read (RSFD rfd, void *buf, int *term_index);
+static int r_read (RSFD rfd, void *buf);
static int r_write (RSFD rfd, const void *buf);
static void r_pos (RSFD rfd, double *current, double *total);
info->rfd_list = NULL;
if (!temp_parms->temp_path)
- info->temp_path = NULL;
+ info->temp_path = NULL;
else
{
- info->temp_path = (char *) xmalloc (strlen(temp_parms->temp_path)+1);
- strcpy (info->temp_path, temp_parms->temp_path);
+ info->temp_path = (char *) xmalloc (strlen(temp_parms->temp_path)+1);
+ strcpy (info->temp_path, temp_parms->temp_path);
}
- ct->no_rset_terms = 1;
- ct->rset_terms = (RSET_TERM *) xmalloc (sizeof(*ct->rset_terms));
- ct->rset_terms[0] = temp_parms->rset_term;
return info;
}
rfd->info = info;
r_rewind (rfd);
- rfd->countp = &ct->rset_terms[0]->count;
*rfd->countp = 0;
rfd->buf = xmalloc (info->key_size);
if (info->fname && info->fd != -1 && info->dirty)
{
size_t count;
- int r;
+ int r;
if (lseek (info->fd, info->pos_buf, SEEK_SET) == -1)
{
xfree (info->fname);
}
if (info->temp_path)
- xfree (info->temp_path);
- rset_term_destroy (ct->rset_terms[0]);
- xfree (ct->rset_terms);
+ xfree (info->temp_path);
xfree (info);
}
if (info->fname)
{
size_t count;
- int r;
+ int r;
info->pos_border = ((struct rset_temp_rfd *)rfd)->pos_cur +
info->buf_size;
return info->pos_end / info->key_size;
}
*/
-static int r_read (RSFD rfd, void *buf, int *term_index)
+static int r_read (RSFD rfd, void *buf)
{
struct rset_temp_rfd *mrfd = (struct rset_temp_rfd*) rfd;
struct rset_temp_info *info = mrfd->info;
memcpy (buf, info->buf_mem + (mrfd->pos_cur - info->pos_buf),
info->key_size);
mrfd->pos_cur = nc;
- *term_index = 0;
if (*mrfd->countp == 0 || (*info->cmp)(buf, mrfd->buf) > 1)
{
projects / idzebra-moved-to-github.git / commitdiff