+ while (src->major < src->zapt->num_attributes)
+ {
+ Z_AttributeElement *element;
+
+ element = src->zapt->attributeList[src->major];
+ if (src->type == *element->attributeType)
+ {
+ switch (element->which)
+ {
+ case Z_AttributeValue_numeric:
+ ++(src->major);
+ if (element->attributeSet && attributeSetP)
+ {
+ oident *attrset;
+
+ attrset = oid_getentbyoid (element->attributeSet);
+ *attributeSetP = attrset->value;
+ }
+ return *element->value.numeric;
+ break;
+ case Z_AttributeValue_complex:
+ if (src->minor >= element->value.complex->num_list ||
+ element->value.complex->list[src->minor]->which !=
+ Z_StringOrNumeric_numeric)
+ break;
+ ++(src->minor);
+ if (element->attributeSet && attributeSetP)
+ {
+ oident *attrset;
+
+ attrset = oid_getentbyoid (element->attributeSet);
+ *attributeSetP = attrset->value;
+ }
+ return *element->value.complex->list[src->minor-1]->u.numeric;
+ default:
+ assert (0);
+ }
+ }
+ ++(src->major);
+ }
+ return -1;
+}
+
+static void attr_init (AttrType *src, Z_AttributesPlusTerm *zapt,
+ int type)
+{
+ src->zapt = zapt;
+ src->type = type;
+ src->major = 0;
+ src->minor = 0;
+}
+
+struct trunc_info {
+ int *ptr;
+ int *indx;
+ char **heap;
+ int heapnum;
+ int (*cmp)(const void *p1, const void *p2);
+ int keysize;
+ char *swapbuf;
+ char *tmpbuf;
+ char *buf;
+};
+
+static void heap_swap (struct trunc_info *ti, int i1, int i2)
+{
+ int swap;
+
+ swap = ti->ptr[i1];
+ ti->ptr[i1] = ti->ptr[i2];
+ ti->ptr[i2] = swap;
+}
+
+static void heap_delete (struct trunc_info *ti)
+{
+ int cur = 1, child = 2;
+
+ heap_swap (ti, 1, ti->heapnum--);
+ while (child <= ti->heapnum) {
+ if (child < ti->heapnum &&
+ (*ti->cmp)(ti->heap[ti->ptr[child]],
+ ti->heap[ti->ptr[1+child]]) > 0)
+ child++;
+ if ((*ti->cmp)(ti->heap[ti->ptr[cur]],
+ ti->heap[ti->ptr[child]]) > 0)
+ {
+ heap_swap (ti, cur, child);
+ cur = child;
+ child = 2*cur;
+ }
+ else
+ break;
+ }
+}
+
+static void heap_insert (struct trunc_info *ti, const char *buf, int indx)
+{
+ int cur, parent;
+
+ cur = ++(ti->heapnum);
+ memcpy (ti->heap[ti->ptr[cur]], buf, ti->keysize);
+ ti->indx[ti->ptr[cur]] = indx;
+ parent = cur/2;
+ while (parent && (*ti->cmp)(ti->heap[ti->ptr[parent]],
+ ti->heap[ti->ptr[cur]]) > 0)
+ {
+ heap_swap (ti, cur, parent);
+ cur = parent;
+ parent = cur/2;
+ }
+}
+
+static
+struct trunc_info *heap_init (int size, int key_size,
+ int (*cmp)(const void *p1, const void *p2))
+{
+ struct trunc_info *ti = xmalloc (sizeof(*ti));
+ int i;
+
+ ++size;
+ ti->heapnum = 0;
+ ti->keysize = key_size;
+ ti->cmp = cmp;
+ ti->indx = xmalloc (size * sizeof(*ti->indx));
+ ti->heap = xmalloc (size * sizeof(*ti->heap));
+ ti->ptr = xmalloc (size * sizeof(*ti->ptr));
+ ti->swapbuf = xmalloc (ti->keysize);
+ ti->tmpbuf = xmalloc (ti->keysize);
+ ti->buf = xmalloc (size * ti->keysize);
+ for (i = size; --i >= 0; )
+ {
+ ti->ptr[i] = i;
+ ti->heap[i] = ti->buf + ti->keysize * i;
+ }
+ return ti;
+}
+
+static void heap_close (struct trunc_info *ti)
+{
+ xfree (ti->ptr);
+ xfree (ti->indx);
+ xfree (ti->heap);
+ xfree (ti->swapbuf);
+ xfree (ti->tmpbuf);
+ xfree (ti);
+}
+
+static RSET rset_trunc_r (ISAM isam, ISAM_P *isam_p, int from, int to,
+ int merge_chunk)
+{
+ RSET result;
+ RSFD result_rsfd;
+ rset_temp_parms parms;
+
+ parms.key_size = sizeof(struct it_key);
+ result = rset_create (rset_kind_temp, &parms);
+ result_rsfd = rset_open (result, RSETF_WRITE|RSETF_SORT_SYSNO);
+
+ if (to - from > merge_chunk)
+ {
+ RSFD *rsfd;
+ RSET *rset;
+ int i, i_add = (to-from)/merge_chunk + 1;
+ struct trunc_info *ti;
+ int rscur = 0;
+ int rsmax = (to-from)/i_add + 1;
+
+ rset = xmalloc (sizeof(*rset) * rsmax);
+ rsfd = xmalloc (sizeof(*rsfd) * rsmax);
+
+ for (i = from; i < to; i += i_add)
+ {
+ if (i_add <= to - i)
+ rset[rscur] = rset_trunc_r (isam, isam_p, i, i+i_add,
+ merge_chunk);
+ else
+ rset[rscur] = rset_trunc_r (isam, isam_p, i, to,
+ merge_chunk);
+ rscur++;
+ }
+ ti = heap_init (rscur, sizeof(struct it_key), key_compare);
+ for (i = rscur; --i >= 0; )
+ {
+ rsfd[i] = rset_open (rset[i], RSETF_READ|RSETF_SORT_SYSNO);
+ if (rset_read (rset[i], rsfd[i], ti->tmpbuf))
+ heap_insert (ti, ti->tmpbuf, i);
+ else
+ {
+ rset_close (rset[i], rsfd[i]);
+ rset_delete (rset[i]);
+ }
+ }
+ while (ti->heapnum)
+ {
+ int n = ti->indx[ti->ptr[1]];
+
+ rset_write (result, result_rsfd, ti->heap[ti->ptr[1]]);
+
+ while (1)
+ {
+ if (!rset_read (rset[n], rsfd[n], ti->tmpbuf))
+ {
+ heap_delete (ti);
+ rset_close (rset[n], rsfd[n]);
+ rset_delete (rset[n]);
+ break;
+ }
+ if ((*ti->cmp)(ti->tmpbuf, ti->heap[ti->ptr[1]]) > 1)
+ {
+ heap_delete (ti);
+ heap_insert (ti, ti->tmpbuf, n);
+ break;
+ }
+ }
+ }
+ xfree (rset);
+ xfree (rsfd);
+ heap_close (ti);
+ }
+ else
+ {
+ ISPT *ispt;
+ int i;
+ struct trunc_info *ti;
+
+ ispt = xmalloc (sizeof(*ispt) * (to-from));
+
+ ti = heap_init (to-from, sizeof(struct it_key),
+ key_compare);
+ for (i = to-from; --i >= 0; )
+ {
+ ispt[i] = is_position (isam, isam_p[from+i]);
+ if (is_readkey (ispt[i], ti->tmpbuf))
+ heap_insert (ti, ti->tmpbuf, i);
+ else
+ is_pt_free (ispt[i]);
+ }
+ while (ti->heapnum)
+ {
+ int n = ti->indx[ti->ptr[1]];
+
+ rset_write (result, result_rsfd, ti->heap[ti->ptr[1]]);
+#if 0
+/* section that preserve all keys */
+ heap_delete (ti);
+ if (is_readkey (ispt[n], ti->tmpbuf))
+ heap_insert (ti, ti->tmpbuf, n);
+ else
+ is_pt_free (ispt[n]);
+#else
+/* section that preserve all keys with unique sysnos */
+ while (1)
+ {
+ if (!is_readkey (ispt[n], ti->tmpbuf))
+ {
+ heap_delete (ti);
+ is_pt_free (ispt[n]);
+ break;
+ }
+ if ((*ti->cmp)(ti->tmpbuf, ti->heap[ti->ptr[1]]) > 1)
+ {
+ heap_delete (ti);
+ heap_insert (ti, ti->tmpbuf, n);
+ break;
+ }
+ }
+#endif
+ }
+ heap_close (ti);
+ xfree (ispt);
+ }
+ rset_close (result, result_rsfd);
+ return result;
+}
+
+static int isam_trunc_cmp (const void *p1, const void *p2)
+{
+ ISAM_P i1 = *(ISAM_P*) p1;
+ ISAM_P i2 = *(ISAM_P*) p2;
+ int d;
+
+ d = is_type (i1) - is_type (i2);
+ if (d)
+ return d;
+ return is_block (i1) - is_block (i2);
+}
+
+static RSET rset_trunc (ISAM isam, ISAM_P *isam_p, int no)
+{
+
+ qsort (isam_p, no, sizeof(*isam_p), isam_trunc_cmp);
+ return rset_trunc_r (isam, isam_p, 0, no, 100);
+}
+
+struct grep_info {
+ ISAM_P *isam_p_buf;
+ int isam_p_size;
+ int isam_p_indx;
+};
+
+static void add_isam_p (const char *info, struct grep_info *p)
+{
+ if (p->isam_p_indx == p->isam_p_size)
+ {
+ ISAM_P *new_isam_p_buf;
+
+ p->isam_p_size = 2*p->isam_p_size + 100;
+ new_isam_p_buf = xmalloc (sizeof(*new_isam_p_buf) *
+ p->isam_p_size);
+ if (p->isam_p_buf)
+ {
+ memcpy (new_isam_p_buf, p->isam_p_buf,
+ p->isam_p_indx * sizeof(*p->isam_p_buf));
+ xfree (p->isam_p_buf);
+ }
+ p->isam_p_buf = new_isam_p_buf;
+ }
+ assert (*info == sizeof(*p->isam_p_buf));
+ memcpy (p->isam_p_buf + p->isam_p_indx, info+1, sizeof(*p->isam_p_buf));
+ (p->isam_p_indx)++;
+}
+
+static int grep_handle (char *name, const char *info, void *p)
+{
+ logf (LOG_DEBUG, "dict name: %s", name);
+ add_isam_p (info, p);
+ return 0;
+}
+
+static void gen_regular_rel (char *dst, int val, int islt)
+{
+ int dst_p = 1;
+ int w, d, i;
+ int pos = 0;
+ char numstr[20];
+
+ *dst = '(';
+ sprintf (numstr, "%d", val);
+ for (w = strlen(numstr); --w >= 0; pos++)
+ {
+ d = numstr[w];
+ if (pos > 0)
+ {
+ if (islt)
+ {
+ if (d == '0')
+ continue;
+ d--;
+ }
+ else
+ {
+ if (d == '9')
+ continue;
+ d++;
+ }
+ }
+
+ strcpy (dst + dst_p, numstr);
+ dst_p = strlen(dst) - pos - 1;
+
+ if (islt)
+ {
+ if (d != '0')
+ {
+ dst[dst_p++] = '[';
+ dst[dst_p++] = '0';
+ dst[dst_p++] = '-';
+ dst[dst_p++] = d;
+ dst[dst_p++] = ']';
+ }
+ else
+ dst[dst_p++] = d;
+ }
+ else
+ {
+ if (d != '9')
+ {
+ dst[dst_p++] = '[';
+ dst[dst_p++] = d;
+ dst[dst_p++] = '-';
+ dst[dst_p++] = '9';
+ dst[dst_p++] = ']';
+ }
+ else
+ dst[dst_p++] = d;
+ }
+ for (i = 0; i<pos; i++)
+ {
+ dst[dst_p++] = '[';
+ dst[dst_p++] = '0';
+ dst[dst_p++] = '-';
+ dst[dst_p++] = '9';
+ dst[dst_p++] = ']';
+ }
+ dst[dst_p++] = '|';
+ }
+ dst[dst_p] = '\0';
+ if (islt)
+ {
+ for (i=1; i<pos; i++)
+ strcat (dst, "[0-9]?");
+ }
+ else
+ {
+ for (i = 0; i <= pos; i++)
+ strcat (dst, "[0-9]");
+ strcat (dst, "[0-9]*");
+ }
+ strcat (dst, ")");
+}
+
+static int relational_term (ZServerInfo *zi, Z_AttributesPlusTerm *zapt,
+ const char *term_sub,
+ char *term_dict,
+ oid_value attributeSet,
+ struct grep_info *grep_info,
+ int *max_pos)
+{
+ AttrType relation;
+ int relation_value;
+ int term_value;
+ int r;
+
+ attr_init (&relation, zapt, 2);
+ relation_value = attr_find (&relation, NULL);
+ term_value = atoi (term_sub);
+
+ switch (relation_value)
+ {
+ case 1:
+ if (term_value <= 0)
+ return 1;
+ logf (LOG_DEBUG, "Relation <");
+ gen_regular_rel (term_dict + strlen(term_dict), term_value-1, 1);
+ break;
+ case 2:
+ if (term_value < 0)
+ return 1;
+ logf (LOG_DEBUG, "Relation <=");
+ gen_regular_rel (term_dict + strlen(term_dict), term_value, 1);
+ break;
+ case 4:
+ if (term_value < 0)
+ term_value = 0;
+ logf (LOG_DEBUG, "Relation >=");
+ gen_regular_rel (term_dict + strlen(term_dict), term_value, 0);
+ break;
+ case 5:
+ if (term_value < 0)
+ term_value = 0;
+ logf (LOG_DEBUG, "Relation >");
+ gen_regular_rel (term_dict + strlen(term_dict), term_value+1, 0);
+ break;
+ default:
+ return 0;
+ }
+ logf (LOG_DEBUG, "dict_lookup_grep: %s", term_dict);
+ r = dict_lookup_grep (zi->wordDict, term_dict, 0, grep_info, max_pos,
+ 0, grep_handle);
+ if (r)
+ logf (LOG_WARN, "dict_lookup_grep fail, rel=gt: %d", r);
+ logf (LOG_DEBUG, "%d positions", grep_info->isam_p_indx);
+ return 1;
+}
+
+static void verbatim_char (int ch, int *indx, char *dst)
+{
+ if (!isalnum (ch))
+ dst[(*indx)++] = '\\';
+ dst[(*indx)++] = ch;
+}
+
+static int field_term (ZServerInfo *zi, Z_AttributesPlusTerm *zapt,
+ const char *term_sub, int regType,
+ oid_value attributeSet, struct grep_info *grep_info,
+ int num_bases, char **basenames)
+{
+ char term_dict[2*IT_MAX_WORD+2];
+ int i, j, r, base_no;
+ AttrType truncation;
+ int truncation_value;
+ AttrType use;
+ int use_value;
+ oid_value curAttributeSet = attributeSet;
+
+ attr_init (&use, zapt, 1);
+ use_value = attr_find (&use, &curAttributeSet);
+ logf (LOG_DEBUG, "use value %d", use_value);
+ attr_init (&truncation, zapt, 5);
+ truncation_value = attr_find (&truncation, NULL);
+ logf (LOG_DEBUG, "truncation value %d", truncation_value);
+
+ if (use_value == -1)
+ use_value = 1016;
+
+ for (base_no = 0; base_no < num_bases; base_no++)
+ {
+ attent *attp;
+ data1_local_attribute *local_attr;
+ int max_pos, prefix_len = 0;
+
+ attp = att_getentbyatt (curAttributeSet, use_value);
+ if (!attp)
+ {
+ logf (LOG_DEBUG, "att_getentbyatt fail. set=%d use=%d",
+ curAttributeSet, use_value);
+ zi->errCode = 114;
+ return -1;
+ }
+ if (zebTargetInfo_curDatabase (zi->zti, basenames[base_no]))
+ {
+ zi->errCode = 109; /* Database unavailable */
+ zi->errString = basenames[base_no];
+ }
+ for (local_attr = attp->local_attributes; local_attr;
+ local_attr = local_attr->next)
+ {
+ int ord;
+
+ ord = zebTargetInfo_lookupSU (zi->zti, attp->attset_ordinal,
+ local_attr->local);
+ if (ord < 0)
+ continue;
+ if (prefix_len)
+ term_dict[prefix_len++] = '|';
+ else
+ term_dict[prefix_len++] = '(';
+ if ((ord >= 'A' && ord <= 'Z') || (ord >= 'a' && ord <= 'z'))
+ term_dict[prefix_len++] = ord;
+ else
+ {
+ term_dict[prefix_len++] = '\\';
+ term_dict[prefix_len++] = ord;
+ }
+ }
+ if (!prefix_len)
+ {
+ zi->errCode = 114;
+ return -1;
+ }
+ term_dict[prefix_len++] = ')';
+ term_dict[prefix_len++] = regType;
+ term_dict[prefix_len] = '\0';
+ if (!relational_term (zi, zapt, term_sub, term_dict,
+ attributeSet, grep_info, &max_pos))
+ {
+ const char *cp;
+
+ j = prefix_len;
+ switch (truncation_value)
+ {
+ case -1: /* not specified */
+ case 100: /* do not truncate */
+ term_dict[j++] = '(';
+ for (i = 0; term_sub[i]; i++)
+ verbatim_char (term_sub[i], &j, term_dict);
+ strcpy (term_dict+j, ")");
+ r = dict_lookup_grep (zi->wordDict, term_dict, 0, grep_info,
+ &max_pos, 0, grep_handle);
+ if (r)
+ logf (LOG_WARN, "dict_lookup_grep err, trunc=none:%d", r);
+ break;
+ case 1: /* right truncation */
+ term_dict[j++] = '(';
+ for (i = 0; term_sub[i]; i++)
+ verbatim_char (term_sub[i], &j, term_dict);
+ strcpy (term_dict+j, ".*)");
+ dict_lookup_grep (zi->wordDict, term_dict, 0, grep_info,
+ &max_pos, 0, grep_handle);
+ break;
+ case 2: /* left truncation */
+ case 3: /* left&right truncation */
+ zi->errCode = 120;
+ return -1;
+ case 101: /* process # in term */
+ term_dict[j++] = '(';
+ for (i=0; term_sub[i]; i++)
+ if (term_sub[i] == '#' && i > 2)
+ {
+ term_dict[j++] = '.';
+ term_dict[j++] = '*';
+ }
+ else
+ verbatim_char (term_sub[i], &j, term_dict);
+ strcpy (term_dict+j, ")");
+ r = dict_lookup_grep (zi->wordDict, term_dict, 0, grep_info,
+ &max_pos, 0, grep_handle);
+ if (r)
+ logf (LOG_WARN, "dict_lookup_grep err, trunc=#: %d",
+ r);
+ break;
+ case 102: /* regular expression */
+ sprintf (term_dict + j, "(%s)", term_sub);
+ r = dict_lookup_grep (zi->wordDict, term_dict, 0, grep_info,
+ &max_pos, 0, grep_handle);
+ if (r)
+ logf (LOG_WARN, "dict_lookup_grep err, trunc=regular: %d",
+ r);
+ break;
+ case 103: /* regular expression with error correction */
+ cp = term_sub;
+ r = 0;
+ if (*cp == '*' && cp[1] && cp[2])
+ {
+ r = atoi (cp+1);
+ cp += 2;
+ }
+ sprintf (term_dict + j, "(%s)", cp);
+ r = dict_lookup_grep (zi->wordDict, term_dict, r, grep_info,
+ &max_pos, j, grep_handle);
+ if (r)
+ logf (LOG_WARN, "dict_lookup_grep err, trunc=eregular: %d",
+ r);
+ break;
+ }
+ }
+ }
+ logf (LOG_DEBUG, "%d positions", grep_info->isam_p_indx);
+ return 0;
+}
+
+static void trans_term (ZServerInfo *zi, Z_AttributesPlusTerm *zapt,
+ char *termz)
+{
+ size_t i, sizez;
+ int sep = 0;