-/* $Id: api.h,v 1.21 2005-05-01 20:43:11 adam Exp $
+/* $Id: api.h,v 1.22 2005-05-03 09:11:34 adam Exp $
Copyright (C) 1995-2005
Index Data ApS
YAZ_EXPORT
struct BFiles_struct *zebra_get_bfs(ZebraHandle zh);
+
+YAZ_EXPORT
+ZEBRA_RES zebra_set_limit(ZebraHandle zh, int exclude_flag, zint *ids);
+
YAZ_END_CDECL
/** \mainpage Zebra
-/* $Id: rset.h,v 1.50 2005-04-26 10:09:38 adam Exp $
+/* $Id: rset.h,v 1.51 2005-05-03 09:11:34 adam Exp $
Copyright (C) 1995-2005
Index Data ApS
* all we assume is that all keys are the same size, and they can be
* memcpy'd around
*/
-struct key_control {
+struct rset_key_control {
+ void *context;
int key_size;
int scope; /* default for what level we operate (book/chapter/verse) on*/
/* usual sysno/seqno is 2 */
- int (*cmp) (const void *p1, const void *p2);
+ int (*cmp)(const void *p1, const void *p2);
void (*key_logdump_txt) (int logmask, const void *p, const char *txt);
zint (*getseq)(const void *p);
- /* FIXME - Should not need a getseq, it won't make much sense with */
- /* higher-order keys. Use a (generalized) cmp instead, or something */
+ int (*filter_func)(const void *p, void *data);
+ void *filter_data;
+ void (*inc)(struct rset_key_control *kc);
+ void (*dec)(struct rset_key_control *kc);
+ /* FIXME - Should not need a getseq, it won't make much sense with */
+ /* higher-order keys. Use a (generalized) cmp instead, or something */
/* FIXME - decode and encode, and lots of other stuff */
};
typedef struct rset
{
const struct rset_control *control;
- const struct key_control *keycontrol;
+ struct rset_key_control *keycontrol;
int count; /* reference count */
void *priv; /* stuff private to the given type of rset */
NMEM nmem; /* nibble memory for various allocs */
RSET rset_create_base(const struct rset_control *sel,
NMEM nmem,
- const struct key_control *kcontrol,
+ struct rset_key_control *kcontrol,
int scope,
TERMID term);
/** rset_count counts or estimates the keys in it*/
zint rset_count(RSET rs);
-RSET rstemp_create(NMEM nmem, const struct key_control *kcontrol,
+RSET rstemp_create(NMEM nmem, struct rset_key_control *kcontrol,
int scope, const char *temp_path, TERMID term);
-RSET rsnull_create(NMEM nmem, const struct key_control *kcontrol);
+RSET rsnull_create(NMEM nmem, struct rset_key_control *kcontrol);
-RSET rsbool_create_and(NMEM nmem, const struct key_control *kcontrol,
+RSET rsbool_create_and(NMEM nmem, struct rset_key_control *kcontrol,
int scope, RSET rset_l, RSET rset_r);
-RSET rsbool_create_or (NMEM nmem, const struct key_control *kcontrol,
- int scope, RSET rset_l, RSET rset_r);
+RSET rsbool_create_or(NMEM nmem, struct rset_key_control *kcontrol,
+ int scope, RSET rset_l, RSET rset_r);
-RSET rsbool_create_not(NMEM nmem, const struct key_control *kcontrol,
+RSET rsbool_create_not(NMEM nmem, struct rset_key_control *kcontrol,
int scope, RSET rset_l, RSET rset_r);
-RSET rsbetween_create(NMEM nmem, const struct key_control *kcontrol,
+RSET rsbetween_create(NMEM nmem, struct rset_key_control *kcontrol,
int scope, RSET rset_l, RSET rset_m, RSET rset_r,
RSET rset_attr);
-RSET rsmulti_or_create(NMEM nmem, const struct key_control *kcontrol,
+RSET rsmulti_or_create(NMEM nmem, struct rset_key_control *kcontrol,
int scope, int no_rsets, RSET* rsets);
-RSET rsmulti_and_create(NMEM nmem, const struct key_control *kcontrol,
+RSET rsmulti_and_create(NMEM nmem, struct rset_key_control *kcontrol,
int scope, int no_rsets, RSET* rsets);
-RSET rsprox_create(NMEM nmem, const struct key_control *kcontrol,
+RSET rsprox_create(NMEM nmem, struct rset_key_control *kcontrol,
int scope, int rset_no, RSET *rset,
int ordered, int exclusion, int relation, int distance);
-RSET rsisamb_create(NMEM nmem, const struct key_control *kcontrol,
+RSET rsisamb_create(NMEM nmem, struct rset_key_control *kcontrol,
int scope, ISAMB is, ISAM_P pos, TERMID term);
-RSET rsisamc_create(NMEM nmem, const struct key_control *kcontrol,
+RSET rsisamc_create(NMEM nmem, struct rset_key_control *kcontrol,
int scope, ISAMC is, ISAM_P pos, TERMID term);
-RSET rsisams_create(NMEM nmem, const struct key_control *kcontrol,
+RSET rsisams_create(NMEM nmem, struct rset_key_control *kcontrol,
int scope, ISAMS is, ISAM_P pos, TERMID term);
-
YAZ_END_CDECL
#endif
-## $Id: Makefile.am,v 1.30 2005-04-01 10:15:13 adam Exp $
+## $Id: Makefile.am,v 1.31 2005-05-03 09:11:34 adam Exp $
noinst_PROGRAMS = apitest kdump
zebraapi.c zinfo.c invstat.c sortidx.c compact.c zsets.c zrpn.c \
rank1.c trunc.c retrieve.c extract.c \
index.h recindex.h recindxp.h \
- zinfo.h zserver.h zvrank.c
+ zinfo.h zserver.h zvrank.c limit.c kcontrol.c
bin_PROGRAMS = zebraidx zebrasrv zebrash
-/* $Id: index.h,v 1.135 2005-04-28 08:20:40 adam Exp $
+/* $Id: index.h,v 1.136 2005-05-03 09:11:34 adam Exp $
Copyright (C) 1995-2005
Index Data ApS
void *store_data_buf;
size_t store_data_size;
+
+ struct zebra_limit *m_limit;
};
struct rank_control {
struct term_set_entry *last;
};
+
+void zebra_limit_destroy(struct zebra_limit *zl);
+struct zebra_limit *zebra_limit_create(int exclude_flag, zint *ids);
+void zebra_limit_for_rset(struct zebra_limit *zl,
+ int (**filter_func)(const void *buf, void *data),
+ void (**filter_destroy)(void *data),
+ void **filter_data);
+
+struct rset_key_control *zebra_key_control_create(ZebraHandle zh);
+
ZEBRA_RES rpn_search_top(ZebraHandle zh, Z_RPNStructure *zs,
oid_value attributeSet,
NMEM stream, NMEM rset_nmem,
RSET rset_trunc (ZebraHandle zh, ISAM_P *isam_p, int no,
const char *term, int length_term, const char *flags,
int preserve_position, int term_type, NMEM rset_nmem,
- const struct key_control *kctrl, int scope);
+ struct rset_key_control *kctrl, int scope);
void resultSetAddTerm (ZebraHandle zh, ZebraSet s, int reg_type,
const char *db, int set,
--- /dev/null
+/* $Id: kcontrol.c,v 1.1 2005-05-03 09:11:34 adam Exp $
+ Copyright (C) 1995-2005
+ Index Data ApS
+
+This file is part of the Zebra server.
+
+Zebra is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2, or (at your option) any later
+version.
+
+Zebra is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License
+along with Zebra; see the file LICENSE.zebra. If not, write to the
+Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
+02111-1307, USA.
+*/
+
+#include <assert.h>
+#include "index.h"
+
+struct context_control {
+ int ref_count;
+ void (*filter_destroy)(void *data);
+};
+
+static void my_inc(struct rset_key_control *kc)
+{
+ struct context_control *cp;
+
+ assert(kc);
+ cp = kc->context;
+ (cp->ref_count)++;
+}
+
+static void my_dec(struct rset_key_control *kc)
+{
+ struct context_control *cp;
+
+ assert(kc);
+ cp = kc->context;
+ (cp->ref_count)--;
+ if (cp->ref_count == 0)
+ {
+ if (cp->filter_destroy)
+ (*cp->filter_destroy)(kc->filter_data);
+ xfree(cp);
+ xfree(kc);
+ }
+}
+
+struct rset_key_control *zebra_key_control_create(ZebraHandle zh)
+{
+ struct rset_key_control *kc = xmalloc(sizeof(*kc));
+ struct context_control *cp = xmalloc(sizeof(*cp));
+
+ kc->context = cp;
+ kc->key_size = sizeof(struct it_key);
+ kc->scope = 2;
+ kc->cmp = key_compare_it;
+ kc->key_logdump_txt = key_logdump_txt;
+ kc->getseq = key_get_seq;
+ zebra_limit_for_rset(zh->m_limit,
+ &kc->filter_func,
+ &cp->filter_destroy,
+ &kc->filter_data);
+ kc->inc = my_inc;
+ kc->dec = my_dec;
+ cp->ref_count = 1;
+ return kc;
+}
+
--- /dev/null
+/* $Id: limit.c,v 1.1 2005-05-03 09:11:34 adam Exp $
+ Copyright (C) 1995-2005
+ Index Data ApS
+
+This file is part of the Zebra server.
+
+Zebra is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2, or (at your option) any later
+version.
+
+Zebra is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License
+along with Zebra; see the file LICENSE.zebra. If not, write to the
+Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
+02111-1307, USA.
+*/
+
+#include <stdio.h>
+#include <assert.h>
+
+#include <yaz/xmalloc.h>
+#include <yaz/diagbib1.h>
+#include "index.h"
+
+struct zebra_limit {
+ int exclude_flag;
+ zint *ids;
+};
+
+void zebra_limit_destroy(struct zebra_limit *zl)
+{
+ if (zl)
+ {
+ xfree(zl->ids);
+ xfree(zl);
+ }
+}
+
+struct zebra_limit *zebra_limit_create(int exclude_flag, zint *ids)
+{
+ struct zebra_limit *zl = 0;
+ size_t i;
+ for (i = 0; ids && ids[i]; i++)
+ ;
+ if (i)
+ {
+ zl = xmalloc(sizeof(*zl));
+ zl->ids = xmalloc((i+1) * sizeof(*ids));
+ memcpy(zl->ids, ids, (i+1) * sizeof(*ids));
+ zl->exclude_flag = exclude_flag;
+ }
+ return zl;
+}
+
+static int zebra_limit_filter_cb(const void *buf, void *data)
+{
+ struct zebra_limit *zl = data;
+ const struct it_key *key = buf;
+ size_t i;
+
+ if (key->len != 3)
+ return 1;
+ for (i = 0; zl->ids[i]; i++)
+ if (zl->ids[i] == key->mem[1])
+ return zl->exclude_flag ? 0 : 1;
+ return zl->exclude_flag ? 1 : 0;
+}
+
+static void zebra_limit_destroy_cb(void *data)
+{
+ zebra_limit_destroy(data);
+}
+
+void zebra_limit_for_rset(struct zebra_limit *zl,
+ int (**filter_func)(const void *buf, void *data),
+ void (**filter_destroy)(void *data),
+ void **filter_data)
+{
+ if (zl && zl->ids)
+ {
+ struct zebra_limit *hl;
+
+ hl = zebra_limit_create(zl->exclude_flag, zl->ids);
+ *filter_data = hl;
+ *filter_func = zebra_limit_filter_cb;
+ *filter_destroy = zebra_limit_destroy_cb;
+ }
+ else
+ {
+ *filter_data = 0;
+ *filter_func = 0;
+ *filter_destroy = 0;
+ }
+}
+
-/* $Id: trunc.c,v 1.56 2005-04-20 10:21:29 adam Exp $
+/* $Id: trunc.c,v 1.57 2005-05-03 09:11:34 adam Exp $
Copyright (C) 1995-2005
Index Data ApS
const char *flags, ISAM_P *isam_p, int from, int to,
int merge_chunk, int preserve_position,
int term_type, NMEM rset_nmem,
- const struct key_control *kctrl, int scope,
+ struct rset_key_control *kctrl, int scope,
TERMID termid)
{
RSET result;
RSET rset_trunc(ZebraHandle zi, ISAM_P *isam_p, int no,
const char *term, int length, const char *flags,
int preserve_position, int term_type, NMEM rset_nmem,
- const struct key_control *kctrl, int scope)
+ struct rset_key_control *kctrl, int scope)
{
TERMID termid;
RSET result;
int trunc_chunk;
+
if (no < 1)
- return rsnull_create(rset_nmem,kctrl);
- termid = rset_term_create(term, length, flags, term_type,rset_nmem);
+ return rsnull_create(rset_nmem, kctrl);
+
+ termid = rset_term_create(term, length, flags, term_type, rset_nmem);
if (zi->reg->isams)
{
if (no == 1)
{
int trunc_limit = atoi(res_get_def(zi->res, "trunclimit", "10000"));
if (no == 1)
- return rsisamb_create(rset_nmem,kctrl, scope,
+ return rsisamb_create(rset_nmem, kctrl, scope,
zi->reg->isamb, *isam_p, termid);
else if (no < trunc_limit)
{
}
trunc_chunk = atoi(res_get_def(zi->res, "truncchunk", "100"));
result = rset_trunc_r(zi, term, length, flags, isam_p, 0, no, trunc_chunk,
- preserve_position, term_type, rset_nmem, kctrl, scope,
- termid);
+ preserve_position, term_type, rset_nmem, kctrl,
+ scope, termid);
return result;
}
-/* $Id: zebraapi.c,v 1.163 2005-04-28 08:20:40 adam Exp $
+/* $Id: zebraapi.c,v 1.164 2005-05-03 09:11:34 adam Exp $
Copyright (C) 1995-2005
Index Data ApS
zh->store_data_buf = 0;
+ zh->m_limit = zebra_limit_create(0, 0);
+
return zh;
}
xfree(zh->reg_name);
xfree(zh->user_perm);
zh->service = 0; /* more likely to trigger an assert */
+
+ zebra_limit_destroy(zh->m_limit);
+
xfree(zh->path_reg);
xfree(zh);
return ZEBRA_OK;
return sort_status;
}
+/* ---------------------------------------------------------------------------
+ Get BFS for Zebra system (to make alternative storage methods)
+*/
struct BFiles_struct *zebra_get_bfs(ZebraHandle zh)
{
if (zh && zh->reg)
return zh->reg->bfs;
return 0;
}
+
+
+/* ---------------------------------------------------------------------------
+ Set limit for search/scan
+*/
+ZEBRA_RES zebra_set_limit(ZebraHandle zh, int exclude_flag, zint *ids)
+{
+ ASSERTZH;
+ zebra_limit_destroy(zh->m_limit);
+ zh->m_limit = zebra_limit_create(exclude_flag, ids);
+ return ZEBRA_OK;
+}
-/* $Id: zrpn.c,v 1.185 2005-05-02 09:25:12 adam Exp $
+/* $Id: zrpn.c,v 1.186 2005-05-03 09:11:34 adam Exp $
Copyright (C) 1995-2005
Index Data ApS
#include <charmap.h>
#include <rset.h>
-static const struct key_control it_ctrl =
-{
- sizeof(struct it_key),
- 2, /* we have sysnos and seqnos in this key, nothing more */
- key_compare_it,
- key_logdump_txt, /* FIXME - clean up these functions */
- key_get_seq,
-};
-
-
-const struct key_control *key_it_ctrl = &it_ctrl;
-
struct rpn_char_map_info
{
ZebraMaps zm;
int num_bases, char **basenames,
char *term_dst, int xpath_use);
-static ZEBRA_RES term_trunc(ZebraHandle zh, Z_AttributesPlusTerm *zapt,
+static ZEBRA_RES term_trunc(ZebraHandle zh,
+ Z_AttributesPlusTerm *zapt,
const char **term_sub,
oid_value attributeSet, NMEM stream,
struct grep_info *grep_info,
char *term_dst,
const char *rank_type, int xpath_use,
NMEM rset_nmem,
- RSET *rset)
+ RSET *rset,
+ struct rset_key_control *kc)
{
ZEBRA_RES res;
*rset = 0;
grep_info->isam_p_indx, term_dst,
strlen(term_dst), rank_type, 1 /* preserve pos */,
zapt->term->which, rset_nmem,
- key_it_ctrl, key_it_ctrl->scope);
+ kc, kc->scope);
if (!*rset)
return ZEBRA_FAIL;
return ZEBRA_OK;
const char *rank_type, int xpath_use,
int num_bases, char **basenames,
NMEM rset_nmem,
- RSET **result_sets, int *num_result_sets)
+ RSET **result_sets, int *num_result_sets,
+ struct rset_key_control *kc)
{
char term_dst[IT_MAX_WORD+1];
struct grep_info grep_info;
num_bases, basenames,
term_dst, rank_type,
xpath_use, rset_nmem,
- &(*result_sets)[*num_result_sets]);
+ &(*result_sets)[*num_result_sets],
+ kc);
if (res != ZEBRA_OK)
{
int i;
const char *rank_type, int xpath_use,
int num_bases, char **basenames,
NMEM rset_nmem,
- RSET *rset)
+ RSET *rset,
+ struct rset_key_control *kc)
{
RSET *result_sets = 0;
int num_result_sets = 0;
rank_type, xpath_use,
num_bases, basenames,
rset_nmem,
- &result_sets, &num_result_sets);
+ &result_sets, &num_result_sets, kc);
if (res != ZEBRA_OK)
return res;
if (num_result_sets == 0)
- *rset = rsnull_create (rset_nmem, key_it_ctrl);
+ *rset = rsnull_create (rset_nmem, kc);
else if (num_result_sets == 1)
*rset = result_sets[0];
else
- *rset = rsprox_create(rset_nmem, key_it_ctrl, key_it_ctrl->scope,
+ *rset = rsprox_create(rset_nmem, kc, kc->scope,
num_result_sets, result_sets,
1 /* ordered */, 0 /* exclusion */,
3 /* relation */, 1 /* distance */);
int xpath_use,
int num_bases, char **basenames,
NMEM rset_nmem,
- RSET *rset)
+ RSET *rset,
+ struct rset_key_control *kc)
{
RSET *result_sets = 0;
int num_result_sets = 0;
rank_type, xpath_use,
num_bases, basenames,
rset_nmem,
- &result_sets, &num_result_sets);
+ &result_sets, &num_result_sets, kc);
if (res != ZEBRA_OK)
return res;
if (num_result_sets == 0)
- *rset = rsnull_create (rset_nmem, key_it_ctrl);
+ *rset = rsnull_create (rset_nmem, kc);
else if (num_result_sets == 1)
*rset = result_sets[0];
else
- *rset = rsmulti_or_create(rset_nmem, key_it_ctrl, key_it_ctrl->scope,
+ *rset = rsmulti_or_create(rset_nmem, kc, kc->scope,
num_result_sets, result_sets);
if (!*rset)
return ZEBRA_FAIL;
int xpath_use,
int num_bases, char **basenames,
NMEM rset_nmem,
- RSET *rset)
+ RSET *rset,
+ struct rset_key_control *kc)
{
RSET *result_sets = 0;
int num_result_sets = 0;
rank_type, xpath_use,
num_bases, basenames,
rset_nmem,
- &result_sets, &num_result_sets);
+ &result_sets, &num_result_sets,
+ kc);
if (res != ZEBRA_OK)
return res;
if (num_result_sets == 0)
- *rset = rsnull_create (rset_nmem, key_it_ctrl);
+ *rset = rsnull_create (rset_nmem, kc);
else if (num_result_sets == 1)
*rset = result_sets[0];
else
- *rset = rsmulti_and_create(rset_nmem, key_it_ctrl, key_it_ctrl->scope,
+ *rset = rsmulti_and_create(rset_nmem, kc, kc->scope,
num_result_sets, result_sets);
if (!*rset)
return ZEBRA_FAIL;
const char *rank_type, int xpath_use,
int num_bases, char **basenames,
NMEM rset_nmem,
- RSET *rset)
+ RSET *rset,
+ struct rset_key_control *kc)
{
char term_dst[IT_MAX_WORD+1];
const char *termp = termz;
strlen(term_dst), rank_type,
0 /* preserve position */,
zapt->term->which, rset_nmem,
- key_it_ctrl,key_it_ctrl->scope);
+ kc, kc->scope);
if (!result_sets[num_result_sets])
break;
num_result_sets++;
return ZEBRA_FAIL;
}
if (num_result_sets == 0)
- *rset = rsnull_create(rset_nmem, key_it_ctrl);
+ *rset = rsnull_create(rset_nmem, kc);
if (num_result_sets == 1)
*rset = result_sets[0];
else
- *rset = rsmulti_and_create(rset_nmem, key_it_ctrl, key_it_ctrl->scope,
+ *rset = rsmulti_and_create(rset_nmem, kc, kc->scope,
num_result_sets, result_sets);
if (!*rset)
return ZEBRA_FAIL;
oid_value attributeSet,
NMEM stream,
const char *rank_type, NMEM rset_nmem,
- RSET *rset)
+ RSET *rset,
+ struct rset_key_control *kc)
{
RSFD rsfd;
struct it_key key;
int sys;
- *rset = rstemp_create(rset_nmem,key_it_ctrl,key_it_ctrl->scope,
+ *rset = rstemp_create(rset_nmem, kc, kc->scope,
res_get (zh->res, "setTmpDir"),0 );
rsfd = rset_open(*rset, RSETF_WRITE);
oid_value attributeSet, NMEM stream,
Z_SortKeySpecList *sort_sequence,
const char *rank_type,
- RSET *rset)
+ RSET *rset,
+ struct rset_key_control *kc)
{
int i;
int sort_relation_value;
sks->which = Z_SortKeySpec_null;
sks->u.null = odr_nullval ();
sort_sequence->specs[i] = sks;
- *rset = rsnull_create (NULL, key_it_ctrl);
+ *rset = rsnull_create (NULL, kc);
return ZEBRA_OK;
}
static RSET xpath_trunc(ZebraHandle zh, NMEM stream,
int reg_type, const char *term, int use,
- oid_value curAttributeSet, NMEM rset_nmem)
+ oid_value curAttributeSet, NMEM rset_nmem,
+ struct rset_key_control *kc)
{
RSET rset;
struct grep_info grep_info;
const char *flags = "void";
if (grep_info_prepare(zh, 0 /* zapt */, &grep_info, '0', stream))
- return rsnull_create (rset_nmem,key_it_ctrl);
+ return rsnull_create(rset_nmem, kc);
if (ord < 0)
- return rsnull_create (rset_nmem,key_it_ctrl);
+ return rsnull_create(rset_nmem, kc);
if (prefix_len)
term_dict[prefix_len++] = '|';
else
rset = rset_trunc(zh, grep_info.isam_p_buf,
grep_info.isam_p_indx, term, strlen(term),
flags, 1, term_type,rset_nmem,
- key_it_ctrl, key_it_ctrl->scope);
+ kc, kc->scope);
grep_info_delete(&grep_info);
return rset;
}
int num_bases, char **basenames,
NMEM stream, const char *rank_type, RSET rset,
int xpath_len, struct xpath_location_step *xpath,
- NMEM rset_nmem)
+ NMEM rset_nmem,
+ struct rset_key_control *kc)
{
oid_value curAttributeSet = attributeSet;
int base_no;
wrbuf_puts(wbuf, "");
rset_attr = xpath_trunc(
zh, stream, '0', wrbuf_buf(wbuf), 3,
- curAttributeSet,rset_nmem);
+ curAttributeSet, rset_nmem, kc);
wrbuf_free(wbuf, 1);
}
else
if (strlen(xpath_rev))
{
rset_start_tag = xpath_trunc(zh, stream, '0',
- xpath_rev, 1, curAttributeSet, rset_nmem);
+ xpath_rev, 1, curAttributeSet, rset_nmem, kc);
rset_end_tag = xpath_trunc(zh, stream, '0',
- xpath_rev, 2, curAttributeSet, rset_nmem);
+ xpath_rev, 2, curAttributeSet, rset_nmem, kc);
- rset = rsbetween_create(rset_nmem, key_it_ctrl,
- key_it_ctrl->scope,
+ rset = rsbetween_create(rset_nmem, kc, kc->scope,
rset_start_tag, rset,
rset_end_tag, rset_attr);
}
return rset;
}
-
-
static ZEBRA_RES rpn_search_APT(ZebraHandle zh, Z_AttributesPlusTerm *zapt,
oid_value attributeSet, NMEM stream,
Z_SortKeySpecList *sort_sequence,
int num_bases, char **basenames,
NMEM rset_nmem,
- RSET *rset)
+ RSET *rset,
+ struct rset_key_control *kc)
{
ZEBRA_RES res = ZEBRA_OK;
unsigned reg_id;
if (sort_flag)
return rpn_sort_spec(zh, zapt, attributeSet, stream, sort_sequence,
- rank_type, rset);
+ rank_type, rset, kc);
xpath_len = parse_xpath(zh, zapt, attributeSet, xpath, 10, stream);
if (xpath_len >= 0)
{
reg_id, complete_flag, rank_type,
xpath_use,
num_bases, basenames, rset_nmem,
- rset);
+ rset, kc);
}
else if (!strcmp(search_type, "and-list"))
{
reg_id, complete_flag, rank_type,
xpath_use,
num_bases, basenames, rset_nmem,
- rset);
+ rset, kc);
}
else if (!strcmp(search_type, "or-list"))
{
reg_id, complete_flag, rank_type,
xpath_use,
num_bases, basenames, rset_nmem,
- rset);
+ rset, kc);
}
else if (!strcmp(search_type, "local"))
{
res = rpn_search_APT_local(zh, zapt, termz, attributeSet, stream,
- rank_type, rset_nmem, rset);
+ rank_type, rset_nmem, rset, kc);
}
else if (!strcmp(search_type, "numeric"))
{
res = rpn_search_APT_numeric(zh, zapt, termz, attributeSet, stream,
reg_id, complete_flag, rank_type,
xpath_use,
- num_bases, basenames, rset_nmem, rset);
+ num_bases, basenames, rset_nmem,
+ rset, kc);
}
else
{
return ZEBRA_FAIL;
*rset = rpn_search_xpath(zh, attributeSet, num_bases, basenames,
stream, rank_type, *rset,
- xpath_len, xpath, rset_nmem);
+ xpath_len, xpath, rset_nmem, kc);
if (!*rset)
return ZEBRA_FAIL;
return ZEBRA_OK;
Z_SortKeySpecList *sort_sequence,
int num_bases, char **basenames,
RSET **result_sets, int *num_result_sets,
- Z_Operator *parent_op);
+ Z_Operator *parent_op,
+ struct rset_key_control *kc);
ZEBRA_RES rpn_search_top(ZebraHandle zh, Z_RPNStructure *zs,
oid_value attributeSet,
{
RSET *result_sets = 0;
int num_result_sets = 0;
- ZEBRA_RES res = rpn_search_structure(zh, zs, attributeSet,
- stream, rset_nmem,
- sort_sequence,
- num_bases, basenames,
- &result_sets, &num_result_sets,
- 0 /* no op */);
+ ZEBRA_RES res;
+ struct rset_key_control *kc = zebra_key_control_create(zh);
+
+ res = rpn_search_structure(zh, zs, attributeSet,
+ stream, rset_nmem,
+ sort_sequence,
+ num_bases, basenames,
+ &result_sets, &num_result_sets,
+ 0 /* no parent op */,
+ kc);
if (res != ZEBRA_OK)
{
int i;
assert(result_sets);
assert(*result_sets);
*result_set = *result_sets;
+
+ (*kc->dec)(kc);
return ZEBRA_OK;
}
Z_SortKeySpecList *sort_sequence,
int num_bases, char **basenames,
RSET **result_sets, int *num_result_sets,
- Z_Operator *parent_op)
+ Z_Operator *parent_op,
+ struct rset_key_control *kc)
{
*num_result_sets = 0;
if (zs->which == Z_RPNStructure_complex)
sort_sequence,
num_bases, basenames,
&result_sets_l, &num_result_sets_l,
- zop);
+ zop, kc);
if (res != ZEBRA_OK)
{
int i;
sort_sequence,
num_bases, basenames,
&result_sets_r, &num_result_sets_r,
- zop);
+ zop, kc);
if (res != ZEBRA_OK)
{
int i;
switch (zop->which)
{
case Z_Operator_and:
- rset = rsmulti_and_create(rset_nmem, key_it_ctrl,
- key_it_ctrl->scope,
+ rset = rsmulti_and_create(rset_nmem, kc,
+ kc->scope,
*num_result_sets, *result_sets);
break;
case Z_Operator_or:
- rset = rsmulti_or_create(rset_nmem, key_it_ctrl,
- key_it_ctrl->scope,
+ rset = rsmulti_or_create(rset_nmem, kc,
+ kc->scope,
*num_result_sets, *result_sets);
break;
case Z_Operator_and_not:
- rset = rsbool_create_not(rset_nmem, key_it_ctrl,
- key_it_ctrl->scope,
+ rset = rsbool_create_not(rset_nmem, kc,
+ kc->scope,
(*result_sets)[0],
(*result_sets)[1]);
break;
}
else
{
- rset = rsprox_create(rset_nmem, key_it_ctrl,
- key_it_ctrl->scope,
+ rset = rsprox_create(rset_nmem, kc,
+ kc->scope,
*num_result_sets, *result_sets,
*zop->u.prox->ordered,
(!zop->u.prox->exclusion ?
yaz_log(YLOG_DEBUG, "rpn_search_APT");
res = rpn_search_APT(zh, zs->u.simple->u.attributesPlusTerm,
attributeSet, stream, sort_sequence,
- num_bases, basenames, rset_nmem, &rset);
+ num_bases, basenames, rset_nmem, &rset,
+ kc);
if (res != ZEBRA_OK)
return res;
}
int complete_flag;
int sort_flag;
NMEM rset_nmem = NULL;
+ struct rset_key_control *kc = 0;
*list = 0;
*is_partial = 0;
odr_malloc(stream, (before+after)*sizeof(*glist));
rset_nmem = nmem_create();
+ kc = zebra_key_control_create(zh);
/* consider terms after main term */
for (i = 0; i < ord_no; i++)
rset = rset_trunc(zh, &scan_info_array[j0].list[ptr[j0]].isam_p, 1,
glist[lo].term, strlen(glist[lo].term),
NULL, 0, zapt->term->which, rset_nmem,
- key_it_ctrl,key_it_ctrl->scope);
+ kc, kc->scope);
}
ptr[j0]++; /* move index for this set .. */
/* get result set for remaining scan terms */
glist[lo].term,
strlen(glist[lo].term), NULL, 0,
zapt->term->which,rset_nmem,
- key_it_ctrl, key_it_ctrl->scope);
- rset = rsmulti_or_create(rset_nmem, key_it_ctrl,
- 2, key_it_ctrl->scope, rsets);
+ kc, kc->scope);
+ rset = rsmulti_or_create(rset_nmem, kc,
+ 2, kc->scope, rsets);
}
ptr[j]++;
}
rsets[0] = rset;
rsets[1] = rset_dup(limit_set);
- rset = rsmulti_and_create(rset_nmem, key_it_ctrl,
- key_it_ctrl->scope, 2, rsets);
+ rset = rsmulti_and_create(rset_nmem, kc,
+ kc->scope, 2, rsets);
}
/* count it */
count_set(rset, &glist[lo].occurrences);
*is_partial = 1;
if (*num_entries < 0)
{
+ (*kc->dec)(kc);
+ nmem_destroy(rset_nmem);
*num_entries = 0;
return ZEBRA_OK;
}
(zh, &scan_info_array[j0].list[before-1-ptr[j0]].isam_p, 1,
glist[lo].term, strlen(glist[lo].term),
NULL, 0, zapt->term->which,rset_nmem,
- key_it_ctrl,key_it_ctrl->scope);
+ kc, kc->scope);
ptr[j0]++;
glist[lo].term,
strlen(glist[lo].term), NULL, 0,
zapt->term->which, rset_nmem,
- key_it_ctrl, key_it_ctrl->scope);
- rset = rsmulti_or_create(rset_nmem, key_it_ctrl,
- 2, key_it_ctrl->scope, rsets);
+ kc, kc->scope);
+ rset = rsmulti_or_create(rset_nmem, kc,
+ 2, kc->scope, rsets);
ptr[j]++;
}
rsets[0] = rset;
rsets[1] = rset_dup(limit_set);
- rset = rsmulti_and_create(rset_nmem, key_it_ctrl,
- key_it_ctrl->scope, 2, rsets);
+ rset = rsmulti_and_create(rset_nmem, kc,
+ kc->scope, 2, rsets);
}
count_set (rset, &glist[lo].occurrences);
rset_delete (rset);
}
+ (*kc->dec)(kc);
+ nmem_destroy(rset_nmem);
i = before-i;
if (i)
{
}
}
- nmem_destroy(rset_nmem);
*list = glist + i; /* list is set to first 'real' entry */
yaz_log(YLOG_DEBUG, "position = %d, num_entries = %d",
-/* $Id: rsbetween.c,v 1.37 2005-04-26 10:09:38 adam Exp $
+/* $Id: rsbetween.c,v 1.38 2005-05-03 09:11:35 adam Exp $
Copyright (C) 1995-2005
Index Data ApS
}
-RSET rsbetween_create( NMEM nmem, const struct key_control *kcontrol,
- int scope,
- RSET rset_l, RSET rset_m, RSET rset_r, RSET rset_attr)
+RSET rsbetween_create(NMEM nmem, struct rset_key_control *kcontrol,
+ int scope,
+ RSET rset_l, RSET rset_m, RSET rset_r, RSET rset_attr)
{
RSET rnew = rset_create_base(&control, nmem, kcontrol, scope,0);
struct rset_between_info *info=
static void checkattr(RSFD rfd)
{
- struct rset_between_info *info =(struct rset_between_info *)rfd->rset->priv;
- struct rset_between_rfd *p=(struct rset_between_rfd *)rfd->priv;
- const struct key_control *kctrl = rfd->rset->keycontrol;
+ struct rset_between_info *info =(struct rset_between_info *)
+ rfd->rset->priv;
+ struct rset_between_rfd *p = (struct rset_between_rfd *)rfd->priv;
+ const struct rset_key_control *kctrl = rfd->rset->keycontrol;
int cmp;
if (p->attrdepth)
return; /* already found one */
static int r_read(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;
- const struct key_control *kctrl = rfd->rset->keycontrol;
+ struct rset_between_info *info =
+ (struct rset_between_info *)rfd->rset->priv;
+ struct rset_between_rfd *p = (struct rset_between_rfd *)rfd->priv;
+ const struct rset_key_control *kctrl = rfd->rset->keycontrol;
int cmp;
TERMID dummyterm = 0;
yaz_log(log_level,"== read: term=%p",term);
-/* $Id: rsbool.c,v 1.54 2005-04-26 10:09:38 adam Exp $
+/* $Id: rsbool.c,v 1.55 2005-05-03 09:11:36 adam Exp $
Copyright (C) 1995-2005
Index Data ApS
r_write,
};
-struct rset_bool_info {
+struct rset_private {
RSET rset_l;
RSET rset_r;
};
-struct rset_bool_rfd {
+struct rfd_private {
zint hits;
RSFD rfd_l;
RSFD rfd_r;
};
static RSET rsbool_create_base(const struct rset_control *ctrl,
- NMEM nmem, const struct key_control *kcontrol,
+ NMEM nmem,
+ struct rset_key_control *kcontrol,
int scope, RSET rset_l, RSET rset_r)
{
- 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));
+ RSET rnew = rset_create_base(ctrl, nmem, kcontrol, scope, 0);
+ struct rset_private *info;
+ info = (struct rset_private *) nmem_malloc(rnew->nmem, sizeof(*info));
info->rset_l = rset_l;
info->rset_r = rset_r;
rnew->priv = info;
return rnew;
}
-RSET rsbool_create_and( NMEM nmem, const struct key_control *kcontrol,
+RSET rsbool_create_and( NMEM nmem, struct rset_key_control *kcontrol,
int scope, RSET rset_l, RSET rset_r)
{
return rsbool_create_base(&control_and, nmem, kcontrol,
rset_l, rset_r);
}
-RSET rsbool_create_or( NMEM nmem, const struct key_control *kcontrol,
- int scope, RSET rset_l, RSET rset_r)
+RSET rsbool_create_or(NMEM nmem, struct rset_key_control *kcontrol,
+ int scope, RSET rset_l, RSET rset_r)
{
return rsbool_create_base(&control_or, nmem, kcontrol,
scope, rset_l, rset_r);
}
-RSET rsbool_create_not( NMEM nmem, const struct key_control *kcontrol,
- int scope, RSET rset_l, RSET rset_r)
+RSET rsbool_create_not(NMEM nmem, struct rset_key_control *kcontrol,
+ int scope, RSET rset_l, RSET rset_r)
{
return rsbool_create_base(&control_not, nmem, kcontrol,
scope, rset_l, rset_r);
}
-static void r_delete (RSET ct)
+static void r_delete(RSET ct)
{
- struct rset_bool_info *info = (struct rset_bool_info *) ct->priv;
+ struct rset_private *info = (struct rset_private *) ct->priv;
rset_delete (info->rset_l);
rset_delete (info->rset_r);
}
-
-static RSFD r_open (RSET ct, int flag)
+static RSFD r_open(RSET ct, int flag)
{
- struct rset_bool_info *info = (struct rset_bool_info *) ct->priv;
+ struct rset_private *info = (struct rset_private *) ct->priv;
RSFD rfd;
- struct rset_bool_rfd *p;
-
+ struct rfd_private *p;
if (flag & RSETF_WRITE)
{
}
rfd = rfd_create_base(ct);
if (rfd->priv)
- p = (struct rset_bool_rfd *)rfd->priv;
+ p = (struct rfd_private *)rfd->priv;
else {
p = nmem_malloc(ct->nmem,sizeof(*p));
rfd->priv = p;
static void r_close (RSFD rfd)
{
- /* struct rset_bool_info *info = (struct rset_bool_info*)(rfd->rset->priv); */
- struct rset_bool_rfd *prfd=(struct rset_bool_rfd *)rfd->priv;
+ struct rfd_private *prfd=(struct rfd_private *)rfd->priv;
rset_close (prfd->rfd_l);
rset_close (prfd->rfd_r);
rfd_delete_base(rfd);
}
-
-
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;
+ struct rfd_private *p = (struct rfd_private *)rfd->priv;
+ const struct rset_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, &p->term_l, untilbuf);
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;
+ struct rfd_private *p=(struct rfd_private *)rfd->priv;
+ const struct rset_key_control *kctrl=rfd->rset->keycontrol;
while (p->more_l || p->more_r)
{
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;
+ struct rfd_private *p = (struct rfd_private *)rfd->priv;
+ const struct rset_key_control *kctrl = rfd->rset->keycontrol;
while (p->more_l || p->more_r)
{
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;
+ struct rfd_private *p = (struct rfd_private *)rfd->priv;
+ const struct rset_key_control *kctrl = rfd->rset->keycontrol;
while (p->more_l || p->more_r)
{
static void r_pos(RSFD rfd, double *current, double *total)
{
- struct rset_bool_rfd *p = (struct rset_bool_rfd *)rfd->priv;
+ struct rfd_private *p = (struct rfd_private *)rfd->priv;
double lcur, ltot;
double rcur, rtot;
double r;
static void r_get_terms(RSET ct, TERMID *terms, int maxterms, int *curterm)
{
- struct rset_bool_info *info = (struct rset_bool_info *) ct->priv;
+ struct rset_private *info = (struct rset_private *) ct->priv;
rset_getterms(info->rset_l, terms, maxterms, curterm);
rset_getterms(info->rset_r, terms, maxterms, curterm);
}
-/* $Id: rset.c,v 1.44 2005-03-30 09:25:24 adam Exp $
+/* $Id: rset.c,v 1.45 2005-05-03 09:11:36 adam Exp $
Copyright (C) 1995-2005
Index Data ApS
else
{
rnew = nmem_malloc(rs->nmem, sizeof(*rnew));
- rnew->priv = NULL;
+ rnew->priv = 0;
rnew->rset = rs;
yaz_log(log_level, "rfd_create_base (new): rfd=%p rs=%p fl=%p priv=%p",
rnew, rs, rs->free_list, rnew->priv);
}
RSET rset_create_base(const struct rset_control *sel,
- NMEM nmem, const struct key_control *kcontrol,
+ NMEM nmem, struct rset_key_control *kcontrol,
int scope, TERMID term)
{
RSET rnew;
rnew->free_list = NULL;
rnew->use_list = NULL;
rnew->keycontrol = kcontrol;
+ (*kcontrol->inc)(kcontrol);
rnew->scope = scope;
rnew->term = term;
if (term)
yaz_log(YLOG_WARN, "rs_delete(%s) still has RFDs in use",
rs->control->desc);
(*rs->control->f_delete)(rs);
+ (*rs->keycontrol->dec)(rs->keycontrol);
if (rs->my_nmem)
nmem_destroy(rs->nmem);
}
(rs->count)++;
yaz_log(log_level, "rs_dup(%s), rs=%p, count=%d",
rs->control->desc, rs, rs->count);
+ (*rs->keycontrol->inc)(rs->keycontrol);
return rs;
}
-/* $Id: rsisamb.c,v 1.32 2005-04-26 10:09:38 adam Exp $
+/* $Id: rsisamb.c,v 1.33 2005-05-03 09:11:36 adam Exp $
Copyright (C) 1995-2005
Index Data ApS
#include <rset.h>
#include <string.h>
-
-static RSFD r_open (RSET ct, int flag);
-static void r_close (RSFD rfd);
-static void r_delete (RSET ct);
+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, TERMID *term, const void *untilbuf);
-static void r_pos (RSFD rfd, double *current, double *total);
-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 int r_read(RSFD rfd, void *buf, TERMID *term);
+static int r_read_filter(RSFD rfd, void *buf, TERMID *term);
+static int r_write(RSFD rfd, const void *buf);
static const struct rset_control control =
{
r_write,
};
-struct rset_pp_info {
+static const struct rset_control control_filter =
+{
+ "isamb",
+ r_delete,
+ rset_get_one_term,
+ r_open,
+ r_close,
+ r_forward,
+ r_pos,
+ r_read_filter,
+ r_write,
+};
+
+struct rfd_private {
ISAMB_PP pt;
void *buf;
};
-struct rset_isamb_info {
+struct rset_private {
ISAMB is;
ISAM_P pos;
};
static int log_level = 0;
static int log_level_initialized = 0;
-RSET rsisamb_create(NMEM nmem, const struct key_control *kcontrol, int scope,
+RSET rsisamb_create(NMEM nmem, struct rset_key_control *kcontrol,
+ int scope,
ISAMB is, ISAM_P pos, TERMID term)
{
- RSET rnew = rset_create_base(&control, nmem, kcontrol, scope, term);
- struct rset_isamb_info *info;
+ RSET rnew = rset_create_base(
+ kcontrol->filter_func ? &control_filter : &control,
+ nmem, kcontrol, scope, term);
+ struct rset_private *info;
if (!log_level_initialized)
{
log_level = yaz_log_module_level("rsisamb");
log_level_initialized = 1;
}
- info = (struct rset_isamb_info *) nmem_malloc(rnew->nmem,sizeof(*info));
+ info = (struct rset_private *) nmem_malloc(rnew->nmem, sizeof(*info));
info->is = is;
info->pos = pos;
rnew->priv = info;
- yaz_log(log_level,"rsisamb_create");
+ yaz_log(log_level, "rsisamb_create");
return rnew;
}
-static void r_delete (RSET ct)
+static void r_delete(RSET ct)
{
yaz_log(log_level, "rsisamb_delete");
}
-RSFD r_open (RSET ct, int flag)
+RSFD r_open(RSET ct, int flag)
{
- struct rset_isamb_info *info = (struct rset_isamb_info *) ct->priv;
+ struct rset_private *info = (struct rset_private *) ct->priv;
RSFD rfd;
- struct rset_pp_info *ptinfo;
+ struct rfd_private *ptinfo;
if (flag & RSETF_WRITE)
{
}
rfd = rfd_create_base(ct);
if (rfd->priv)
- ptinfo = (struct rset_pp_info *) (rfd->priv);
+ ptinfo = (struct rfd_private *) (rfd->priv);
else {
- ptinfo = (struct rset_pp_info *)nmem_malloc(ct->nmem,sizeof(*ptinfo));
- ptinfo->buf = nmem_malloc (ct->nmem,ct->keycontrol->key_size);
+ ptinfo = (struct rfd_private *) nmem_malloc(ct->nmem,sizeof(*ptinfo));
+ ptinfo->buf = nmem_malloc(ct->nmem,ct->keycontrol->key_size);
rfd->priv = ptinfo;
}
- ptinfo->pt = isamb_pp_open (info->is, info->pos, ct->scope );
- yaz_log(log_level,"rsisamb_open");
+ ptinfo->pt = isamb_pp_open(info->is, info->pos, ct->scope );
+ yaz_log(log_level, "rsisamb_open");
return rfd;
}
-static void r_close (RSFD rfd)
+static void r_close(RSFD rfd)
{
- struct rset_pp_info *ptinfo = (struct rset_pp_info *)(rfd->priv);
+ struct rfd_private *ptinfo = (struct rfd_private *)(rfd->priv);
isamb_pp_close (ptinfo->pt);
rfd_delete_base(rfd);
- yaz_log(log_level,"rsisamb_close");
+ yaz_log(log_level, "rsisamb_close");
}
static int r_forward(RSFD rfd, void *buf, TERMID *term, const void *untilbuf)
{
- struct rset_pp_info *pinfo = (struct rset_pp_info *)(rfd->priv);
+ struct rfd_private *pinfo = (struct rfd_private *)(rfd->priv);
int rc;
rc = isamb_pp_forward(pinfo->pt, buf, untilbuf);
if (rc && term)
*term = rfd->rset->term;
- yaz_log(log_level,"rsisamb_forward");
+ yaz_log(log_level, "rsisamb_forward");
return rc;
}
-static void r_pos (RSFD rfd, double *current, double *total)
+static void r_pos(RSFD rfd, double *current, double *total)
{
- struct rset_pp_info *pinfo = (struct rset_pp_info *)(rfd->priv);
+ struct rfd_private *pinfo = (struct rfd_private *)(rfd->priv);
assert(rfd);
isamb_pp_pos(pinfo->pt, current, total);
- yaz_log(log_level,"isamb.r_pos returning %0.1f/%0.1f",
+ yaz_log(log_level, "isamb.r_pos returning %0.1f/%0.1f",
*current, *total);
}
-static int r_read (RSFD rfd, void *buf, TERMID *term)
+static int r_read(RSFD rfd, void *buf, TERMID *term)
{
- struct rset_pp_info *pinfo = (struct rset_pp_info *)(rfd->priv);
+ struct rfd_private *pinfo = (struct rfd_private *)(rfd->priv);
int rc;
rc = isamb_pp_read(pinfo->pt, buf);
if (rc && term)
*term = rfd->rset->term;
- yaz_log(log_level,"isamb.r_read ");
+ yaz_log(log_level, "isamb.r_read ");
+ return rc;
+}
+
+static int r_read_filter(RSFD rfd, void *buf, TERMID *term)
+{
+ struct rfd_private *pinfo = (struct rfd_private *)rfd->priv;
+ const struct rset_key_control *kctrl = rfd->rset->keycontrol;
+ int rc;
+ while((rc = isamb_pp_read(pinfo->pt, buf)))
+ {
+ int incl = (*kctrl->filter_func)(buf, kctrl->filter_data);
+ if (incl)
+ break;
+ }
+ if (rc && term)
+ *term = rfd->rset->term;
+ yaz_log(log_level, "isamb.r_read_filter");
return rc;
}
-static int r_write (RSFD rfd, const void *buf)
+static int r_write(RSFD rfd, const void *buf)
{
yaz_log(YLOG_FATAL, "ISAMB set type is read-only");
return -1;
-/* $Id: rsisamc.c,v 1.38 2005-04-26 10:09:38 adam Exp $
+/* $Id: rsisamc.c,v 1.39 2005-05-03 09:11:36 adam Exp $
Copyright (C) 1995-2005
Index Data ApS
static int log_level = 0;
static int log_level_initialized = 0;
-RSET rsisamc_create(NMEM nmem, const struct key_control *kcontrol, int scope,
+RSET rsisamc_create(NMEM nmem, struct rset_key_control *kcontrol,
+ int scope,
ISAMC is, ISAM_P pos, TERMID term)
{
RSET rnew = rset_create_base(&control, nmem, kcontrol, scope,term);
-/* $Id: rsisams.c,v 1.21 2005-04-26 10:09:38 adam Exp $
+/* $Id: rsisams.c,v 1.22 2005-05-03 09:11:36 adam Exp $
Copyright (C) 1995-2005
Index Data ApS
r_write,
};
-struct rset_pp_info {
+struct rfd_private {
ISAMS_PP pt;
};
-struct rset_isams_info {
+struct rset_private {
ISAMS is;
ISAM_P pos;
};
-RSET rsisams_create(NMEM nmem, const struct key_control *kcontrol, int scope,
+RSET rsisams_create(NMEM nmem, struct rset_key_control *kcontrol,
+ int scope,
ISAMS is, ISAM_P pos, TERMID term)
{
- 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;
- info->is=is;
- info->pos=pos;
+ RSET rnew = rset_create_base(&control, nmem, kcontrol, scope, term);
+ struct rset_private *info;
+ info = (struct rset_private *) nmem_malloc(rnew->nmem,sizeof(*info));
+ rnew->priv = info;
+ info->is = is;
+ info->pos = pos;
return rnew;
}
RSFD r_open (RSET ct, int flag)
{
- struct rset_isams_info *info = (struct rset_isams_info *) ct->priv;
+ struct rset_private *info = (struct rset_private *) ct->priv;
RSFD rfd;
- struct rset_pp_info *ptinfo;
+ struct rfd_private *ptinfo;
yaz_log (YLOG_DEBUG, "risams_open");
if (flag & RSETF_WRITE)
}
rfd=rfd_create_base(ct);
if (rfd->priv)
- ptinfo=(struct rset_pp_info *)(rfd->priv);
+ ptinfo=(struct rfd_private *)(rfd->priv);
else {
- ptinfo = (struct rset_pp_info *) nmem_malloc(ct->nmem,sizeof(*ptinfo));
+ ptinfo = (struct rfd_private *) nmem_malloc(ct->nmem,sizeof(*ptinfo));
ptinfo->pt = isams_pp_open (info->is, info->pos);
rfd->priv=ptinfo;
}
static void r_close (RSFD rfd)
{
- struct rset_pp_info *ptinfo=(struct rset_pp_info *)(rfd->priv);
+ struct rfd_private *ptinfo = (struct rfd_private *)(rfd->priv);
isams_pp_close (ptinfo->pt);
rfd_delete_base(rfd);
static int r_read (RSFD rfd, void *buf, TERMID *term)
{
- struct rset_pp_info *ptinfo=(struct rset_pp_info *)(rfd->priv);
+ struct rfd_private *ptinfo = (struct rfd_private *)(rfd->priv);
int rc;
rc=isams_pp_read(ptinfo->pt, buf);
if (rc && term)
-/* $Id: rsmultiandor.c,v 1.16 2005-04-26 10:09:38 adam Exp $
+/* $Id: rsmultiandor.c,v 1.17 2005-05-03 09:11:36 adam Exp $
Copyright (C) 1995-2005
Index Data ApS
struct heap {
int heapnum;
int heapmax;
- const struct key_control *kctrl;
+ const struct rset_key_control *kctrl;
struct heap_item **heap; /* ptrs to the rfd */
};
typedef struct heap *HEAP;
-struct rset_multiandor_info {
+struct rset_private {
int no_rsets;
RSET *rsets;
};
-struct rset_multiandor_rfd {
+struct rfd_private {
int flag;
struct heap_item *items; /* we alloc and free them here */
HEAP h; /* and move around here */
static
-HEAP heap_create (NMEM nmem, int size, const struct key_control *kctrl)
+HEAP heap_create (NMEM nmem, int size, const struct rset_key_control *kctrl)
{
HEAP h = (HEAP) nmem_malloc (nmem, sizeof(*h));
/* Creating and deleting rsets ***********************/
-static RSET rsmulti_andor_create( NMEM nmem, const struct key_control *kcontrol,
- int scope, int no_rsets, RSET* rsets,
- const struct rset_control *ctrl)
+static RSET rsmulti_andor_create(NMEM nmem,
+ struct rset_key_control *kcontrol,
+ int scope, int no_rsets, RSET* rsets,
+ const struct rset_control *ctrl)
{
- RSET rnew = rset_create_base(ctrl, nmem,kcontrol, scope,0);
- struct rset_multiandor_info *info;
+ RSET rnew = rset_create_base(ctrl, nmem, kcontrol, scope,0);
+ struct rset_private *info;
if (!log_level_initialized)
{
log_level = yaz_log_module_level("rsmultiandor");
log_level_initialized = 1;
}
- info = (struct rset_multiandor_info *) nmem_malloc(rnew->nmem,sizeof(*info));
+ info = (struct rset_private *) nmem_malloc(rnew->nmem,sizeof(*info));
info->no_rsets = no_rsets;
info->rsets = (RSET*)nmem_malloc(rnew->nmem, no_rsets*sizeof(*rsets));
memcpy(info->rsets,rsets,no_rsets*sizeof(*rsets));
return rnew;
}
-RSET rsmulti_or_create(NMEM nmem, const struct key_control *kcontrol,
+RSET rsmulti_or_create(NMEM nmem, struct rset_key_control *kcontrol,
int scope, int no_rsets, RSET* rsets)
{
return rsmulti_andor_create(nmem, kcontrol, scope,
no_rsets, rsets, &control_or);
}
-RSET rsmulti_and_create(NMEM nmem, const struct key_control *kcontrol,
+RSET rsmulti_and_create(NMEM nmem, struct rset_key_control *kcontrol,
int scope, int no_rsets, RSET* rsets)
{
return rsmulti_andor_create(nmem, kcontrol, scope,
static void r_delete (RSET ct)
{
- struct rset_multiandor_info *info = (struct rset_multiandor_info *) ct->priv;
+ struct rset_private *info = (struct rset_private *) ct->priv;
int i;
for(i = 0; i<info->no_rsets; i++)
rset_delete(info->rsets[i]);
static RSFD r_open_andor (RSET ct, int flag, int is_and)
{
RSFD rfd;
- struct rset_multiandor_rfd *p;
- struct rset_multiandor_info *info = (struct rset_multiandor_info *) ct->priv;
- const struct key_control *kctrl = ct->keycontrol;
+ struct rfd_private *p;
+ struct rset_private *info = (struct rset_private *) ct->priv;
+ const struct rset_key_control *kctrl = ct->keycontrol;
int i;
if (flag & RSETF_WRITE)
}
rfd = rfd_create_base(ct);
if (rfd->priv) {
- p = (struct rset_multiandor_rfd *)rfd->priv;
+ p = (struct rfd_private *)rfd->priv;
if (!is_and)
heap_clear(p->h);
assert(p->items);
/* all other pointers shouls already be allocated, in right sizes! */
}
else {
- p = (struct rset_multiandor_rfd *) nmem_malloc (ct->nmem,sizeof(*p));
+ p = (struct rfd_private *) nmem_malloc (ct->nmem,sizeof(*p));
rfd->priv = p;
p->h = 0;
p->tailbits = 0;
p->h = heap_create( ct->nmem, info->no_rsets, kctrl);
p->items=(struct heap_item *) nmem_malloc(ct->nmem,
info->no_rsets*sizeof(*p->items));
- for (i = 0; i<info->no_rsets; i++){
+ for (i = 0; i<info->no_rsets; i++)
+ {
p->items[i].rset = info->rsets[i];
- p->items[i].buf = nmem_malloc(ct->nmem,kctrl->key_size);
+ p->items[i].buf = nmem_malloc(ct->nmem, kctrl->key_size);
}
}
p->flag = flag;
static void r_close (RSFD rfd)
{
- struct rset_multiandor_info *info=
- (struct rset_multiandor_info *)(rfd->rset->priv);
- struct rset_multiandor_rfd *p=(struct rset_multiandor_rfd *)(rfd->priv);
+ struct rset_private *info=
+ (struct rset_private *)(rfd->rset->priv);
+ struct rfd_private *p=(struct rfd_private *)(rfd->priv);
int i;
if (p->h)
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;
+ struct rfd_private *p = rfd->priv;
+ const struct rset_key_control *kctrl = rfd->rset->keycontrol;
if (heap_empty(p->h))
return 0;
while ( (*kctrl->cmp)(p->h->heap[1]->buf,untilbuf) < -rfd->rset->scope )
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;
+ struct rfd_private *mrfd = rfd->priv;
+ const struct rset_key_control *kctrl = rfd->rset->keycontrol;
struct heap_item *it;
int rdres;
if (heap_empty(mrfd->h))
/* Once a hit has been found, scan all items for the smallest */
/* value. Mark all as being in the tail. Read next from that */
/* item, and if not in the same record, clear its tail bit */
- struct rset_multiandor_rfd *p = rfd->priv;
- const struct key_control *kctrl = rfd->rset->keycontrol;
- struct rset_multiandor_info *info = rfd->rset->priv;
+ struct rfd_private *p = rfd->priv;
+ const struct rset_key_control *kctrl = rfd->rset->keycontrol;
+ struct rset_private *info = rfd->rset->priv;
int i, mintail;
int cmp;
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;
- struct rset_multiandor_info *info = rfd->rset->priv;
+ struct rfd_private *p = rfd->priv;
+ const struct rset_key_control *kctrl = rfd->rset->keycontrol;
+ struct rset_private *info = rfd->rset->priv;
int i;
int cmp;
int killtail = 0;
static void r_pos (RSFD rfd, double *current, double *total)
{
- struct rset_multiandor_info *info =
- (struct rset_multiandor_info *)(rfd->rset->priv);
- struct rset_multiandor_rfd *mrfd =
- (struct rset_multiandor_rfd *)(rfd->priv);
+ struct rset_private *info =
+ (struct rset_private *)(rfd->rset->priv);
+ struct rfd_private *mrfd =
+ (struct rfd_private *)(rfd->priv);
double cur, tot;
double scur = 0.0, stot = 0.0;
int i;
/* term. We do not want to duplicate those. Other multiors (and ands) */
/* have different terms under them. Those we want. */
{
- struct rset_multiandor_info *info =
- (struct rset_multiandor_info *) ct->priv;
+ struct rset_private *info =
+ (struct rset_private *) ct->priv;
int firstterm= *curterm;
int i;
for (i = 0; i<info->no_rsets; i++)
-/* $Id: rsnull.c,v 1.33 2005-04-26 10:09:38 adam Exp $
+/* $Id: rsnull.c,v 1.34 2005-05-03 09:11:36 adam Exp $
Copyright (C) 1995-2005
Index Data ApS
02111-1307, USA.
*/
-
-
#include <stdio.h>
#include <assert.h>
#include <idzebra/util.h>
#include <rset.h>
-
-static RSFD r_open (RSET ct, int flag);
-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, TERMID *term);
-static int r_write (RSFD rfd, const void *buf);
+static RSFD r_open(RSET ct, int flag);
+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, TERMID *term);
+static int r_write(RSFD rfd, const void *buf);
static const struct rset_control control =
{
r_write,
};
-RSET rsnull_create(NMEM nmem, const struct key_control *kcontrol )
+RSET rsnull_create(NMEM nmem, struct rset_key_control *kcontrol )
{
- RSET rnew=rset_create_base(&control, nmem, kcontrol,0,0);
- rnew->priv=NULL;
+ RSET rnew = rset_create_base(&control, nmem, kcontrol, 0, 0);
+ rnew->priv = 0;
return rnew;
}
-static RSFD r_open (RSET ct, int flag)
+static RSFD r_open(RSET ct, int flag)
{
RSFD rfd;
if (flag & RSETF_WRITE)
yaz_log (YLOG_FATAL, "NULL set type is read-only");
return NULL;
}
- rfd=rfd_create_base(ct);
- rfd->priv=NULL;
+ rfd = rfd_create_base(ct);
+ rfd->priv = 0;
return rfd;
}
-static void r_close (RSFD rfd)
+static void r_close(RSFD rfd)
{
rfd_delete_base(rfd);
}
-static void r_delete (RSET ct)
+static void r_delete(RSET ct)
{
}
-
-static void r_pos (RSFD rfd, double *current, double *total)
+static void r_pos(RSFD rfd, double *current, double *total)
{
assert(rfd);
assert(current);
*current=0;
}
-static int r_read (RSFD rfd, void *buf, TERMID *term)
+static int r_read(RSFD rfd, void *buf, TERMID *term)
{
if (term)
- *term=0; /* NULL */
+ *term = 0;
return 0;
}
-static int r_write (RSFD rfd, const void *buf)
+static int r_write(RSFD rfd, const void *buf)
{
yaz_log (YLOG_FATAL, "NULL set type is read-only");
return -1;
-/* $Id: rsprox.c,v 1.27 2005-04-26 10:09:38 adam Exp $
+/* $Id: rsprox.c,v 1.28 2005-05-03 09:11:36 adam Exp $
Copyright (C) 1995-2005
Index Data ApS
};
-RSET rsprox_create( NMEM nmem, const struct key_control *kcontrol, int scope,
- int rset_no, RSET *rset,
- int ordered, int exclusion,
- int relation, int distance)
+RSET rsprox_create(NMEM nmem, struct rset_key_control *kcontrol,
+ int scope,
+ int rset_no, RSET *rset,
+ int ordered, int exclusion,
+ int relation, int distance)
{
RSET rnew = rset_create_base(&control, nmem, kcontrol, scope,0);
struct rset_prox_info *info;
rfd_delete_base(rfd);
}
-static int r_forward (RSFD rfd, void *buf, TERMID *term, 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);
- const struct key_control *kctrl = rfd->rset->keycontrol;
+ struct rset_prox_rfd *p = (struct rset_prox_rfd *)(rfd->priv);
+ const struct rset_key_control *kctrl = rfd->rset->keycontrol;
int cmp = 0;
int i;
-/* $Id: rstemp.c,v 1.62 2005-04-26 10:09:38 adam Exp $
+/* $Id: rstemp.c,v 1.63 2005-05-03 09:11:36 adam Exp $
Copyright (C) 1995-2005
Index Data ApS
r_write,
};
-struct rset_temp_info {
+struct rset_private {
int fd; /* file descriptor for temp file */
char *fname; /* name of temp file */
char *buf_mem; /* window buffer */
char *temp_path;
};
-struct rset_temp_rfd {
+struct rfd_private {
void *buf;
size_t pos_cur; /* current position in set */
/* FIXME - term pos or what ?? */
static int log_level = 0;
static int log_level_initialized = 0;
-RSET rstemp_create(NMEM nmem, const struct key_control *kcontrol,
+RSET rstemp_create(NMEM nmem, struct rset_key_control *kcontrol,
int scope, const char *temp_path, TERMID term)
{
- RSET rnew = rset_create_base(&control, nmem, kcontrol, scope,term);
- struct rset_temp_info *info;
+ RSET rnew = rset_create_base(&control, nmem, kcontrol, scope, term);
+ struct rset_private *info;
if (!log_level_initialized)
{
log_level = yaz_log_module_level("rstemp");
log_level_initialized = 1;
}
- info = (struct rset_temp_info *) nmem_malloc(rnew->nmem, sizeof(*info));
+ info = (struct rset_private *) nmem_malloc(rnew->nmem, sizeof(*info));
info->fd = -1;
info->fname = NULL;
info->buf_size = 4096;
static void r_delete(RSET ct)
{
- struct rset_temp_info *info = (struct rset_temp_info*) ct->priv;
+ struct rset_private *info = (struct rset_private*) ct->priv;
yaz_log(log_level, "r_delete: set size %ld", (long) info->pos_end);
if (info->fname)
static RSFD r_open(RSET ct, int flag)
{
- struct rset_temp_info *info = (struct rset_temp_info *) ct->priv;
+ struct rset_private *info = (struct rset_private *) ct->priv;
RSFD rfd;
- struct rset_temp_rfd *prfd;
+ struct rfd_private *prfd;
if (info->fd == -1 && info->fname)
{
rfd = rfd_create_base(ct);
if (!rfd->priv)
{
- prfd = (struct rset_temp_rfd *) nmem_malloc(ct->nmem, sizeof(*prfd));
+ prfd = (struct rfd_private *) nmem_malloc(ct->nmem, sizeof(*prfd));
rfd->priv = (void *)prfd;
prfd->buf = nmem_malloc(ct->nmem,ct->keycontrol->key_size);
}
*/
static void r_flush(RSFD rfd, int mk)
{
- /* struct rset_temp_info *info = ((struct rset_temp_rfd*) rfd)->info; */
- struct rset_temp_info *info = rfd->rset->priv;
+ struct rset_private *info = rfd->rset->priv;
if (!info->fname && mk)
{
static void r_close(RSFD rfd)
{
- /*struct rset_temp_rfd *mrfd = (struct rset_temp_rfd*) rfd->priv; */
- struct rset_temp_info *info = (struct rset_temp_info *)rfd->rset->priv;
+ struct rset_private *info = (struct rset_private *)rfd->rset->priv;
if (rfd_is_last(rfd))
{
r_flush(rfd, 0);
*/
static void r_reread(RSFD rfd)
{
- struct rset_temp_rfd *mrfd = (struct rset_temp_rfd*) rfd->priv;
- struct rset_temp_info *info = (struct rset_temp_info *)rfd->rset->priv;
+ struct rfd_private *mrfd = (struct rfd_private*) rfd->priv;
+ struct rset_private *info = (struct rset_private *)rfd->rset->priv;
if (info->fname)
{
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;
+ struct rfd_private *mrfd = (struct rfd_private*) rfd->priv;
+ struct rset_private *info = (struct rset_private *)rfd->rset->priv;
size_t nc = mrfd->pos_cur + rfd->rset->keycontrol->key_size;
static int r_write(RSFD rfd, const void *buf)
{
- struct rset_temp_rfd *mrfd = (struct rset_temp_rfd*) rfd->priv;
- struct rset_temp_info *info = (struct rset_temp_info *)rfd->rset->priv;
+ struct rfd_private *mrfd = (struct rfd_private*) rfd->priv;
+ struct rset_private *info = (struct rset_private *)rfd->rset->priv;
size_t nc = mrfd->pos_cur + rfd->rset->keycontrol->key_size;
static void r_pos(RSFD rfd, double *current, double *total)
{
- /* struct rset_temp_rfd *mrfd = (struct rset_temp_rfd*) rfd; */
- struct rset_temp_rfd *mrfd = (struct rset_temp_rfd*) rfd->priv;
- struct rset_temp_info *info = (struct rset_temp_info *)rfd->rset->priv;
+ struct rfd_private *mrfd = (struct rfd_private*) rfd->priv;
+ struct rset_private *info = (struct rset_private *)rfd->rset->priv;
*current = (double) mrfd->cur;
*total = (double) info->hits;
-/* $Id: safari1.c,v 1.4 2005-03-05 09:19:16 adam Exp $
+/* $Id: safari1.c,v 1.5 2005-05-03 09:11:37 adam Exp $
Copyright (C) 1995-2005
Index Data ApS
#include "testlib.h"
-const char *myrec[] = {
+const char *myrec[] =
+{
"1234\n" /* first record */
"00024338 125060 1 any the\n"
"00024338 125060 2 any art\n"
"00024338 125060 3 any of\n",
- "5678\n" /* other record */
+ "5678\n" /* other record - same owner id */
"00024339 125060 1 any den\n"
"00024339 125060 2 any gamle\n"
"00024339 125060 3 any mand\n",
- "5678\n" /* same record identifier as before .. */
+ "5678\n" /* same record chunk id as before .. */
"00024339 125060 1 any the\n"
"00024339 125060 2 any gamle\n"
"00024339 125060 3 any mand\n",
- 0};
-
+ "1000\n" /* separate record */
+ "00024339 125061 1 any the\n"
+ "00024339 125061 2 any gamle\n"
+ "00024339 125061 3 any mand\n",
+
+ "1001\n" /* separate record */
+ "00024340 125062 1 any the\n"
+ "00024340 125062 2 any gamle\n"
+ "00024340 125062 3 any mand\n",
+
+ 0
+};
+
int main(int argc, char **argv)
{
- zint ids[2];
+ zint ids[3];
+ zint limits[3];
ZebraService zs = start_up("safari.cfg", argc, argv);
ZebraHandle zh = zebra_open(zs);
init_data(zh, myrec);
- do_query(__LINE__, zh, "@attr 1=any the", 1);
+ do_query(__LINE__, zh, "@attr 1=any the", 3);
do_query(__LINE__, zh, "@attr 1=any {the art}", 1);
do_query(__LINE__, zh, "@attr 1=any {den gamle}", 1);
do_query(__LINE__, zh, "@attr 1=any {the of}", 0);
+ /* verify that we get these records exactly */
ids[0] = 24338;
+ ids[1] = 24339;
+ ids[2] = 24340;
+ meta_query(__LINE__, zh, "@attr 1=any the", 3, ids);
+
+ /* limit to 125061 */
+ limits[0] = 125061;
+ limits[1] = 0;
+ zebra_set_limit(zh, 0, limits);
+ ids[0] = 24339;
meta_query(__LINE__, zh, "@attr 1=any the", 1, ids);
-
+
+ /* limit to 125060, 125061 */
+ limits[0] = 125061;
+ limits[1] = 125060;
+ limits[2] = 0;
+ zebra_set_limit(zh, 0, limits);
+ ids[0] = 24338;
+ ids[1] = 24339;
+ meta_query(__LINE__, zh, "@attr 1=any the", 2, ids);
+
+ /* all except 125061 */
+ limits[0] = 125061;
+ limits[1] = 0;
+ zebra_set_limit(zh, 1, limits);
+
+ ids[0] = 24338;
+ ids[1] = 24340;
+ meta_query(__LINE__, zh, "@attr 1=any the", 2, ids);
+
+ /* no limit */
+ zebra_set_limit(zh, 1, 0);
+ do_query(__LINE__, zh, "@attr 1=any the", 3);
+
return close_down(zh, zs, 0);
}
projects / idzebra-moved-to-github.git / commitdiff