/*
- * Copyright (C) 1994-1996, Index Data I/S
+ * Copyright (C) 1994-1998, Index Data I/S
* All rights reserved.
* Sebastian Hammer, Adam Dickmeiss
*
* $Log: zrpn.c,v $
- * Revision 1.57 1996-11-11 13:38:02 adam
+ * Revision 1.72 1998-01-07 13:53:41 adam
+ * Queries using simple ranked operands returns right number of hits.
+ *
+ * Revision 1.71 1997/12/18 10:54:24 adam
+ * New method result set method rs_hits that returns the number of
+ * hits in result-set (if known). The ranked result set returns real
+ * number of hits but only when not combined with other operands.
+ *
+ * Revision 1.70 1997/10/31 12:34:43 adam
+ * Changed a few log statements.
+ *
+ * Revision 1.69 1997/10/29 12:05:02 adam
+ * Server produces diagnostic "Unsupported Attribute Set" when appropriate.
+ *
+ * Revision 1.68 1997/10/27 14:33:06 adam
+ * Moved towards generic character mapping depending on "structure"
+ * field in abstract syntax file. Fixed a few memory leaks. Fixed
+ * bug with negative integers when doing searches with relational
+ * operators.
+ *
+ * Revision 1.67 1997/09/29 09:06:10 adam
+ * Removed one static var in order to make this module thread safe.
+ *
+ * Revision 1.66 1997/09/25 14:58:03 adam
+ * Windows NT port.
+ *
+ * Revision 1.65 1997/09/22 12:39:06 adam
+ * Added get_pos method for the ranked result sets.
+ *
+ * Revision 1.64 1997/09/18 08:59:20 adam
+ * Extra generic handle for the character mapping routines.
+ *
+ * Revision 1.63 1997/09/17 12:19:18 adam
+ * Zebra version corresponds to YAZ version 1.4.
+ * Changed Zebra server so that it doesn't depend on global common_resource.
+ *
+ * Revision 1.62 1997/09/05 15:30:09 adam
+ * Changed prototype for chr_map_input - added const.
+ * Added support for C++, headers uses extern "C" for public definitions.
+ *
+ * Revision 1.61 1997/02/10 10:21:14 adam
+ * Bug fix: in search terms character (^) wasn't observed.
+ *
+ * Revision 1.60 1997/01/31 11:10:34 adam
+ * Bug fix: Leading and trailing white space weren't removed in scan tokens.
+ *
+ * Revision 1.59 1997/01/17 11:31:46 adam
+ * Bug fix: complete phrase search didn't work.
+ *
+ * Revision 1.58 1996/12/23 15:30:45 adam
+ * Work on truncation.
+ * Bug fix: result sets weren't deleted after server shut down.
+ *
+ * Revision 1.57 1996/11/11 13:38:02 adam
* Added proximity support in search.
*
* Revision 1.56 1996/11/08 11:10:32 adam
*/
#include <stdio.h>
#include <assert.h>
+#ifdef WINDOWS
+#include <io.h>
+#else
#include <unistd.h>
+#endif
#include <ctype.h>
#include "zserver.h"
-#include "attribute.h"
#include <charmap.h>
#include <rstemp.h>
#include <rsbool.h>
#include <rsrel.h>
+struct rpn_char_map_info {
+ ZebraMaps zm;
+ int reg_type;
+};
+
+static const char **rpn_char_map_handler (void *vp, const char **from, int len)
+{
+ struct rpn_char_map_info *p = vp;
+ return zebra_maps_input (p->zm, p->reg_type, from, len);
+}
+
+static void rpn_char_map_prepare (ZServerInfo *zi, int reg_type,
+ struct rpn_char_map_info *map_info)
+{
+ map_info->zm = zi->zebra_maps;
+ map_info->reg_type = reg_type;
+ dict_grep_cmap (zi->dict, map_info, rpn_char_map_handler);
+}
+
typedef struct {
int type;
int major;
ISAM_P *new_isam_p_buf;
#ifdef TERM_COUNT
int *new_term_no;
-#endif
-
+#endif
p->isam_p_size = 2*p->isam_p_size + 100;
new_isam_p_buf = xmalloc (sizeof(*new_isam_p_buf) *
p->isam_p_size);
return 0;
}
-static int term_pre (char **src, const char *ct1, const char *ct2)
+static int term_pre (ZebraMaps zebra_maps, int reg_type, const char **src,
+ const char *ct1, const char *ct2)
{
- char *s1, *s0 = *src;
- char **map;
+ const char *s1, *s0 = *src;
+ const char **map;
/* skip white space */
while (*s0)
if (ct2 && strchr (ct2, *s0))
break;
s1 = s0;
- map = map_chrs_input (&s1, strlen(s1));
+ map = zebra_maps_input (zebra_maps, reg_type, &s1, strlen(s1));
if (**map != *CHR_SPACE)
break;
s0 = s1;
return *s0;
}
-static int term_100 (char **src, char *dst)
+static int term_100 (ZebraMaps zebra_maps, int reg_type,
+ const char **src, char *dst, int space_split)
{
- char *s0, *s1, **map;
+ const char *s0, *s1;
+ const char **map;
int i = 0;
- if (!term_pre (src, NULL, NULL))
+ if (!term_pre (zebra_maps, reg_type, src, NULL, NULL))
return 0;
s0 = *src;
while (*s0)
{
s1 = s0;
- map = map_chrs_input (&s0, strlen(s0));
- if (**map == *CHR_SPACE)
+ map = zebra_maps_input (zebra_maps, reg_type, &s0, strlen(s0));
+ if (space_split && **map == *CHR_SPACE)
break;
while (s1 < s0)
{
- if (!isalnum (*s1))
+ if (!isalnum (*s1) && *s1 != '-')
dst[i++] = '\\';
dst[i++] = *s1++;
}
return i;
}
-static int term_101 (char **src, char *dst)
+static int term_101 (ZebraMaps zebra_maps, int reg_type,
+ const char **src, char *dst, int space_split)
{
- char *s0, *s1, **map;
+ const char *s0, *s1;
+ const char **map;
int i = 0;
- if (!term_pre (src, "#", "#"))
+ if (!term_pre (zebra_maps, reg_type, src, "#", "#"))
return 0;
s0 = *src;
while (*s0)
else
{
s1 = s0;
- map = map_chrs_input (&s0, strlen(s0));
- if (**map == *CHR_SPACE)
+ map = zebra_maps_input (zebra_maps, reg_type, &s0, strlen(s0));
+ if (space_split && **map == *CHR_SPACE)
break;
while (s1 < s0)
{
}
-static int term_103 (char **src, char *dst, int *errors)
+static int term_103 (ZebraMaps zebra_maps, int reg_type, const char **src,
+ char *dst, int *errors, int space_split)
{
int i = 0;
- char *s0, *s1, **map;
+ const char *s0, *s1;
+ const char **map;
- if (!term_pre (src, "\\()[].*+?|", "("))
+ if (!term_pre (zebra_maps, reg_type, src, "^\\()[].*+?|", "("))
return 0;
s0 = *src;
if (errors && *s0 == '+' && s0[1] && s0[2] == '+' && s0[3] &&
}
while (*s0)
{
- if (strchr ("\\()[].*+?|-", *s0))
+ if (strchr ("^\\()[].*+?|-", *s0))
dst[i++] = *s0++;
else
{
s1 = s0;
- map = map_chrs_input (&s0, strlen(s0));
+ map = zebra_maps_input (zebra_maps, reg_type, &s0, strlen(s0));
if (**map == *CHR_SPACE)
break;
while (s1 < s0)
return i;
}
-static int term_102 (char **src, char *dst)
+static int term_102 (ZebraMaps zebra_maps, int reg_type, const char **src,
+ char *dst, int space_split)
{
- return term_103 (src, dst, NULL);
+ return term_103 (zebra_maps, reg_type, src, dst, NULL, space_split);
}
/* gen_regular_rel - generate regular expression from relation
if (val >= 0)
{
if (islt)
- strcpy (dst, "(-[0-9]+|");
+ strcpy (dst, "(-[0-9]+|(");
else
- strcpy (dst, "(");
+ strcpy (dst, "((");
}
else
{
if (!islt)
{
- strcpy (dst, "([0-9]+|-");
+ strcpy (dst, "([0-9]+|-(");
dst_p = strlen (dst);
islt = 1;
}
else
{
- strcpy (dst, "(-");
+ strcpy (dst, "((-");
islt = 0;
}
val = -val;
strcat (dst, "[0-9]");
strcat (dst, "[0-9]*");
}
- strcat (dst, ")");
+ strcat (dst, "))");
}
static int relational_term (ZServerInfo *zi, Z_AttributesPlusTerm *zapt,
- char **term_sub,
+ const char **term_sub,
char *term_dict,
oid_value attributeSet,
struct grep_info *grep_info,
- int *max_pos)
+ int *max_pos,
+ int reg_type)
{
AttrType relation;
int relation_value;
int term_value;
int r;
+ char *term_tmp = term_dict + strlen(term_dict);
attr_init (&relation, zapt, 2);
relation_value = attr_find (&relation, NULL);
+ logf (LOG_DEBUG, "relation value=%d", relation_value);
switch (relation_value)
{
case 1:
- if (!term_100 (term_sub, term_dict))
+ if (!term_100 (zi->zebra_maps, reg_type, term_sub, term_tmp, 1))
return 0;
- term_value = atoi (term_dict);
- if (term_value <= 0)
- return 1;
+ term_value = atoi (term_tmp);
logf (LOG_DEBUG, "Relation <");
- gen_regular_rel (term_dict + strlen(term_dict), term_value-1, 1);
+ gen_regular_rel (term_tmp, term_value-1, 1);
break;
case 2:
- if (!term_100 (term_sub, term_dict))
+ if (!term_100 (zi->zebra_maps, reg_type, term_sub, term_tmp, 1))
return 0;
- term_value = atoi (term_dict);
- if (term_value < 0)
- return 1;
+ term_value = atoi (term_tmp);
logf (LOG_DEBUG, "Relation <=");
- gen_regular_rel (term_dict + strlen(term_dict), term_value, 1);
+ gen_regular_rel (term_tmp, term_value, 1);
break;
case 4:
- if (!term_100 (term_sub, term_dict))
+ if (!term_100 (zi->zebra_maps, reg_type, term_sub, term_tmp, 1))
return 0;
- term_value = atoi (term_dict);
- if (term_value < 0)
- term_value = 0;
+ term_value = atoi (term_tmp);
logf (LOG_DEBUG, "Relation >=");
- gen_regular_rel (term_dict + strlen(term_dict), term_value, 0);
+ gen_regular_rel (term_tmp, term_value, 0);
break;
case 5:
- if (!term_100 (term_sub, term_dict))
+ if (!term_100 (zi->zebra_maps, reg_type, term_sub, term_tmp, 1))
return 0;
- term_value = atoi (term_dict);
- if (term_value < 0)
- term_value = 0;
+ term_value = atoi (term_tmp);
logf (LOG_DEBUG, "Relation >");
- gen_regular_rel (term_dict + strlen(term_dict), term_value+1, 0);
+ gen_regular_rel (term_tmp, term_value+1, 0);
break;
default:
return 0;
}
- logf (LOG_DEBUG, "dict_lookup_grep: %s", term_dict);
+ logf (LOG_DEBUG, "dict_lookup_grep: %s", term_tmp);
r = dict_lookup_grep (zi->dict, term_dict, 0, grep_info, max_pos,
0, grep_handle);
if (r)
}
static int field_term (ZServerInfo *zi, Z_AttributesPlusTerm *zapt,
- char **term_sub, int regType,
+ const char **term_sub,
oid_value attributeSet, struct grep_info *grep_info,
+ int reg_type, int complete_flag,
int num_bases, char **basenames)
{
char term_dict[2*IT_MAX_WORD+2];
AttrType use;
int use_value;
oid_value curAttributeSet = attributeSet;
- char *termp;
+ const char *termp;
+ struct rpn_char_map_info rcmi;
+ int space_split = complete_flag ? 0 : 1;
+ rpn_char_map_prepare (zi, reg_type, &rcmi);
attr_init (&use, zapt, 1);
use_value = attr_find (&use, &curAttributeSet);
- logf (LOG_DEBUG, "use value %d", use_value);
+ logf (LOG_DEBUG, "field_term, use value %d", use_value);
attr_init (&truncation, zapt, 5);
truncation_value = attr_find (&truncation, NULL);
logf (LOG_DEBUG, "truncation value %d", truncation_value);
for (base_no = 0; base_no < num_bases; base_no++)
{
- attent *attp;
+ attent attp;
data1_local_attribute *local_attr;
int max_pos, prefix_len = 0;
termp = *term_sub;
- attp = att_getentbyatt (curAttributeSet, use_value);
- if (!attp)
+ if ((r=att_getentbyatt (zi, &attp, curAttributeSet, use_value)))
{
- logf (LOG_DEBUG, "att_getentbyatt fail. set=%d use=%d",
- curAttributeSet, use_value);
- zi->errCode = 114;
+ logf (LOG_DEBUG, "att_getentbyatt fail. set=%d use=%d r=%d",
+ curAttributeSet, use_value, r);
+ if (r == -1)
+ zi->errCode = 114;
+ else
+ zi->errCode = 121;
return -1;
}
if (zebTargetInfo_curDatabase (zi->zti, basenames[base_no]))
zi->errString = basenames[base_no];
return -1;
}
- for (local_attr = attp->local_attributes; local_attr;
+ for (local_attr = attp.local_attributes; local_attr;
local_attr = local_attr->next)
{
int ord;
- ord = zebTargetInfo_lookupSU (zi->zti, attp->attset_ordinal,
+ ord = zebTargetInfo_lookupSU (zi->zti, attp.attset_ordinal,
local_attr->local);
if (ord < 0)
continue;
}
term_dict[prefix_len++] = ')';
term_dict[prefix_len++] = 1;
- term_dict[prefix_len++] = regType;
+ term_dict[prefix_len++] = reg_type;
+ logf (LOG_DEBUG, "reg_type = %d", term_dict[prefix_len-1]);
term_dict[prefix_len] = '\0';
if (!relational_term (zi, zapt, &termp, term_dict,
- attributeSet, grep_info, &max_pos))
+ attributeSet, grep_info, &max_pos, reg_type))
{
j = prefix_len;
switch (truncation_value)
{
case -1: /* not specified */
case 100: /* do not truncate */
- term_dict[j++] = '(';
- if (!term_100 (&termp, term_dict + j))
+ term_dict[j++] = '(';
+ if (!term_100 (zi->zebra_maps, reg_type,
+ &termp, term_dict + j, space_split))
return 0;
strcat (term_dict, ")");
r = dict_lookup_grep (zi->dict, term_dict, 0, grep_info,
break;
case 1: /* right truncation */
term_dict[j++] = '(';
- if (!term_100 (&termp, term_dict + j))
+ if (!term_100 (zi->zebra_maps, reg_type,
+ &termp, term_dict + j, space_split))
return 0;
strcat (term_dict, ".*)");
dict_lookup_grep (zi->dict, term_dict, 0, grep_info,
return -1;
case 101: /* process # in term */
term_dict[j++] = '(';
- if (!term_101 (&termp, term_dict + j))
+ if (!term_101 (zi->zebra_maps, reg_type,
+ &termp, term_dict + j, space_split))
return 0;
strcat (term_dict, ")");
r = dict_lookup_grep (zi->dict, term_dict, 0, grep_info,
break;
case 102: /* Regexp-1 */
term_dict[j++] = '(';
- if (!term_102 (&termp, term_dict + j))
+ if (!term_102 (zi->zebra_maps, reg_type,
+ &termp, term_dict + j, space_split))
return 0;
strcat (term_dict, ")");
logf (LOG_DEBUG, "Regexp-1 tolerance=%d", r);
logf (LOG_WARN, "dict_lookup_grep err, trunc=regular: %d",
r);
break;
- case 103: /* Regexp-1 */
+ case 103: /* Regexp-2 */
r = 1;
term_dict[j++] = '(';
- if (!term_103 (&termp, term_dict + j, &r))
+ if (!term_103 (zi->zebra_maps, reg_type,
+ &termp, term_dict + j, &r, space_split))
return 0;
strcat (term_dict, ")");
logf (LOG_DEBUG, "Regexp-2 tolerance=%d", r);
}
static void trans_scan_term (ZServerInfo *zi, Z_AttributesPlusTerm *zapt,
- char *termz)
+ char *termz, int reg_type)
{
Z_Term *term = zapt->term;
- char **map;
- char *cp = (char*) term->u.general->buf;
+ const char **map;
+ const char *cp = (const char *) term->u.general->buf;
const char *cp_end = cp + term->u.general->len;
const char *src;
int i = 0;
- int prev_space = 0;
+ const char *space_map = NULL;
int len;
while ((len = (cp_end - cp)) > 0)
{
- map = map_chrs_input (&cp, len);
+ map = zebra_maps_input (zi->zebra_maps, reg_type, &cp, len);
if (**map == *CHR_SPACE)
- {
- if (prev_space)
- continue;
- prev_space = 1;
- }
+ space_map = *map;
else
- prev_space = 0;
- for (src = *map; *src; src++)
- termz[i++] = *src;
+ {
+ if (i && space_map)
+ for (src = space_map; *src; src++)
+ termz[i++] = *src;
+ space_map = NULL;
+ for (src = *map; *src; src++)
+ termz[i++] = *src;
+ }
}
termz[i] = '\0';
}
static RSET rpn_search_APT_relevance (ZServerInfo *zi,
Z_AttributesPlusTerm *zapt,
oid_value attributeSet,
+ int reg_type, int complete_flag,
int num_bases, char **basenames)
{
rset_relevance_parms parms;
char termz[IT_MAX_WORD+1];
- char *termp = termz;
+ const char *termp = termz;
struct grep_info grep_info;
RSET result;
int term_index = 0;
int r;
parms.key_size = sizeof(struct it_key);
- parms.max_rec = 100;
- parms.cmp = key_compare;
+ parms.max_rec = 200;
+ parms.cmp = key_compare_it;
+ parms.get_pos = key_get_pos;
parms.is = zi->isam;
parms.isc = zi->isamc;
parms.no_terms = 0;
+ parms.method = RSREL_METHOD_A;
if (zapt->term->which != Z_Term_general)
{
grep_info.isam_p_buf = NULL;
while (1)
{
- r = field_term (zi, zapt, &termp, 'w', attributeSet, &grep_info,
- num_bases, basenames);
+ r = field_term (zi, zapt, &termp, attributeSet, &grep_info,
+ reg_type, complete_flag, num_bases, basenames);
if (r <= 0)
break;
#ifdef TERM_COUNT
return result;
}
-static RSET rpn_search_APT_cphrase (ZServerInfo *zi,
- Z_AttributesPlusTerm *zapt,
- oid_value attributeSet,
- int num_bases, char **basenames)
-{
- char termz[IT_MAX_WORD+1];
- struct grep_info grep_info;
- RSET result;
- char *termp = termz;
- int r;
-
- if (zapt->term->which != Z_Term_general)
- {
- zi->errCode = 124;
- return NULL;
- }
- trans_term (zi, zapt, termz);
-
-#ifdef TERM_COUNT
- grep_info.term_no = 0;
-#endif
- grep_info.isam_p_indx = 0;
- grep_info.isam_p_size = 0;
- grep_info.isam_p_buf = NULL;
-
- r = field_term (zi, zapt, &termp, 'p', attributeSet, &grep_info,
- num_bases, basenames);
- result = rset_trunc (zi, grep_info.isam_p_buf, grep_info.isam_p_indx);
-#ifdef TERM_COUNT
- xfree(grep_info.term_no);
-#endif
- xfree (grep_info.isam_p_buf);
- return result;
-}
-
-static RSET rpn_proximity (RSET rset1, RSET rset2, int ordered,
+static RSET rpn_proximity (ZServerInfo *zi, RSET rset1, RSET rset2,
+ int ordered,
int exclusion, int relation, int distance)
{
int i;
more2 = rset_read (rset2, rsfd2, &buf2);
parms.key_size = sizeof (struct it_key);
+ parms.temp_path = res_get (zi->res, "setTmpDir");
result = rset_create (rset_kind_temp, &parms);
rsfd_result = rset_open (result, RSETF_WRITE|RSETF_SORT_SYSNO);
exclusion, ordered, relation, distance);
while (more1 && more2)
{
- int cmp = key_compare (&buf1, &buf2);
+ int cmp = key_compare_it (&buf1, &buf2);
if (cmp < -1)
more1 = rset_read (rset1, rsfd1, &buf1);
else if (cmp > 1)
int excl = exclusion;
if (!ordered && diff < 0)
diff = -diff;
- logf (LOG_DEBUG, "l = %d r = %d", seqno[i], buf2.seqno);
switch (relation)
{
case 1: /* < */
break;
}
if (excl)
- {
- logf (LOG_DEBUG, " match");
rset_write (result, rsfd_result, &buf2);
- }
}
} while ((more2 = rset_read (rset2, rsfd2, &buf2)) &&
sysno == buf2.sysno);
return result;
}
-static RSET rpn_prox (RSET *rset, int rset_no)
+static RSET rpn_prox (ZServerInfo *zi, RSET *rset, int rset_no)
{
int i;
RSFD *rsfd;
}
}
parms.key_size = sizeof (struct it_key);
+ parms.temp_path = res_get (zi->res, "setTmpDir");
result = rset_create (rset_kind_temp, &parms);
rsfd_result = rset_open (result, RSETF_WRITE|RSETF_SORT_SYSNO);
*more = 0;
break;
}
- cmp = key_compare (buf[i], buf[i-1]);
+ cmp = key_compare_it (buf[i], buf[i-1]);
if (cmp > 1)
{
more[i-1] = rset_read (rset[i-1], rsfd[i-1], buf[i-1]);
static RSET rpn_search_APT_phrase (ZServerInfo *zi,
Z_AttributesPlusTerm *zapt,
oid_value attributeSet,
+ int reg_type, int complete_flag,
int num_bases, char **basenames)
{
char termz[IT_MAX_WORD+1];
- char *termp = termz;
+ const char *termp = termz;
RSET rset[60], result;
int i, r, rset_no = 0;
struct grep_info grep_info;
grep_info.isam_p_buf = NULL;
while (1)
- {
- grep_info.isam_p_indx = 0;
- r = field_term (zi, zapt, &termp, 'w', attributeSet, &grep_info,
- num_bases, basenames);
+ {
+ logf (LOG_DEBUG, "APT_phrase termp=%s", termp);
+ grep_info.isam_p_indx = 0;
+ r = field_term (zi, zapt, &termp, attributeSet, &grep_info,
+ reg_type, complete_flag, num_bases, basenames);
if (r < 1)
break;
rset[rset_no] = rset_trunc (zi, grep_info.isam_p_buf,
return rset_create (rset_kind_null, NULL);
else if (rset_no == 1)
return (rset[0]);
- result = rpn_prox (rset, rset_no);
+ result = rpn_prox (zi, rset, rset_no);
for (i = 0; i<rset_no; i++)
rset_delete (rset[i]);
return result;
return NULL;
}
parms.key_size = sizeof (struct it_key);
+ parms.temp_path = res_get (zi->res, "setTmpDir");
result = rset_create (rset_kind_temp, &parms);
rsfd = rset_open (result, RSETF_WRITE|RSETF_SORT_SYSNO);
oid_value attributeSet,
int num_bases, char **basenames)
{
- AttrType relation;
- AttrType structure;
- AttrType completeness;
- int relation_value, structure_value, completeness_value;
+ int reg_type;
+ char *search_type = NULL;
+ int complete_flag;
- attr_init (&relation, zapt, 2);
- attr_init (&structure, zapt, 4);
- attr_init (&completeness, zapt, 6);
+ zebra_maps_attr (zi->zebra_maps, zapt, ®_type, &search_type,
+ &complete_flag);
- relation_value = attr_find (&relation, NULL);
- structure_value = attr_find (&structure, NULL);
- completeness_value = attr_find (&completeness, NULL);
- switch (structure_value)
+ logf (LOG_DEBUG, "reg_type=%c", reg_type);
+ logf (LOG_DEBUG, "complete_flag=%d", complete_flag);
+ logf (LOG_DEBUG, "search_type=%s", search_type);
+ if (!strcmp (search_type, "phrase"))
+ {
+ return rpn_search_APT_phrase (zi, zapt, attributeSet,
+ reg_type, complete_flag,
+ num_bases, basenames);
+ }
+ else if (!strcmp (search_type, "ranked"))
{
- case -1:
- if (relation_value == 102) /* relevance relation */
- return rpn_search_APT_relevance (zi, zapt, attributeSet,
- num_bases, basenames);
- if (completeness_value == 2 || completeness_value == 3)
- return rpn_search_APT_cphrase (zi, zapt, attributeSet,
- num_bases, basenames);
- return rpn_search_APT_phrase (zi, zapt, attributeSet,
- num_bases, basenames);
- case 1: /* phrase */
- if (relation_value == 102) /* relevance relation */
- return rpn_search_APT_relevance (zi, zapt, attributeSet,
- num_bases, basenames);
- if (completeness_value == 2 || completeness_value == 3)
- return rpn_search_APT_cphrase (zi, zapt, attributeSet,
- num_bases, basenames);
- return rpn_search_APT_phrase (zi, zapt, attributeSet,
- num_bases, basenames);
- break;
- case 2: /* word */
- if (relation_value == 102) /* relevance relation */
- return rpn_search_APT_relevance (zi, zapt, attributeSet,
- num_bases, basenames);
- if (completeness_value == 2 || completeness_value == 3)
- return rpn_search_APT_cphrase (zi, zapt, attributeSet,
- num_bases, basenames);
- return rpn_search_APT_phrase (zi, zapt, attributeSet,
- num_bases, basenames);
- case 3: /* key */
- break;
- case 4: /* year */
- break;
- case 5: /* date - normalized */
- break;
- case 6: /* word list */
- return rpn_search_APT_relevance (zi, zapt, attributeSet,
- num_bases, basenames);
- case 100: /* date - un-normalized */
- break;
- case 101: /* name - normalized */
- break;
- case 102: /* date - un-normalized */
- break;
- case 103: /* structure */
- break;
- case 104: /* urx */
- break;
- case 105: /* free-form-text */
- return rpn_search_APT_relevance (zi, zapt, attributeSet,
- num_bases, basenames);
- case 106: /* document-text */
return rpn_search_APT_relevance (zi, zapt, attributeSet,
+ reg_type, complete_flag,
num_bases, basenames);
- case 107: /* local-number */
+ }
+ else if (!strcmp (search_type, "local"))
+ {
return rpn_search_APT_local (zi, zapt, attributeSet);
- case 108: /* string */
- return rpn_search_APT_phrase (zi, zapt, attributeSet,
- num_bases, basenames);
- case 109: /* numeric string */
- break;
}
zi->errCode = 118;
return NULL;
if (rset_is_ranked(bool_parms.rset_r))
soft = 1;
bool_parms.key_size = sizeof(struct it_key);
- bool_parms.cmp = key_compare;
+ bool_parms.cmp = key_compare_it;
switch (zop->which)
{
}
if (*zop->u.prox->proximityUnitCode != Z_ProxUnit_word)
{
- static char val[16];
+ char *val = odr_malloc (zi->odr, 16);
zi->errCode = 132;
zi->errString = val;
sprintf (val, "%d", *zop->u.prox->proximityUnitCode);
return NULL;
}
- r = rpn_proximity (bool_parms.rset_l, bool_parms.rset_r,
+ r = rpn_proximity (zi, bool_parms.rset_l, bool_parms.rset_r,
*zop->u.prox->ordered,
(!zop->u.prox->exclusion ? 0 :
*zop->u.prox->exclusion),
return r;
}
-void count_set_save (RSET *r, int *count)
+void count_set_save (ZServerInfo *zi, RSET *r, int *count)
{
int psysno = 0;
int kno = 0;
RSFD rfd, wfd;
RSET w;
rset_temp_parms parms;
-
+ int maxResultSetSize = atoi (res_get_def (zi->res,
+ "maxResultSetSize", "400"));
logf (LOG_DEBUG, "count_set_save");
*count = 0;
parms.key_size = sizeof(struct it_key);
+ parms.temp_path = res_get (zi->res, "setTmpDir");
w = rset_create (rset_kind_temp, &parms);
wfd = rset_open (w, RSETF_WRITE|RSETF_SORT_SYSNO);
rfd = rset_open (*r, RSETF_READ|RSETF_SORT_SYSNO);
while (rset_read (*r, rfd, &key))
{
- logf (LOG_DEBUG, "sysno=%-7d seqno=%d", key.sysno, key.seqno);
if (key.sysno != psysno)
{
- rset_write (w, wfd, &key);
- psysno = key.sysno;
+ if (*count < maxResultSetSize)
+ rset_write (w, wfd, &key);
(*count)++;
+ psysno = key.sysno;
}
kno++;
}
RSFD rfd;
logf (LOG_DEBUG, "count_set");
+
*count = 0;
rfd = rset_open (r, RSETF_READ|RSETF_SORT_SYSNO);
while (rset_read (r, rfd, &key))
Z_RPNQuery *rpn, int num_bases, char **basenames,
const char *setname, int *hits)
{
+ int i;
RSET rset;
oident *attrset;
oid_value attributeSet;
- dict_grep_cmap (zi->dict, map_chrs_input);
zlog_rpn (rpn);
zi->errCode = 0;
if (!rset)
return zi->errCode;
if (rset_is_volatile(rset))
- count_set_save(&rset,hits);
+ count_set_save(zi, &rset, hits);
+ else if ((i = rset_hits (rset)) >= 0)
+ *hits = i;
else
count_set (rset, hits);
resultSetAdd (zi, setname, 1, rset);
idx = scan_info->after - pos + scan_info->before;
else
idx = - pos - 1;
- logf (LOG_DEBUG, "%-3d %s", idx, name+len_prefix);
scan_info->list[idx].term = odr_malloc (scan_info->odr,
strlen(name + len_prefix)+1);
strcpy (scan_info->list[idx].term, name + len_prefix);
}
-static void scan_term_untrans (ODR odr, char **dstp, const char *src)
+static void scan_term_untrans (ZServerInfo *zi, int reg_type,
+ char **dstp, const char *src)
{
- char *dst = odr_malloc (odr, strlen(src)*2+1);
+ char *dst = odr_malloc (zi->odr, strlen(src)*2+1);
*dstp = dst;
while (*src)
{
- const char *cp = map_chrs_output (&src);
+ const char *cp = zebra_maps_output (zi->zebra_maps, reg_type, &src);
while (*cp)
*dst++ = *cp++;
}
char termz[IT_MAX_WORD+20];
AttrType use;
int use_value;
- AttrType completeness;
- int completeness_value;
struct scan_info *scan_info_array;
struct scan_entry *glist;
int ords[32], ord_no = 0;
int ptr[32];
+ int reg_type;
+ char *search_type = NULL;
+ int complete_flag;
+
logf (LOG_DEBUG, "scan, position = %d, num = %d", pos, num);
if (attributeset == VAL_NONE)
use_value = attr_find (&use, &attributeset);
logf (LOG_DEBUG, "use value %d", use_value);
- attr_init (&completeness, zapt, 6);
- completeness_value = attr_find (&completeness, NULL);
- logf (LOG_DEBUG, "completeness value %d", completeness_value);
+ if (zebra_maps_attr (zi->zebra_maps, zapt, ®_type, &search_type,
+ &complete_flag))
+ {
+ zi->errCode = 113;
+ return zi->errCode;
+ }
if (use_value == -1)
use_value = 1016;
for (base_no = 0; base_no < num_bases && ord_no < 32; base_no++)
{
- attent *attp;
+ int r;
+ attent attp;
data1_local_attribute *local_attr;
- attp = att_getentbyatt (attributeset, use_value);
- if (!attp)
+ if ((r=att_getentbyatt (zi, &attp, attributeset, use_value)))
{
logf (LOG_DEBUG, "att_getentbyatt fail. set=%d use=%d",
attributeset, use_value);
- return zi->errCode = 114;
+ if (r == -1)
+ zi->errCode = 114;
+ else
+ zi->errCode = 121;
}
if (zebTargetInfo_curDatabase (zi->zti, basenames[base_no]))
{
zi->errString = basenames[base_no];
return zi->errCode = 109; /* Database unavailable */
}
- for (local_attr = attp->local_attributes; local_attr && ord_no < 32;
+ for (local_attr = attp.local_attributes; local_attr && ord_no < 32;
local_attr = local_attr->next)
{
int ord;
- ord = zebTargetInfo_lookupSU (zi->zti, attp->attset_ordinal,
+ ord = zebTargetInfo_lookupSU (zi->zti, attp.attset_ordinal,
local_attr->local);
if (ord > 0)
ords[ord_no++] = ord;
int j, prefix_len = 0;
int before_tmp = before, after_tmp = after;
struct scan_info *scan_info = scan_info_array + i;
+ struct rpn_char_map_info rcmi;
+
+ rpn_char_map_prepare (zi, reg_type, &rcmi);
scan_info->before = before;
scan_info->after = after;
for (j = 0; j<before+after; j++)
scan_info->list[j].term = NULL;
termz[prefix_len++] = ords[i];
- termz[prefix_len++] =
- (completeness_value==2 || completeness_value==3) ? 'p': 'w';
+ termz[prefix_len++] = reg_type;
termz[prefix_len] = 0;
strcpy (scan_info->prefix, termz);
- trans_scan_term (zi, zapt, termz+prefix_len);
+ trans_scan_term (zi, zapt, termz+prefix_len, reg_type);
dict_scan (zi->dict, termz, &before_tmp, &after_tmp, scan_info,
scan_handle);
}
if (j0 == -1)
break;
- scan_term_untrans (zi->odr, &glist[i+before].term, mterm);
+ scan_term_untrans (zi, reg_type, &glist[i+before].term, mterm);
rset = rset_trunc (zi, &scan_info_array[j0].list[ptr[j0]].isam_p, 1);
ptr[j0]++;
rset_trunc (zi, &scan_info_array[j].list[ptr[j]].isam_p, 1);
bool_parms.key_size = sizeof(struct it_key);
- bool_parms.cmp = key_compare;
+ bool_parms.cmp = key_compare_it;
bool_parms.rset_l = rset;
bool_parms.rset_r = rset2;
if (j0 == -1)
break;
- scan_term_untrans (zi->odr, &glist[before-1-i].term, mterm);
+ scan_term_untrans (zi, reg_type, &glist[before-1-i].term, mterm);
rset = rset_trunc
(zi, &scan_info_array[j0].list[before-1-ptr[j0]].isam_p, 1);
&scan_info_array[j].list[before-1-ptr[j]].isam_p, 1);
bool_parms.key_size = sizeof(struct it_key);
- bool_parms.cmp = key_compare;
+ bool_parms.cmp = key_compare_it;
bool_parms.rset_l = rset;
bool_parms.rset_r = rset2;
projects / idzebra-moved-to-github.git / blobdiff