IDZEBRA 2.2.8
rpnsearch.c
Go to the documentation of this file.
1/* This file is part of the Zebra server.
2 Copyright (C) Index Data
3
4Zebra is free software; you can redistribute it and/or modify it under
5the terms of the GNU General Public License as published by the Free
6Software Foundation; either version 2, or (at your option) any later
7version.
8
9Zebra is distributed in the hope that it will be useful, but WITHOUT ANY
10WARRANTY; without even the implied warranty of MERCHANTABILITY or
11FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12for more details.
13
14You should have received a copy of the GNU General Public License
15along with this program; if not, write to the Free Software
16Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
17
18*/
19
20#if HAVE_CONFIG_H
21#include <config.h>
22#endif
23#include <stdio.h>
24#include <assert.h>
25#ifdef WIN32
26#include <io.h>
27#endif
28#if HAVE_UNISTD_H
29#include <unistd.h>
30#endif
31#include <ctype.h>
32
33#include <yaz/diagbib1.h>
34#include <yaz/snprintf.h>
35#include "index.h"
36#include <zebra_xpath.h>
37#include <attrfind.h>
38#include <charmap.h>
39#include <rset.h>
40
41static int log_level_set = 0;
42static int log_level_rpn = 0;
43
44static const char **rpn_char_map_handler(void *vp, const char **from, int len)
45{
46 struct rpn_char_map_info *p = (struct rpn_char_map_info *) vp;
47 const char **out = zebra_maps_input(p->zm, from, len, 0);
48#if 0
49 if (out && *out)
50 {
51 const char *outp = *out;
52 yaz_log(YLOG_LOG, "---");
53 while (*outp)
54 {
55 yaz_log(YLOG_LOG, "%02X", *outp);
56 outp++;
57 }
58 }
59#endif
60 return out;
61}
62
63void rpn_char_map_prepare(struct zebra_register *reg, zebra_map_t zm,
64 struct rpn_char_map_info *map_info)
65{
66 map_info->zm = zm;
67 if (zebra_maps_is_icu(zm))
68 dict_grep_cmap(reg->dict, 0, 0);
69 else
70 dict_grep_cmap(reg->dict, map_info, rpn_char_map_handler);
71}
72
73#define TERM_COUNT
74
75struct grep_info {
76#ifdef TERM_COUNT
77 int *term_no;
78#endif
79 ISAM_P *isam_p_buf;
80 int isam_p_size;
81 int isam_p_indx;
82 int trunc_max;
83 ZebraHandle zh;
84 const char *index_type;
85 ZebraSet termset;
86};
87
88static int add_isam_p(const char *name, const char *info,
89 struct grep_info *p)
90{
91 if (!log_level_set)
92 {
93 log_level_rpn = yaz_log_module_level("rpn");
94 log_level_set = 1;
95 }
96 /* we may have to stop this madness.. NOTE: -1 so that if
97 truncmax == trunxlimit we do *not* generate result sets */
98 if (p->isam_p_indx >= p->trunc_max - 1)
99 return 1;
100
101 if (p->isam_p_indx == p->isam_p_size)
102 {
103 ISAM_P *new_isam_p_buf;
104#ifdef TERM_COUNT
105 int *new_term_no;
106#endif
107 p->isam_p_size = 2*p->isam_p_size + 100;
108 new_isam_p_buf = (ISAM_P *) xmalloc(sizeof(*new_isam_p_buf) *
109 p->isam_p_size);
110 if (p->isam_p_buf)
111 {
112 memcpy(new_isam_p_buf, p->isam_p_buf,
113 p->isam_p_indx * sizeof(*p->isam_p_buf));
114 xfree(p->isam_p_buf);
115 }
116 p->isam_p_buf = new_isam_p_buf;
117
118#ifdef TERM_COUNT
119 new_term_no = (int *) xmalloc(sizeof(*new_term_no) * p->isam_p_size);
120 if (p->term_no)
121 {
122 memcpy(new_term_no, p->isam_p_buf,
123 p->isam_p_indx * sizeof(*p->term_no));
124 xfree(p->term_no);
125 }
126 p->term_no = new_term_no;
127#endif
128 }
129 assert(*info == sizeof(*p->isam_p_buf));
130 memcpy(p->isam_p_buf + p->isam_p_indx, info+1, sizeof(*p->isam_p_buf));
131
132 if (p->termset)
133 {
134 const char *db;
135 char term_tmp[IT_MAX_WORD];
136 int ord = 0;
137 const char *index_name;
138 int len = key_SU_decode(&ord, (const unsigned char *) name);
139
140 zebra_term_untrans (p->zh, p->index_type, term_tmp, name+len);
141 yaz_log(log_level_rpn, "grep: %d %c %s", ord, name[len], term_tmp);
142 zebraExplain_lookup_ord(p->zh->reg->zei,
143 ord, 0 /* index_type */, &db, &index_name);
144 yaz_log(log_level_rpn, "grep: db=%s index=%s", db, index_name);
145
146 resultSetAddTerm(p->zh, p->termset, name[len], db,
147 index_name, term_tmp);
148 }
149 (p->isam_p_indx)++;
150 return 0;
151}
152
153static int grep_handle(char *name, const char *info, void *p)
154{
155 return add_isam_p(name, info, (struct grep_info *) p);
156}
157
158static int term_pre(zebra_map_t zm, const char **src,
159 const char *ct1, int first)
160{
161 const char *s1, *s0 = *src;
162 const char **map;
163
164 /* skip white space */
165 while (*s0)
166 {
167 if (ct1 && strchr(ct1, *s0))
168 break;
169 s1 = s0;
170 map = zebra_maps_input(zm, &s1, strlen(s1), first);
171 if (**map != *CHR_SPACE)
172 break;
173 s0 = s1;
174 }
175 *src = s0;
176 return *s0;
177}
178
179
180static void esc_str(char *out_buf, size_t out_size,
181 const char *in_buf, int in_size)
182{
183 int k;
184
185 assert(out_buf);
186 assert(in_buf);
187 assert(out_size > 20);
188 *out_buf = '\0';
189 for (k = 0; k < in_size; k++)
190 {
191 int c = in_buf[k] & 0xff;
192 int pc;
193 if (c < 32 || c > 126)
194 pc = '?';
195 else
196 pc = c;
197 yaz_snprintf(out_buf + strlen(out_buf), 20, "%02X:%c ", c, pc);
198 if (strlen(out_buf) > out_size-20)
199 {
200 strcat(out_buf, "..");
201 break;
202 }
203 }
204}
205
206#define REGEX_CHARS " ^[]()|.*+?!\"$\\"
207
208static void add_non_space(const char *start, const char *end,
209 WRBUF term_dict,
210 WRBUF display_term,
211 const char **map, int q_map_match)
212{
213 size_t sz = end - start;
214
215 wrbuf_write(display_term, start, sz);
216 if (!q_map_match)
217 {
218 while (start < end)
219 {
220 if (strchr(REGEX_CHARS, *start))
221 wrbuf_putc(term_dict, '\\');
222 wrbuf_putc(term_dict, *start);
223 start++;
224 }
225 }
226 else
227 {
228 char tmpbuf[80];
229 esc_str(tmpbuf, sizeof(tmpbuf), map[0], strlen(map[0]));
230
231 wrbuf_puts(term_dict, map[0]);
232 }
233}
234
235
236/* ICU sort keys seem to be of the form
237 basechars \x01 accents \x01 length
238 For now we'll just right truncate from basechars . This
239 may give false hits due to accents not being used.
240*/
241static size_t icu_basechars(const char *buf, size_t i)
242{
243 while (i > 0 && buf[--i] != '\x01') /* skip length */
244 ;
245 while (i > 0 && buf[--i] != '\x01') /* skip accents */
246 ;
247 return i; /* only basechars left */
248}
249
250static int term_102_icu(zebra_map_t zm,
251 const char **src, WRBUF term_dict, int space_split,
252 WRBUF display_term)
253{
254 int no_terms = 0;
255 const char *s0 = *src, *s1;
256 while (*s0 == ' ')
257 s0++;
258 s1 = s0;
259 for (;;)
260 {
261 if (*s1 == ' ' && space_split)
262 break;
263 else if (*s1 && !strchr(REGEX_CHARS "-", *s1))
264 s1++;
265 else
266 {
267 /* EOF or regex reserved char */
268 if (s0 != s1)
269 {
270 const char *res_buf = 0;
271 size_t res_len = 0;
272 const char *display_buf;
273 size_t display_len;
274
275 zebra_map_tokenize_start(zm, s0, s1 - s0);
276
277 if (zebra_map_tokenize_next(zm, &res_buf, &res_len,
278 &display_buf, &display_len))
279 {
280 size_t i;
281 res_len = icu_basechars(res_buf, res_len);
282 for (i = 0; i < res_len; i++)
283 {
284 if (strchr(REGEX_CHARS "\\", res_buf[i]))
285 wrbuf_putc(term_dict, '\\');
286 if (res_buf[i] < 32)
287 wrbuf_putc(term_dict, '\x01');
288
289 wrbuf_putc(term_dict, res_buf[i]);
290 }
291 wrbuf_write(display_term, display_buf, display_len);
292
293 no_terms++;
294 }
295 }
296 if (*s1 == '\0')
297 break;
298
299 wrbuf_putc(term_dict, *s1);
300 wrbuf_putc(display_term, *s1);
301
302 s1++;
303 s0 = s1;
304 }
305 }
306 if (no_terms)
307 wrbuf_puts(term_dict, "\x01\x01.*");
308 *src = s1;
309 return no_terms;
310}
311
312static int term_100_icu(zebra_map_t zm,
313 const char **src, WRBUF term_dict,
314 WRBUF display_term,
315 int mode,
316 size_t token_number)
317{
318 size_t i;
319 const char *res_buf = 0;
320 size_t res_len = 0;
321 const char *display_buf;
322 size_t display_len;
323
324 zebra_map_tokenize_start(zm, *src, strlen(*src));
325 for (i = 0; i <= token_number; i++)
326 {
327 if (!zebra_map_tokenize_next(zm, &res_buf, &res_len,
328 &display_buf, &display_len))
329 return 0;
330 }
331 wrbuf_write(display_term, display_buf, display_len);
332 if (mode)
333 {
334 res_len = icu_basechars(res_buf, res_len);
335 }
336 if (mode & 2)
337 wrbuf_puts(term_dict, ".*");
338 for (i = 0; i < res_len; i++)
339 {
340 if (strchr(REGEX_CHARS "\\", res_buf[i]))
341 wrbuf_putc(term_dict, '\\');
342 if (res_buf[i] < 32)
343 wrbuf_putc(term_dict, '\x01');
344
345 wrbuf_putc(term_dict, res_buf[i]);
346 }
347 if (mode & 1)
348 wrbuf_puts(term_dict, ".*");
349 else if (mode)
350 wrbuf_puts(term_dict, "\x01\x01.*");
351 return 1;
352}
353
354/* term_100: handle term, where trunc = none(no operators at all) */
355static int term_100(zebra_map_t zm,
356 const char **src, WRBUF term_dict, int space_split,
357 WRBUF display_term)
358{
359 const char *s0;
360 const char **map;
361 int i = 0;
362
363 const char *space_start = 0;
364 const char *space_end = 0;
365
366 if (!term_pre(zm, src, 0, !space_split))
367 return 0;
368 s0 = *src;
369 while (*s0)
370 {
371 const char *s1 = s0;
372 int q_map_match = 0;
373 map = zebra_maps_search(zm, &s0, strlen(s0), &q_map_match);
374 if (space_split)
375 {
376 if (**map == *CHR_SPACE)
377 break;
378 }
379 else /* complete subfield only. */
380 {
381 if (**map == *CHR_SPACE)
382 { /* save space mapping for later .. */
383 space_start = s1;
384 space_end = s0;
385 continue;
386 }
387 else if (space_start)
388 { /* reload last space */
389 while (space_start < space_end)
390 {
391 if (strchr(REGEX_CHARS, *space_start))
392 wrbuf_putc(term_dict, '\\');
393 wrbuf_putc(display_term, *space_start);
394 wrbuf_putc(term_dict, *space_start);
395 space_start++;
396
397 }
398 /* and reset */
399 space_start = space_end = 0;
400 }
401 }
402 i++;
403
404 add_non_space(s1, s0, term_dict, display_term, map, q_map_match);
405 }
406 *src = s0;
407 return i;
408}
409
410/* term_101: handle term, where trunc = Process # */
411static int term_101(zebra_map_t zm,
412 const char **src, WRBUF term_dict, int space_split,
413 WRBUF display_term)
414{
415 const char *s0;
416 const char **map;
417 int i = 0;
418
419 if (!term_pre(zm, src, "#", !space_split))
420 return 0;
421 s0 = *src;
422 while (*s0)
423 {
424 if (*s0 == '#')
425 {
426 i++;
427 wrbuf_puts(term_dict, ".*");
428 wrbuf_putc(display_term, *s0);
429 s0++;
430 }
431 else
432 {
433 const char *s1 = s0;
434 int q_map_match = 0;
435 map = zebra_maps_search(zm, &s0, strlen(s0), &q_map_match);
436 if (space_split && **map == *CHR_SPACE)
437 break;
438
439 i++;
440 add_non_space(s1, s0, term_dict, display_term, map, q_map_match);
441 }
442 }
443 *src = s0;
444 return i;
445}
446
447/* term_103: handle term, where trunc = re-2 (regular expressions) */
448static int term_103(zebra_map_t zm, const char **src,
449 WRBUF term_dict, int *errors, int space_split,
450 WRBUF display_term)
451{
452 int i = 0;
453 const char *s0;
454 const char **map;
455
456 if (!term_pre(zm, src, "^\\()[].*+?|", !space_split))
457 return 0;
458 s0 = *src;
459 if (errors && *s0 == '+' && s0[1] && s0[2] == '+' && s0[3] &&
460 isdigit(((const unsigned char *)s0)[1]))
461 {
462 *errors = s0[1] - '0';
463 s0 += 3;
464 if (*errors > 3)
465 *errors = 3;
466 }
467 while (*s0)
468 {
469 if (strchr("^\\()[].*+?|-", *s0))
470 {
471 wrbuf_putc(display_term, *s0);
472 wrbuf_putc(term_dict, *s0);
473 s0++;
474 i++;
475 }
476 else
477 {
478 const char *s1 = s0;
479 int q_map_match = 0;
480 map = zebra_maps_search(zm, &s0, strlen(s0), &q_map_match);
481 if (space_split && **map == *CHR_SPACE)
482 break;
483
484 i++;
485 add_non_space(s1, s0, term_dict, display_term, map, q_map_match);
486 }
487 }
488 *src = s0;
489
490 return i;
491}
492
493/* term_103: handle term, where trunc = re-1 (regular expressions) */
494static int term_102(zebra_map_t zm, const char **src,
495 WRBUF term_dict, int space_split, WRBUF display_term)
496{
497 return term_103(zm, src, term_dict, NULL, space_split, display_term);
498}
499
500
501/* term_104: handle term, process ?n * # */
502static int term_104(zebra_map_t zm, const char **src,
503 WRBUF term_dict, int space_split, WRBUF display_term)
504{
505 const char *s0;
506 const char **map;
507 int i = 0;
508
509 if (!term_pre(zm, src, "?*#", !space_split))
510 return 0;
511 s0 = *src;
512 while (*s0)
513 {
514 if (*s0 == '?')
515 {
516 i++;
517 wrbuf_putc(display_term, *s0);
518 s0++;
519 if (*s0 >= '0' && *s0 <= '9')
520 {
521 int limit = 0;
522 while (*s0 >= '0' && *s0 <= '9')
523 {
524 limit = limit * 10 + (*s0 - '0');
525 wrbuf_putc(display_term, *s0);
526 s0++;
527 }
528 if (limit > 20)
529 limit = 20;
530 while (--limit >= 0)
531 {
532 wrbuf_puts(term_dict, ".?");
533 }
534 }
535 else
536 {
537 wrbuf_puts(term_dict, ".*");
538 }
539 }
540 else if (*s0 == '*')
541 {
542 i++;
543 wrbuf_puts(term_dict, ".*");
544 wrbuf_putc(display_term, *s0);
545 s0++;
546 }
547 else if (*s0 == '#')
548 {
549 i++;
550 wrbuf_puts(term_dict, ".");
551 wrbuf_putc(display_term, *s0);
552 s0++;
553 }
554 else
555 {
556 const char *s1 = s0;
557 int q_map_match = 0;
558 map = zebra_maps_search(zm, &s0, strlen(s0), &q_map_match);
559 if (space_split && **map == *CHR_SPACE)
560 break;
561
562 i++;
563 add_non_space(s1, s0, term_dict, display_term, map, q_map_match);
564 }
565 }
566 *src = s0;
567 return i;
568}
569
570/* term_105/106: handle term, process * ! and possibly right_truncate */
571static int term_105(zebra_map_t zm, const char **src,
572 WRBUF term_dict, int space_split,
573 WRBUF display_term, int right_truncate)
574{
575 const char *s0;
576 const char **map;
577 int i = 0;
578
579 if (!term_pre(zm, src, "\\*!", !space_split))
580 return 0;
581 s0 = *src;
582 while (*s0)
583 {
584 if (*s0 == '*')
585 {
586 i++;
587 wrbuf_puts(term_dict, ".*");
588 wrbuf_putc(display_term, *s0);
589 s0++;
590 }
591 else if (*s0 == '!')
592 {
593 i++;
594 wrbuf_putc(term_dict, '.');
595 wrbuf_putc(display_term, *s0);
596 s0++;
597 }
598 else if (*s0 == '\\')
599 {
600 i++;
601 wrbuf_puts(term_dict, "\\\\");
602 wrbuf_putc(display_term, *s0);
603 s0++;
604 }
605 else
606 {
607 const char *s1 = s0;
608 int q_map_match = 0;
609 map = zebra_maps_search(zm, &s0, strlen(s0), &q_map_match);
610 if (space_split && **map == *CHR_SPACE)
611 break;
612
613 i++;
614 add_non_space(s1, s0, term_dict, display_term, map, q_map_match);
615 }
616 }
617 if (right_truncate)
618 wrbuf_puts(term_dict, ".*");
619 *src = s0;
620 return i;
621}
622
623
624/* gen_regular_rel - generate regular expression from relation
625 * val: border value (inclusive)
626 * islt: 1 if <=; 0 if >=.
627 */
628static void gen_regular_rel(WRBUF dst, int val, int islt)
629{
630 int w, d, i;
631 int pos = 0;
632 char numstr[20];
633
634 yaz_log(YLOG_DEBUG, "gen_regular_rel. val=%d, islt=%d", val, islt);
635 if (val >= 0)
636 {
637 if (islt)
638 wrbuf_puts(dst, "(-[0-9]+|(");
639 else
640 wrbuf_puts(dst, "((");
641 }
642 else
643 {
644 if (!islt)
645 {
646 wrbuf_puts(dst, "([0-9]+|-(");
647 islt = 1;
648 }
649 else
650 {
651 wrbuf_puts(dst, "(-(");
652 islt = 0;
653 }
654 val = -val;
655 }
656 yaz_snprintf(numstr, sizeof(numstr), "%d", val);
657 for (w = strlen(numstr); --w >= 0; pos++)
658 {
659 d = numstr[w];
660 if (pos > 0)
661 {
662 if (islt)
663 {
664 if (d == '0')
665 continue;
666 d--;
667 }
668 else
669 {
670 if (d == '9')
671 continue;
672 d++;
673 }
674 }
675 wrbuf_write(dst, numstr, w);
676 if (islt)
677 {
678 if (d != '0')
679 {
680 wrbuf_putc(dst, '[');
681 wrbuf_putc(dst, '0');
682 wrbuf_putc(dst, '-');
683 wrbuf_putc(dst, d);
684 wrbuf_putc(dst, ']');
685 }
686 else
687 wrbuf_putc(dst, d);
688 }
689 else
690 {
691 if (d != '9')
692 {
693 wrbuf_putc(dst, '[');
694 wrbuf_putc(dst, d);
695 wrbuf_putc(dst, '-');
696 wrbuf_putc(dst, '9');
697 wrbuf_putc(dst, ']');
698 }
699 else
700 wrbuf_putc(dst, d);
701 }
702 for (i = 0; i < pos; i++)
703 wrbuf_puts(dst, "[0-9]");
704 wrbuf_putc(dst, '|');
705 }
706 if (islt)
707 {
708 /* match everything less than 10^(pos-1) */
709 wrbuf_puts(dst, "0*");
710 for (i = 1; i < pos; i++)
711 wrbuf_puts(dst, "[0-9]?");
712 }
713 else
714 {
715 /* match everything greater than 10^pos */
716 for (i = 0; i <= pos; i++)
717 wrbuf_puts(dst, "[0-9]");
718 wrbuf_puts(dst, "[0-9]*");
719 }
720 wrbuf_puts(dst, "))");
721}
722
723void string_rel_add_char(WRBUF term_p, WRBUF wsrc, int *indx)
724{
725 const char *src = wrbuf_cstr(wsrc);
726 if (src[*indx] == '\\')
727 {
728 wrbuf_putc(term_p, src[*indx]);
729 (*indx)++;
730 }
731 wrbuf_putc(term_p, src[*indx]);
732 (*indx)++;
733}
734
735/*
736 * > abc ([b-].*|a[c-].*|ab[d-].*|abc.+)
737 * ([^-a].*|a[^-b].*ab[^-c].*|abc.+)
738 * >= abc ([b-].*|a[c-].*|ab[c-].*)
739 * ([^-a].*|a[^-b].*|ab[c-].*)
740 * < abc ([-0].*|a[-a].*|ab[-b].*)
741 * ([^a-].*|a[^b-].*|ab[^c-].*)
742 * <= abc ([-0].*|a[-a].*|ab[-b].*|abc)
743 * ([^a-].*|a[^b-].*|ab[^c-].*|abc)
744 */
745static int string_relation(ZebraHandle zh, Z_AttributesPlusTerm *zapt,
746 const char **term_sub, WRBUF term_dict,
747 const Odr_oid *attributeSet,
748 zebra_map_t zm, int space_split,
749 WRBUF display_term,
750 int *error_code)
751{
752 AttrType relation;
753 int relation_value;
754 int i;
755 WRBUF term_component = wrbuf_alloc();
756
757 attr_init_APT(&relation, zapt, 2);
758 relation_value = attr_find(&relation, NULL);
759
760 *error_code = 0;
761 yaz_log(YLOG_DEBUG, "string relation value=%d", relation_value);
762 switch (relation_value)
763 {
764 case 1:
765 if (!term_100(zm, term_sub, term_component, space_split, display_term))
766 {
767 wrbuf_destroy(term_component);
768 return 0;
769 }
770 yaz_log(log_level_rpn, "Relation <");
771
772 wrbuf_putc(term_dict, '(');
773 for (i = 0; i < wrbuf_len(term_component); )
774 {
775 int j = 0;
776
777 if (i)
778 wrbuf_putc(term_dict, '|');
779 while (j < i)
780 string_rel_add_char(term_dict, term_component, &j);
781
782 wrbuf_putc(term_dict, '[');
783
784 wrbuf_putc(term_dict, '^');
785
786 wrbuf_putc(term_dict, 1);
787 wrbuf_putc(term_dict, FIRST_IN_FIELD_CHAR);
788
789 string_rel_add_char(term_dict, term_component, &i);
790 wrbuf_putc(term_dict, '-');
791
792 wrbuf_putc(term_dict, ']');
793 wrbuf_putc(term_dict, '.');
794 wrbuf_putc(term_dict, '*');
795 }
796 wrbuf_putc(term_dict, ')');
797 break;
798 case 2:
799 if (!term_100(zm, term_sub, term_component, space_split, display_term))
800 {
801 wrbuf_destroy(term_component);
802 return 0;
803 }
804 yaz_log(log_level_rpn, "Relation <=");
805
806 wrbuf_putc(term_dict, '(');
807 for (i = 0; i < wrbuf_len(term_component); )
808 {
809 int j = 0;
810
811 while (j < i)
812 string_rel_add_char(term_dict, term_component, &j);
813 wrbuf_putc(term_dict, '[');
814
815 wrbuf_putc(term_dict, '^');
816
817 wrbuf_putc(term_dict, 1);
818 wrbuf_putc(term_dict, FIRST_IN_FIELD_CHAR);
819
820 string_rel_add_char(term_dict, term_component, &i);
821 wrbuf_putc(term_dict, '-');
822
823 wrbuf_putc(term_dict, ']');
824 wrbuf_putc(term_dict, '.');
825 wrbuf_putc(term_dict, '*');
826
827 wrbuf_putc(term_dict, '|');
828 }
829 for (i = 0; i < wrbuf_len(term_component); )
830 string_rel_add_char(term_dict, term_component, &i);
831 wrbuf_putc(term_dict, ')');
832 break;
833 case 5:
834 if (!term_100(zm, term_sub, term_component, space_split, display_term))
835 {
836 wrbuf_destroy(term_component);
837 return 0;
838 }
839 yaz_log(log_level_rpn, "Relation >");
840
841 wrbuf_putc(term_dict, '(');
842 for (i = 0; i < wrbuf_len(term_component); )
843 {
844 int j = 0;
845
846 while (j < i)
847 string_rel_add_char(term_dict, term_component, &j);
848 wrbuf_putc(term_dict, '[');
849
850 wrbuf_putc(term_dict, '^');
851 wrbuf_putc(term_dict, '-');
852 string_rel_add_char(term_dict, term_component, &i);
853
854 wrbuf_putc(term_dict, ']');
855 wrbuf_putc(term_dict, '.');
856 wrbuf_putc(term_dict, '*');
857
858 wrbuf_putc(term_dict, '|');
859 }
860 for (i = 0; i < wrbuf_len(term_component); )
861 string_rel_add_char(term_dict, term_component, &i);
862 wrbuf_putc(term_dict, '.');
863 wrbuf_putc(term_dict, '+');
864 wrbuf_putc(term_dict, ')');
865 break;
866 case 4:
867 if (!term_100(zm, term_sub, term_component, space_split, display_term))
868 {
869 wrbuf_destroy(term_component);
870 return 0;
871 }
872 yaz_log(log_level_rpn, "Relation >=");
873
874 wrbuf_putc(term_dict, '(');
875 for (i = 0; i < wrbuf_len(term_component); )
876 {
877 int j = 0;
878
879 if (i)
880 wrbuf_putc(term_dict, '|');
881 while (j < i)
882 string_rel_add_char(term_dict, term_component, &j);
883 wrbuf_putc(term_dict, '[');
884
885 if (i < wrbuf_len(term_component)-1)
886 {
887 wrbuf_putc(term_dict, '^');
888 wrbuf_putc(term_dict, '-');
889 string_rel_add_char(term_dict, term_component, &i);
890 }
891 else
892 {
893 string_rel_add_char(term_dict, term_component, &i);
894 wrbuf_putc(term_dict, '-');
895 }
896 wrbuf_putc(term_dict, ']');
897 wrbuf_putc(term_dict, '.');
898 wrbuf_putc(term_dict, '*');
899 }
900 wrbuf_putc(term_dict, ')');
901 break;
902 case 3:
903 case 102:
904 case -1:
905 if (!**term_sub)
906 return 1;
907 yaz_log(log_level_rpn, "Relation =");
908 if (!term_100(zm, term_sub, term_component, space_split, display_term))
909 {
910 wrbuf_destroy(term_component);
911 return 0;
912 }
913 wrbuf_puts(term_dict, "(");
914 wrbuf_puts(term_dict, wrbuf_cstr(term_component));
915 wrbuf_puts(term_dict, ")");
916 break;
917 case 103:
918 yaz_log(log_level_rpn, "Relation always matches");
919 /* skip to end of term (we don't care what it is) */
920 while (**term_sub != '\0')
921 (*term_sub)++;
922 break;
923 default:
924 *error_code = YAZ_BIB1_UNSUPP_RELATION_ATTRIBUTE;
925 wrbuf_destroy(term_component);
926 return 0;
927 }
928 wrbuf_destroy(term_component);
929 return 1;
930}
931
932static ZEBRA_RES string_term(ZebraHandle zh, Z_AttributesPlusTerm *zapt,
933 const char **term_sub,
934 WRBUF term_dict,
935 const Odr_oid *attributeSet, NMEM stream,
936 struct grep_info *grep_info,
937 const char *index_type, int complete_flag,
938 WRBUF display_term,
939 const char *xpath_use,
940 struct ord_list **ol,
941 zebra_map_t zm, size_t token_number);
942
943ZEBRA_RES zebra_term_limits_APT(ZebraHandle zh,
944 Z_AttributesPlusTerm *zapt,
945 zint *hits_limit_value,
946 const char **term_ref_id_str,
947 NMEM nmem)
948{
949 AttrType term_ref_id_attr;
950 AttrType hits_limit_attr;
951 int term_ref_id_int;
952 zint hits_limit_from_attr;
953
954 attr_init_APT(&hits_limit_attr, zapt, 11);
955 hits_limit_from_attr = attr_find(&hits_limit_attr, NULL);
956
957 attr_init_APT(&term_ref_id_attr, zapt, 10);
958 term_ref_id_int = attr_find_ex(&term_ref_id_attr, NULL, term_ref_id_str);
959 if (term_ref_id_int >= 0)
960 {
961 char *res = nmem_malloc(nmem, 20);
962 yaz_snprintf(res, 20, "%d", term_ref_id_int);
963 *term_ref_id_str = res;
964 }
965 if (hits_limit_from_attr != -1)
966 *hits_limit_value = hits_limit_from_attr;
967
968 yaz_log(YLOG_DEBUG, "term_limits_APT ref_id=%s limit=" ZINT_FORMAT,
969 *term_ref_id_str ? *term_ref_id_str : "none",
970 *hits_limit_value);
971 return ZEBRA_OK;
972}
973
976static ZEBRA_RES search_term(ZebraHandle zh,
977 Z_AttributesPlusTerm *zapt,
978 const char **term_sub,
979 const Odr_oid *attributeSet,
980 zint hits_limit, NMEM stream,
981 struct grep_info *grep_info,
982 const char *index_type, int complete_flag,
983 const char *rank_type,
984 const char *xpath_use,
985 NMEM rset_nmem,
986 RSET *rset,
987 struct rset_key_control *kc,
988 zebra_map_t zm,
989 size_t token_number)
990{
991 ZEBRA_RES res;
992 struct ord_list *ol;
993 zint hits_limit_value = hits_limit;
994 const char *term_ref_id_str = 0;
995 WRBUF term_dict = wrbuf_alloc();
996 WRBUF display_term = wrbuf_alloc();
997 *rset = 0;
998 zebra_term_limits_APT(zh, zapt, &hits_limit_value, &term_ref_id_str,
999 stream);
1000 grep_info->isam_p_indx = 0;
1001 res = string_term(zh, zapt, term_sub, term_dict,
1002 attributeSet, stream, grep_info,
1003 index_type, complete_flag,
1004 display_term, xpath_use, &ol, zm, token_number);
1005 wrbuf_destroy(term_dict);
1006 if (res == ZEBRA_OK && *term_sub)
1007 {
1008 yaz_log(log_level_rpn, "term: %s", wrbuf_cstr(display_term));
1009 *rset = rset_trunc(zh, grep_info->isam_p_buf,
1010 grep_info->isam_p_indx, wrbuf_buf(display_term),
1011 wrbuf_len(display_term), rank_type,
1012 1 /* preserve pos */,
1013 zapt->term->which, rset_nmem,
1014 kc, kc->scope, ol, index_type, hits_limit_value,
1015 term_ref_id_str);
1016 if (!*rset)
1017 res = ZEBRA_FAIL;
1018 }
1019 wrbuf_destroy(display_term);
1020 return res;
1021}
1022
1023static ZEBRA_RES string_term(ZebraHandle zh, Z_AttributesPlusTerm *zapt,
1024 const char **term_sub,
1025 WRBUF term_dict,
1026 const Odr_oid *attributeSet, NMEM stream,
1027 struct grep_info *grep_info,
1028 const char *index_type, int complete_flag,
1029 WRBUF display_term,
1030 const char *xpath_use,
1031 struct ord_list **ol,
1032 zebra_map_t zm, size_t token_number)
1033{
1034 int r;
1035 AttrType truncation;
1036 int truncation_value;
1037 const char *termp;
1038 struct rpn_char_map_info rcmi;
1039
1040 int space_split = complete_flag ? 0 : 1;
1041 int ord = -1;
1042 int regex_range = 0;
1043 int max_pos, prefix_len = 0;
1044 int relation_error;
1045 char ord_buf[32];
1046 int ord_len, i;
1047
1048 *ol = ord_list_create(stream);
1049
1050 rpn_char_map_prepare(zh->reg, zm, &rcmi);
1051 attr_init_APT(&truncation, zapt, 5);
1052 truncation_value = attr_find(&truncation, NULL);
1053 yaz_log(log_level_rpn, "truncation value %d", truncation_value);
1054
1055 termp = *term_sub; /* start of term for each database */
1056
1057 if (zebra_apt_get_ord(zh, zapt, index_type, xpath_use,
1058 attributeSet, &ord) != ZEBRA_OK)
1059 {
1060 *term_sub = 0;
1061 return ZEBRA_FAIL;
1062 }
1063
1064 wrbuf_rewind(term_dict); /* new dictionary regexp term */
1065
1066 *ol = ord_list_append(stream, *ol, ord);
1067 ord_len = key_SU_encode(ord, ord_buf);
1068
1069 wrbuf_putc(term_dict, '(');
1070
1071 for (i = 0; i < ord_len; i++)
1072 {
1073 wrbuf_putc(term_dict, 1); /* our internal regexp escape char */
1074 wrbuf_putc(term_dict, ord_buf[i]);
1075 }
1076 wrbuf_putc(term_dict, ')');
1077
1078 prefix_len = wrbuf_len(term_dict);
1079
1080 if (zebra_maps_is_icu(zm))
1081 {
1082 int relation_value;
1083 AttrType relation;
1084
1085 attr_init_APT(&relation, zapt, 2);
1086 relation_value = attr_find(&relation, NULL);
1087 if (relation_value == 103) /* always matches */
1088 termp += strlen(termp); /* move to end of term */
1089 else if (relation_value == 3 || relation_value == 102 || relation_value == -1)
1090 {
1091 /* ICU case */
1092 switch (truncation_value)
1093 {
1094 case -1: /* not specified */
1095 case 100: /* do not truncate */
1096 if (!term_100_icu(zm, &termp, term_dict, display_term, 0, token_number))
1097 {
1098 *term_sub = 0;
1099 return ZEBRA_OK;
1100 }
1101 break;
1102 case 102:
1103 if (!term_102_icu(zm, &termp, term_dict, space_split, display_term))
1104 {
1105 *term_sub = 0;
1106 return ZEBRA_OK;
1107 }
1108 break;
1109 case 1: /* right truncation */
1110 if (!term_100_icu(zm, &termp, term_dict, display_term, 1, token_number))
1111 {
1112 *term_sub = 0;
1113 return ZEBRA_OK;
1114 }
1115 break;
1116 case 2:
1117 if (!term_100_icu(zm, &termp, term_dict, display_term, 2, token_number))
1118 {
1119 *term_sub = 0;
1120 return ZEBRA_OK;
1121 }
1122 break;
1123 case 3:
1124 if (!term_100_icu(zm, &termp, term_dict, display_term, 3, token_number))
1125 {
1126 *term_sub = 0;
1127 return ZEBRA_OK;
1128 }
1129 break;
1130 default:
1131 zebra_setError_zint(zh,
1132 YAZ_BIB1_UNSUPP_TRUNCATION_ATTRIBUTE,
1133 truncation_value);
1134 return ZEBRA_FAIL;
1135 }
1136 }
1137 else
1138 {
1139 zebra_setError_zint(zh,
1140 YAZ_BIB1_UNSUPP_RELATION_ATTRIBUTE,
1141 relation_value);
1142 return ZEBRA_FAIL;
1143 }
1144 }
1145 else
1146 {
1147 /* non-ICU case. using string.chr and friends */
1148 switch (truncation_value)
1149 {
1150 case -1: /* not specified */
1151 case 100: /* do not truncate */
1152 if (!string_relation(zh, zapt, &termp, term_dict,
1153 attributeSet,
1154 zm, space_split, display_term,
1155 &relation_error))
1156 {
1157 if (relation_error)
1158 {
1159 zebra_setError(zh, relation_error, 0);
1160 return ZEBRA_FAIL;
1161 }
1162 *term_sub = 0;
1163 return ZEBRA_OK;
1164 }
1165 break;
1166 case 1: /* right truncation */
1167 wrbuf_putc(term_dict, '(');
1168 if (!term_100(zm, &termp, term_dict, space_split, display_term))
1169 {
1170 *term_sub = 0;
1171 return ZEBRA_OK;
1172 }
1173 wrbuf_puts(term_dict, ".*)");
1174 break;
1175 case 2: /* left truncation */
1176 wrbuf_puts(term_dict, "(.*");
1177 if (!term_100(zm, &termp, term_dict, space_split, display_term))
1178 {
1179 *term_sub = 0;
1180 return ZEBRA_OK;
1181 }
1182 wrbuf_putc(term_dict, ')');
1183 break;
1184 case 3: /* left&right truncation */
1185 wrbuf_puts(term_dict, "(.*");
1186 if (!term_100(zm, &termp, term_dict, space_split, display_term))
1187 {
1188 *term_sub = 0;
1189 return ZEBRA_OK;
1190 }
1191 wrbuf_puts(term_dict, ".*)");
1192 break;
1193 case 101: /* process # in term */
1194 wrbuf_putc(term_dict, '(');
1195 if (!term_101(zm, &termp, term_dict, space_split, display_term))
1196 {
1197 *term_sub = 0;
1198 return ZEBRA_OK;
1199 }
1200 wrbuf_puts(term_dict, ")");
1201 break;
1202 case 102: /* Regexp-1 */
1203 wrbuf_putc(term_dict, '(');
1204 if (!term_102(zm, &termp, term_dict, space_split, display_term))
1205 {
1206 *term_sub = 0;
1207 return ZEBRA_OK;
1208 }
1209 wrbuf_putc(term_dict, ')');
1210 break;
1211 case 103: /* Regexp-2 */
1212 regex_range = 1;
1213 wrbuf_putc(term_dict, '(');
1214 if (!term_103(zm, &termp, term_dict, &regex_range,
1215 space_split, display_term))
1216 {
1217 *term_sub = 0;
1218 return ZEBRA_OK;
1219 }
1220 wrbuf_putc(term_dict, ')');
1221 break;
1222 case 104: /* process ?n * # term */
1223 wrbuf_putc(term_dict, '(');
1224 if (!term_104(zm, &termp, term_dict, space_split, display_term))
1225 {
1226 *term_sub = 0;
1227 return ZEBRA_OK;
1228 }
1229 wrbuf_putc(term_dict, ')');
1230 break;
1231 case 105: /* process * ! in term and right truncate */
1232 wrbuf_putc(term_dict, '(');
1233 if (!term_105(zm, &termp, term_dict, space_split, display_term, 1))
1234 {
1235 *term_sub = 0;
1236 return ZEBRA_OK;
1237 }
1238 wrbuf_putc(term_dict, ')');
1239 break;
1240 case 106: /* process * ! in term */
1241 wrbuf_putc(term_dict, '(');
1242 if (!term_105(zm, &termp, term_dict, space_split, display_term, 0))
1243 {
1244 *term_sub = 0;
1245 return ZEBRA_OK;
1246 }
1247 wrbuf_putc(term_dict, ')');
1248 break;
1249 default:
1250 zebra_setError_zint(zh,
1251 YAZ_BIB1_UNSUPP_TRUNCATION_ATTRIBUTE,
1252 truncation_value);
1253 return ZEBRA_FAIL;
1254 }
1255 }
1256 if (1)
1257 {
1258 char buf[1000];
1259 const char *input = wrbuf_cstr(term_dict) + prefix_len;
1260 esc_str(buf, sizeof(buf), input, strlen(input));
1261 }
1262 {
1263 WRBUF pr_wr = wrbuf_alloc();
1264
1265 wrbuf_write_escaped(pr_wr, wrbuf_buf(term_dict), wrbuf_len(term_dict));
1266 yaz_log(YLOG_LOG, "dict_lookup_grep: %s", wrbuf_cstr(pr_wr));
1267 wrbuf_destroy(pr_wr);
1268 }
1269 r = dict_lookup_grep(zh->reg->dict, wrbuf_cstr(term_dict), regex_range,
1270 grep_info, &max_pos,
1271 ord_len /* number of "exact" chars */,
1272 grep_handle);
1273 if (r == 1)
1274 zebra_set_partial_result(zh);
1275 else if (r)
1276 yaz_log(YLOG_WARN, "dict_lookup_grep fail %d", r);
1277 *term_sub = termp;
1278 yaz_log(YLOG_DEBUG, "%d positions", grep_info->isam_p_indx);
1279 return ZEBRA_OK;
1280}
1281
1282
1283
1284static void grep_info_delete(struct grep_info *grep_info)
1285{
1286#ifdef TERM_COUNT
1287 xfree(grep_info->term_no);
1288#endif
1289 xfree(grep_info->isam_p_buf);
1290}
1291
1292static ZEBRA_RES grep_info_prepare(ZebraHandle zh,
1293 Z_AttributesPlusTerm *zapt,
1294 struct grep_info *grep_info,
1295 const char *index_type)
1296{
1297#ifdef TERM_COUNT
1298 grep_info->term_no = 0;
1299#endif
1300 grep_info->trunc_max = atoi(res_get_def(zh->res, "truncmax", "10000"));
1301 grep_info->isam_p_size = 0;
1302 grep_info->isam_p_buf = NULL;
1303 grep_info->zh = zh;
1304 grep_info->index_type = index_type;
1305 grep_info->termset = 0;
1306 if (zapt)
1307 {
1308 AttrType truncmax;
1309 int truncmax_value;
1310
1311 attr_init_APT(&truncmax, zapt, 13);
1312 truncmax_value = attr_find(&truncmax, NULL);
1313 if (truncmax_value != -1)
1314 grep_info->trunc_max = truncmax_value;
1315 }
1316 if (zapt)
1317 {
1318 AttrType termset;
1319 int termset_value_numeric;
1320 const char *termset_value_string;
1321
1322 attr_init_APT(&termset, zapt, 8);
1323 termset_value_numeric =
1324 attr_find_ex(&termset, NULL, &termset_value_string);
1325 if (termset_value_numeric != -1)
1326 {
1327 zebra_setError(zh, YAZ_BIB1_UNSUPP_SEARCH, "termset");
1328 return ZEBRA_FAIL;
1329 }
1330 }
1331 return ZEBRA_OK;
1332}
1333
1334static ZEBRA_RES search_terms_chrmap(ZebraHandle zh,
1335 Z_AttributesPlusTerm *zapt,
1336 const char *termz,
1337 const Odr_oid *attributeSet,
1338 zint hits_limit,
1339 NMEM stream,
1340 const char *index_type, int complete_flag,
1341 const char *rank_type,
1342 const char *xpath_use,
1343 NMEM rset_nmem,
1344 RSET **result_sets, int *num_result_sets,
1345 struct rset_key_control *kc,
1346 zebra_map_t zm)
1347{
1348 struct grep_info grep_info;
1349 const char *termp = termz;
1350 int alloc_sets = 0;
1351
1352 *num_result_sets = 0;
1353 if (grep_info_prepare(zh, zapt, &grep_info, index_type) == ZEBRA_FAIL)
1354 return ZEBRA_FAIL;
1355 while (1)
1356 {
1357 ZEBRA_RES res;
1358
1359 if (alloc_sets == *num_result_sets)
1360 {
1361 int add = 10;
1362 RSET *rnew = (RSET *) nmem_malloc(stream, (alloc_sets+add) *
1363 sizeof(*rnew));
1364 if (alloc_sets)
1365 memcpy(rnew, *result_sets, alloc_sets * sizeof(*rnew));
1366 alloc_sets = alloc_sets + add;
1367 *result_sets = rnew;
1368 }
1369 res = search_term(zh, zapt, &termp, attributeSet, hits_limit,
1370 stream, &grep_info,
1371 index_type, complete_flag,
1372 rank_type,
1373 xpath_use, rset_nmem,
1374 &(*result_sets)[*num_result_sets],
1375 kc, zm,
1376 *num_result_sets);
1377 if (res != ZEBRA_OK)
1378 {
1379 int i;
1380 for (i = 0; i < *num_result_sets; i++)
1381 rset_delete((*result_sets)[i]);
1382 grep_info_delete(&grep_info);
1383 return res;
1384 }
1385 if ((*result_sets)[*num_result_sets] == 0)
1386 break;
1387 (*num_result_sets)++;
1388
1389 if (!*termp)
1390 break;
1391 }
1392 grep_info_delete(&grep_info);
1393 return ZEBRA_OK;
1394}
1395
1412static ZEBRA_RES search_terms_list(ZebraHandle zh,
1413 Z_AttributesPlusTerm *zapt,
1414 const char *termz,
1415 const Odr_oid *attributeSet,
1416 zint hits_limit,
1417 NMEM stream,
1418 const char *index_type, int complete_flag,
1419 const char *rank_type,
1420 const char *xpath_use,
1421 NMEM rset_nmem,
1422 RSET **result_sets, int *num_result_sets,
1423 struct rset_key_control *kc)
1424{
1425 zebra_map_t zm = zebra_map_get_or_add(zh->reg->zebra_maps, index_type);
1426 return search_terms_chrmap(zh, zapt, termz, attributeSet, hits_limit,
1427 stream, index_type, complete_flag,
1428 rank_type, xpath_use,
1429 rset_nmem, result_sets, num_result_sets,
1430 kc, zm);
1431}
1432
1433static RSET search_group(ZebraHandle zh,
1434 const char *unit,
1435 const char *term,
1436 NMEM rset_nmem,
1437 struct rset_key_control *kc)
1438{
1439 zinfo_index_category_t cat = zinfo_index_category_index;
1440 WRBUF w = wrbuf_alloc();
1441 wrbuf_puts(w, ZEBRA_GROUP_INDEX_NAME);
1442 wrbuf_puts(w, unit);
1443 int ord = zebraExplain_lookup_attr_str(zh->reg->zei, cat, "0",
1444 wrbuf_cstr(w));
1445 wrbuf_destroy(w);
1446 if (ord == -1)
1447 return 0;
1448 char ord_buf[32];
1449 int ord_len = key_SU_encode(ord, ord_buf);
1450 char term_dict[100];
1451 memcpy(term_dict, ord_buf, ord_len);
1452 strcpy(term_dict + ord_len, term);
1453 char *val = dict_lookup(zh->reg->dict, term_dict);
1454 if (!val)
1455 return 0;
1456 ISAM_P isam_p;
1457 assert(*val == sizeof(ISAM_P));
1458 memcpy(&isam_p, val+1, sizeof(isam_p));
1459 return zebra_create_rset_isam(zh, rset_nmem, kc, kc->scope,
1460 isam_p, 0);
1461}
1462
1465static ZEBRA_RES search_position(ZebraHandle zh,
1466 Z_AttributesPlusTerm *zapt,
1467 const Odr_oid *attributeSet,
1468 const char *index_type,
1469 NMEM rset_nmem,
1470 RSET *rset,
1471 struct rset_key_control *kc)
1472{
1473 int position_value;
1474 AttrType position;
1475 int ord = -1;
1476 char ord_buf[32];
1477 char term_dict[100];
1478 int ord_len;
1479 char *val;
1480 ISAM_P isam_p;
1481 zebra_map_t zm = zebra_map_get_or_add(zh->reg->zebra_maps, index_type);
1482
1483 attr_init_APT(&position, zapt, 3);
1484 position_value = attr_find(&position, NULL);
1485 switch(position_value)
1486 {
1487 case 3:
1488 case -1:
1489 return ZEBRA_OK;
1490 case 1:
1491 case 2:
1492 break;
1493 default:
1494 zebra_setError_zint(zh, YAZ_BIB1_UNSUPP_POSITION_ATTRIBUTE,
1495 position_value);
1496 return ZEBRA_FAIL;
1497 }
1498
1499
1500 if (!zebra_maps_is_first_in_field(zm))
1501 {
1502 zebra_setError_zint(zh, YAZ_BIB1_UNSUPP_POSITION_ATTRIBUTE,
1503 position_value);
1504 return ZEBRA_FAIL;
1505 }
1506
1507 if (zebra_apt_get_ord(zh, zapt, index_type, 0,
1508 attributeSet, &ord) != ZEBRA_OK)
1509 {
1510 return ZEBRA_FAIL;
1511 }
1512 ord_len = key_SU_encode(ord, ord_buf);
1513 memcpy(term_dict, ord_buf, ord_len);
1514 strcpy(term_dict+ord_len, FIRST_IN_FIELD_STR);
1515 val = dict_lookup(zh->reg->dict, term_dict);
1516 if (val)
1517 {
1518 assert(*val == sizeof(ISAM_P));
1519 memcpy(&isam_p, val+1, sizeof(isam_p));
1520
1521 *rset = zebra_create_rset_isam(zh, rset_nmem, kc, kc->scope,
1522 isam_p, 0);
1523 }
1524 return ZEBRA_OK;
1525}
1526
1529static ZEBRA_RES rpn_search_APT_phrase(ZebraHandle zh,
1530 Z_AttributesPlusTerm *zapt,
1531 const char *termz_org,
1532 const Odr_oid *attributeSet,
1533 zint hits_limit,
1534 NMEM stream,
1535 const char *index_type,
1536 int complete_flag,
1537 const char *rank_type,
1538 const char *xpath_use,
1539 NMEM rset_nmem,
1540 RSET *rset,
1541 struct rset_key_control *kc)
1542{
1543 RSET *result_sets = 0;
1544 int num_result_sets = 0;
1545 ZEBRA_RES res =
1546 search_terms_list(zh, zapt, termz_org, attributeSet, hits_limit,
1547 stream, index_type, complete_flag,
1548 rank_type, xpath_use,
1549 rset_nmem,
1550 &result_sets, &num_result_sets, kc);
1551
1552 if (res != ZEBRA_OK)
1553 return res;
1554
1555 if (num_result_sets > 0)
1556 {
1557 RSET first_set = 0;
1558 res = search_position(zh, zapt, attributeSet,
1559 index_type,
1560 rset_nmem, &first_set,
1561 kc);
1562 if (res != ZEBRA_OK)
1563 {
1564 int i;
1565 for (i = 0; i < num_result_sets; i++)
1566 rset_delete(result_sets[i]);
1567 return res;
1568 }
1569 if (first_set)
1570 {
1571 RSET *nsets = nmem_malloc(stream,
1572 sizeof(RSET) * (num_result_sets+1));
1573 nsets[0] = first_set;
1574 memcpy(nsets+1, result_sets, sizeof(RSET) * num_result_sets);
1575 result_sets = nsets;
1576 num_result_sets++;
1577 }
1578 }
1579 if (num_result_sets == 0)
1580 *rset = rset_create_null(rset_nmem, kc, 0);
1581 else if (num_result_sets == 1)
1582 *rset = result_sets[0];
1583 else
1584 *rset = rset_create_prox(rset_nmem, kc, kc->scope,
1585 num_result_sets, result_sets,
1586 1 /* ordered */, 0 /* exclusion */,
1587 3 /* relation */, 1 /* distance */);
1588 if (!*rset)
1589 return ZEBRA_FAIL;
1590 return ZEBRA_OK;
1591}
1592
1595static ZEBRA_RES rpn_search_APT_or_list(ZebraHandle zh,
1596 Z_AttributesPlusTerm *zapt,
1597 const char *termz_org,
1598 const Odr_oid *attributeSet,
1599 zint hits_limit,
1600 NMEM stream,
1601 const char *index_type,
1602 int complete_flag,
1603 const char *rank_type,
1604 const char *xpath_use,
1605 NMEM rset_nmem,
1606 RSET *rset,
1607 struct rset_key_control *kc)
1608{
1609 RSET *result_sets = 0;
1610 int num_result_sets = 0;
1611 int i;
1612 ZEBRA_RES res =
1613 search_terms_list(zh, zapt, termz_org, attributeSet, hits_limit,
1614 stream, index_type, complete_flag,
1615 rank_type, xpath_use,
1616 rset_nmem,
1617 &result_sets, &num_result_sets, kc);
1618 if (res != ZEBRA_OK)
1619 return res;
1620
1621 for (i = 0; i < num_result_sets; i++)
1622 {
1623 RSET first_set = 0;
1624 res = search_position(zh, zapt, attributeSet,
1625 index_type,
1626 rset_nmem, &first_set,
1627 kc);
1628 if (res != ZEBRA_OK)
1629 {
1630 for (i = 0; i < num_result_sets; i++)
1631 rset_delete(result_sets[i]);
1632 return res;
1633 }
1634
1635 if (first_set)
1636 {
1637 RSET tmp_set[2];
1638
1639 tmp_set[0] = first_set;
1640 tmp_set[1] = result_sets[i];
1641
1642 result_sets[i] = rset_create_prox(
1643 rset_nmem, kc, kc->scope,
1644 2, tmp_set,
1645 1 /* ordered */, 0 /* exclusion */,
1646 3 /* relation */, 1 /* distance */);
1647 }
1648 }
1649 if (num_result_sets == 0)
1650 *rset = rset_create_null(rset_nmem, kc, 0);
1651 else if (num_result_sets == 1)
1652 *rset = result_sets[0];
1653 else
1654 *rset = rset_create_or(rset_nmem, kc, kc->scope, 0 /* termid */,
1655 num_result_sets, result_sets);
1656 if (!*rset)
1657 return ZEBRA_FAIL;
1658 return ZEBRA_OK;
1659}
1660
1663static ZEBRA_RES rpn_search_APT_and_list(ZebraHandle zh,
1664 Z_AttributesPlusTerm *zapt,
1665 const char *termz_org,
1666 const Odr_oid *attributeSet,
1667 zint hits_limit,
1668 NMEM stream,
1669 const char *index_type,
1670 int complete_flag,
1671 const char *rank_type,
1672 const char *xpath_use,
1673 NMEM rset_nmem,
1674 RSET *rset,
1675 struct rset_key_control *kc)
1676{
1677 RSET *result_sets = 0;
1678 int num_result_sets = 0;
1679 int i;
1680 ZEBRA_RES res =
1681 search_terms_list(zh, zapt, termz_org, attributeSet, hits_limit,
1682 stream, index_type, complete_flag,
1683 rank_type, xpath_use,
1684 rset_nmem,
1685 &result_sets, &num_result_sets,
1686 kc);
1687 if (res != ZEBRA_OK)
1688 return res;
1689 for (i = 0; i < num_result_sets; i++)
1690 {
1691 RSET first_set = 0;
1692 res = search_position(zh, zapt, attributeSet,
1693 index_type,
1694 rset_nmem, &first_set,
1695 kc);
1696 if (res != ZEBRA_OK)
1697 {
1698 for (i = 0; i < num_result_sets; i++)
1699 rset_delete(result_sets[i]);
1700 return res;
1701 }
1702
1703 if (first_set)
1704 {
1705 RSET tmp_set[2];
1706
1707 tmp_set[0] = first_set;
1708 tmp_set[1] = result_sets[i];
1709
1710 result_sets[i] = rset_create_prox(
1711 rset_nmem, kc, kc->scope,
1712 2, tmp_set,
1713 1 /* ordered */, 0 /* exclusion */,
1714 3 /* relation */, 1 /* distance */);
1715 }
1716 }
1717
1718
1719 if (num_result_sets == 0)
1720 *rset = rset_create_null(rset_nmem, kc, 0);
1721 else if (num_result_sets == 1)
1722 *rset = result_sets[0];
1723 else
1724 *rset = rset_create_and(rset_nmem, kc, kc->scope,
1725 num_result_sets, result_sets);
1726 if (!*rset)
1727 return ZEBRA_FAIL;
1728 return ZEBRA_OK;
1729}
1730
1731static int numeric_relation(ZebraHandle zh, Z_AttributesPlusTerm *zapt,
1732 const char **term_sub,
1733 WRBUF term_dict,
1734 const Odr_oid *attributeSet,
1735 struct grep_info *grep_info,
1736 int *max_pos,
1737 zebra_map_t zm,
1738 WRBUF display_term,
1739 int *error_code)
1740{
1741 AttrType relation;
1742 int relation_value;
1743 int term_value;
1744 int r;
1745 WRBUF term_num = wrbuf_alloc();
1746
1747 *error_code = 0;
1748 attr_init_APT(&relation, zapt, 2);
1749 relation_value = attr_find(&relation, NULL);
1750
1751 yaz_log(log_level_rpn, "numeric relation value=%d", relation_value);
1752
1753 switch (relation_value)
1754 {
1755 case 1:
1756 yaz_log(log_level_rpn, "Relation <");
1757 if (!term_100(zm, term_sub, term_num, 1, display_term))
1758 {
1759 wrbuf_destroy(term_num);
1760 return 0;
1761 }
1762 term_value = atoi(wrbuf_cstr(term_num));
1763 gen_regular_rel(term_dict, term_value-1, 1);
1764 break;
1765 case 2:
1766 yaz_log(log_level_rpn, "Relation <=");
1767 if (!term_100(zm, term_sub, term_num, 1, display_term))
1768 {
1769 wrbuf_destroy(term_num);
1770 return 0;
1771 }
1772 term_value = atoi(wrbuf_cstr(term_num));
1773 gen_regular_rel(term_dict, term_value, 1);
1774 break;
1775 case 4:
1776 yaz_log(log_level_rpn, "Relation >=");
1777 if (!term_100(zm, term_sub, term_num, 1, display_term))
1778 {
1779 wrbuf_destroy(term_num);
1780 return 0;
1781 }
1782 term_value = atoi(wrbuf_cstr(term_num));
1783 gen_regular_rel(term_dict, term_value, 0);
1784 break;
1785 case 5:
1786 yaz_log(log_level_rpn, "Relation >");
1787 if (!term_100(zm, term_sub, term_num, 1, display_term))
1788 {
1789 wrbuf_destroy(term_num);
1790 return 0;
1791 }
1792 term_value = atoi(wrbuf_cstr(term_num));
1793 gen_regular_rel(term_dict, term_value+1, 0);
1794 break;
1795 case -1:
1796 case 102:
1797 case 3:
1798 yaz_log(log_level_rpn, "Relation =");
1799 if (!term_100(zm, term_sub, term_num, 1, display_term))
1800 {
1801 wrbuf_destroy(term_num);
1802 return 0;
1803 }
1804 term_value = atoi(wrbuf_cstr(term_num));
1805 wrbuf_printf(term_dict, "(0*%d)", term_value);
1806 break;
1807 case 103:
1808 /* term_tmp untouched.. */
1809 while (**term_sub != '\0')
1810 (*term_sub)++;
1811 break;
1812 default:
1813 *error_code = YAZ_BIB1_UNSUPP_RELATION_ATTRIBUTE;
1814 wrbuf_destroy(term_num);
1815 return 0;
1816 }
1817 r = dict_lookup_grep(zh->reg->dict, wrbuf_cstr(term_dict),
1818 0, grep_info, max_pos, 0, grep_handle);
1819
1820 if (r == 1)
1821 zebra_set_partial_result(zh);
1822 else if (r)
1823 yaz_log(YLOG_WARN, "dict_lookup_grep fail, rel = gt: %d", r);
1824 yaz_log(log_level_rpn, "%d positions", grep_info->isam_p_indx);
1825 wrbuf_destroy(term_num);
1826 return 1;
1827}
1828
1829static ZEBRA_RES numeric_term(ZebraHandle zh, Z_AttributesPlusTerm *zapt,
1830 const char **term_sub,
1831 WRBUF term_dict,
1832 const Odr_oid *attributeSet, NMEM stream,
1833 struct grep_info *grep_info,
1834 const char *index_type, int complete_flag,
1835 WRBUF display_term,
1836 const char *xpath_use,
1837 struct ord_list **ol)
1838{
1839 const char *termp;
1840 struct rpn_char_map_info rcmi;
1841 int max_pos;
1842 int relation_error = 0;
1843 int ord, ord_len, i;
1844 char ord_buf[32];
1845 zebra_map_t zm = zebra_map_get_or_add(zh->reg->zebra_maps, index_type);
1846
1847 *ol = ord_list_create(stream);
1848
1849 rpn_char_map_prepare(zh->reg, zm, &rcmi);
1850
1851 termp = *term_sub;
1852
1853 if (zebra_apt_get_ord(zh, zapt, index_type, xpath_use,
1854 attributeSet, &ord) != ZEBRA_OK)
1855 {
1856 return ZEBRA_FAIL;
1857 }
1858
1859 wrbuf_rewind(term_dict);
1860
1861 *ol = ord_list_append(stream, *ol, ord);
1862
1863 ord_len = key_SU_encode(ord, ord_buf);
1864
1865 wrbuf_putc(term_dict, '(');
1866 for (i = 0; i < ord_len; i++)
1867 {
1868 wrbuf_putc(term_dict, 1);
1869 wrbuf_putc(term_dict, ord_buf[i]);
1870 }
1871 wrbuf_putc(term_dict, ')');
1872
1873 if (!numeric_relation(zh, zapt, &termp, term_dict,
1874 attributeSet, grep_info, &max_pos, zm,
1875 display_term, &relation_error))
1876 {
1877 if (relation_error)
1878 {
1879 zebra_setError(zh, relation_error, 0);
1880 return ZEBRA_FAIL;
1881 }
1882 *term_sub = 0;
1883 return ZEBRA_OK;
1884 }
1885 *term_sub = termp;
1886 yaz_log(YLOG_DEBUG, "%d positions", grep_info->isam_p_indx);
1887 return ZEBRA_OK;
1888}
1889
1890
1891static ZEBRA_RES rpn_search_APT_numeric(ZebraHandle zh,
1892 Z_AttributesPlusTerm *zapt,
1893 const char *termz,
1894 const Odr_oid *attributeSet,
1895 zint hits_limit,
1896 NMEM stream,
1897 const char *index_type,
1898 int complete_flag,
1899 const char *rank_type,
1900 const char *xpath_use,
1901 NMEM rset_nmem,
1902 RSET *rset,
1903 struct rset_key_control *kc)
1904{
1905 const char *termp = termz;
1906 RSET *result_sets = 0;
1907 int num_result_sets = 0;
1908 ZEBRA_RES res;
1909 struct grep_info grep_info;
1910 int alloc_sets = 0;
1911 zint hits_limit_value = hits_limit;
1912 const char *term_ref_id_str = 0;
1913
1914 zebra_term_limits_APT(zh, zapt, &hits_limit_value, &term_ref_id_str,
1915 stream);
1916
1917 yaz_log(log_level_rpn, "APT_numeric t='%s'", termz);
1918 if (grep_info_prepare(zh, zapt, &grep_info, index_type) == ZEBRA_FAIL)
1919 return ZEBRA_FAIL;
1920 while (1)
1921 {
1922 struct ord_list *ol;
1923 WRBUF term_dict = wrbuf_alloc();
1924 WRBUF display_term = wrbuf_alloc();
1925 if (alloc_sets == num_result_sets)
1926 {
1927 int add = 10;
1928 RSET *rnew = (RSET *) nmem_malloc(stream, (alloc_sets+add) *
1929 sizeof(*rnew));
1930 if (alloc_sets)
1931 memcpy(rnew, result_sets, alloc_sets * sizeof(*rnew));
1932 alloc_sets = alloc_sets + add;
1933 result_sets = rnew;
1934 }
1935 yaz_log(YLOG_DEBUG, "APT_numeric termp=%s", termp);
1936 grep_info.isam_p_indx = 0;
1937 res = numeric_term(zh, zapt, &termp, term_dict,
1938 attributeSet, stream, &grep_info,
1939 index_type, complete_flag,
1940 display_term, xpath_use, &ol);
1941 wrbuf_destroy(term_dict);
1942 if (res == ZEBRA_FAIL || termp == 0)
1943 {
1944 wrbuf_destroy(display_term);
1945 break;
1946 }
1947 yaz_log(YLOG_DEBUG, "term: %s", wrbuf_cstr(display_term));
1948 result_sets[num_result_sets] =
1949 rset_trunc(zh, grep_info.isam_p_buf,
1950 grep_info.isam_p_indx, wrbuf_buf(display_term),
1951 wrbuf_len(display_term), rank_type,
1952 0 /* preserve position */,
1953 zapt->term->which, rset_nmem,
1954 kc, kc->scope, ol, index_type,
1955 hits_limit_value,
1956 term_ref_id_str);
1957 wrbuf_destroy(display_term);
1958 if (!result_sets[num_result_sets])
1959 break;
1960 num_result_sets++;
1961 if (!*termp)
1962 break;
1963 }
1964 grep_info_delete(&grep_info);
1965
1966 if (res != ZEBRA_OK)
1967 return res;
1968 if (num_result_sets == 0)
1969 *rset = rset_create_null(rset_nmem, kc, 0);
1970 else if (num_result_sets == 1)
1971 *rset = result_sets[0];
1972 else
1973 *rset = rset_create_and(rset_nmem, kc, kc->scope,
1974 num_result_sets, result_sets);
1975 if (!*rset)
1976 return ZEBRA_FAIL;
1977 return ZEBRA_OK;
1978}
1979
1980static ZEBRA_RES rpn_search_APT_local(ZebraHandle zh,
1981 Z_AttributesPlusTerm *zapt,
1982 const char *termz,
1983 const Odr_oid *attributeSet,
1984 NMEM stream,
1985 const char *rank_type, NMEM rset_nmem,
1986 RSET *rset,
1987 struct rset_key_control *kc)
1988{
1989 Record rec;
1990 zint sysno = atozint(termz);
1991
1992 if (sysno <= 0)
1993 sysno = 0;
1994 rec = rec_get(zh->reg->records, sysno);
1995 if (!rec)
1996 sysno = 0;
1997
1998 rec_free(&rec);
1999
2000 if (sysno <= 0)
2001 {
2002 *rset = rset_create_null(rset_nmem, kc, 0);
2003 }
2004 else
2005 {
2006 RSFD rsfd;
2007 struct it_key key;
2008 *rset = rset_create_temp(rset_nmem, kc, kc->scope,
2009 res_get(zh->res, "setTmpDir"), 0);
2010 rsfd = rset_open(*rset, RSETF_WRITE);
2011
2012 key.mem[0] = sysno;
2013 key.mem[1] = 1;
2014 key.len = 2;
2015 rset_write(rsfd, &key);
2016 rset_close(rsfd);
2017 }
2018 return ZEBRA_OK;
2019}
2020
2021static ZEBRA_RES rpn_sort_spec(ZebraHandle zh, Z_AttributesPlusTerm *zapt,
2022 const Odr_oid *attributeSet, NMEM stream,
2023 Z_SortKeySpecList *sort_sequence,
2024 const char *rank_type,
2025 NMEM rset_nmem,
2026 RSET *rset,
2027 struct rset_key_control *kc)
2028{
2029 int i;
2030 int sort_relation_value;
2031 AttrType sort_relation_type;
2032 Z_SortKeySpec *sks;
2033 Z_SortKey *sk;
2034 char termz[20];
2035
2036 attr_init_APT(&sort_relation_type, zapt, 7);
2037 sort_relation_value = attr_find(&sort_relation_type, &attributeSet);
2038
2039 if (!sort_sequence->specs)
2040 {
2041 sort_sequence->num_specs = 10;
2042 sort_sequence->specs = (Z_SortKeySpec **)
2043 nmem_malloc(stream, sort_sequence->num_specs *
2044 sizeof(*sort_sequence->specs));
2045 for (i = 0; i < sort_sequence->num_specs; i++)
2046 sort_sequence->specs[i] = 0;
2047 }
2048 if (zapt->term->which != Z_Term_general)
2049 i = 0;
2050 else
2051 i = atoi_n((char *) zapt->term->u.general->buf,
2052 zapt->term->u.general->len);
2053 if (i >= sort_sequence->num_specs)
2054 i = 0;
2055 yaz_snprintf(termz, sizeof(termz), "%d", i);
2056
2057 sks = (Z_SortKeySpec *) nmem_malloc(stream, sizeof(*sks));
2058 sks->sortElement = (Z_SortElement *)
2059 nmem_malloc(stream, sizeof(*sks->sortElement));
2060 sks->sortElement->which = Z_SortElement_generic;
2061 sk = sks->sortElement->u.generic = (Z_SortKey *)
2062 nmem_malloc(stream, sizeof(*sk));
2063 sk->which = Z_SortKey_sortAttributes;
2064 sk->u.sortAttributes = (Z_SortAttributes *)
2065 nmem_malloc(stream, sizeof(*sk->u.sortAttributes));
2066
2067 sk->u.sortAttributes->id = odr_oiddup_nmem(stream, attributeSet);
2068 sk->u.sortAttributes->list = zapt->attributes;
2069
2070 sks->sortRelation = (Odr_int *)
2071 nmem_malloc(stream, sizeof(*sks->sortRelation));
2072 if (sort_relation_value == 1)
2073 *sks->sortRelation = Z_SortKeySpec_ascending;
2074 else if (sort_relation_value == 2)
2075 *sks->sortRelation = Z_SortKeySpec_descending;
2076 else
2077 *sks->sortRelation = Z_SortKeySpec_ascending;
2078
2079 sks->caseSensitivity = (Odr_int *)
2080 nmem_malloc(stream, sizeof(*sks->caseSensitivity));
2081 *sks->caseSensitivity = 0;
2082
2083 sks->which = Z_SortKeySpec_null;
2084 sks->u.null = odr_nullval ();
2085 sort_sequence->specs[i] = sks;
2086 *rset = rset_create_null(rset_nmem, kc, 0);
2087 return ZEBRA_OK;
2088}
2089
2090
2091static int rpn_check_xpath(ZebraHandle zh, Z_AttributesPlusTerm *zapt,
2092 const Odr_oid *attributeSet,
2093 struct xpath_location_step *xpath, int max,
2094 NMEM mem)
2095{
2096 const Odr_oid *curAttributeSet = attributeSet;
2097 AttrType use;
2098 const char *use_string = 0;
2099
2100 attr_init_APT(&use, zapt, 1);
2101 attr_find_ex(&use, &curAttributeSet, &use_string);
2102
2103 if (!use_string || *use_string != '/')
2104 return -1;
2105
2106 return zebra_parse_xpath_str(use_string, xpath, max, mem);
2107}
2108
2109
2110
2111static RSET xpath_trunc(ZebraHandle zh, NMEM stream,
2112 const char *index_type, const char *term,
2113 const char *xpath_use,
2114 NMEM rset_nmem,
2115 struct rset_key_control *kc)
2116{
2117 struct grep_info grep_info;
2118 int ord = zebraExplain_lookup_attr_str(zh->reg->zei,
2119 zinfo_index_category_index,
2120 index_type, xpath_use);
2121 if (grep_info_prepare(zh, 0 /* zapt */, &grep_info, "0") == ZEBRA_FAIL)
2122 return rset_create_null(rset_nmem, kc, 0);
2123
2124 if (ord < 0)
2125 return rset_create_null(rset_nmem, kc, 0);
2126 else
2127 {
2128 int i, max_pos;
2129 char ord_buf[32];
2130 RSET rset;
2131 WRBUF term_dict = wrbuf_alloc();
2132 int ord_len = key_SU_encode(ord, ord_buf);
2133 int term_type = Z_Term_characterString;
2134 const char *flags = "void";
2135
2136 wrbuf_putc(term_dict, '(');
2137 for (i = 0; i < ord_len; i++)
2138 {
2139 wrbuf_putc(term_dict, 1);
2140 wrbuf_putc(term_dict, ord_buf[i]);
2141 }
2142 wrbuf_putc(term_dict, ')');
2143 wrbuf_puts(term_dict, term);
2144
2145 grep_info.isam_p_indx = 0;
2146 dict_lookup_grep(zh->reg->dict, wrbuf_cstr(term_dict), 0,
2147 &grep_info, &max_pos, 0, grep_handle);
2148 yaz_log(YLOG_DEBUG, "%s %d positions", term,
2149 grep_info.isam_p_indx);
2150 rset = rset_trunc(zh, grep_info.isam_p_buf,
2151 grep_info.isam_p_indx, term, strlen(term),
2152 flags, 1, term_type, rset_nmem,
2153 kc, kc->scope, 0, index_type, 0 /* hits_limit */,
2154 0 /* term_ref_id_str */);
2155 grep_info_delete(&grep_info);
2156 wrbuf_destroy(term_dict);
2157 return rset;
2158 }
2159}
2160
2161static
2162ZEBRA_RES rpn_search_xpath(ZebraHandle zh,
2163 NMEM stream, const char *rank_type, RSET rset,
2164 int xpath_len, struct xpath_location_step *xpath,
2165 NMEM rset_nmem,
2166 RSET *rset_out,
2167 struct rset_key_control *kc)
2168{
2169 int i;
2170 int always_matches = rset ? 0 : 1;
2171
2172 if (xpath_len < 0)
2173 {
2174 *rset_out = rset;
2175 return ZEBRA_OK;
2176 }
2177
2178 yaz_log(YLOG_DEBUG, "xpath len=%d", xpath_len);
2179 for (i = 0; i < xpath_len; i++)
2180 {
2181 yaz_log(log_level_rpn, "XPATH %d %s", i, xpath[i].part);
2182
2183 }
2184
2185 /*
2186 //a -> a/.*
2187 //a/b -> b/a/.*
2188 /a -> a/
2189 /a/b -> b/a/
2190
2191 / -> none
2192
2193 a[@attr = value]/b[@other = othervalue]
2194
2195 /e/@a val range(e/,range(@a,freetext(w,1015,val),@a),e/)
2196 /a/b val range(b/a/,freetext(w,1016,val),b/a/)
2197 /a/b/@c val range(b/a/,range(@c,freetext(w,1016,val),@c),b/a/)
2198 /a/b[@c = y] val range(b/a/,freetext(w,1016,val),b/a/,@c = y)
2199 /a[@c = y]/b val range(a/,range(b/a/,freetext(w,1016,val),b/a/),a/,@c = y)
2200 /a[@c = x]/b[@c = y] range(a/,range(b/a/,freetext(w,1016,val),b/a/,@c = y),a/,@c = x)
2201
2202 */
2203
2204 dict_grep_cmap(zh->reg->dict, 0, 0);
2205
2206 {
2207 int level = xpath_len;
2208 int first_path = 1;
2209
2210 while (--level >= 0)
2211 {
2212 WRBUF xpath_rev = wrbuf_alloc();
2213 int i;
2214 RSET rset_start_tag = 0, rset_end_tag = 0, rset_attr = 0;
2215
2216 for (i = level; i >= 1; --i)
2217 {
2218 const char *cp = xpath[i].part;
2219 if (*cp)
2220 {
2221 for (; *cp; cp++)
2222 {
2223 if (*cp == '*')
2224 wrbuf_puts(xpath_rev, "[^/]*");
2225 else if (*cp == ' ')
2226 wrbuf_puts(xpath_rev, "\001 ");
2227 else
2228 wrbuf_putc(xpath_rev, *cp);
2229
2230 /* wrbuf_putc does not null-terminate , but
2231 wrbuf_puts below ensures it does.. so xpath_rev
2232 is OK iff length is > 0 */
2233 }
2234 wrbuf_puts(xpath_rev, "/");
2235 }
2236 else if (i == 1) /* // case */
2237 wrbuf_puts(xpath_rev, ".*");
2238 }
2239 if (xpath[level].predicate &&
2240 xpath[level].predicate->which == XPATH_PREDICATE_RELATION &&
2241 xpath[level].predicate->u.relation.name[0])
2242 {
2243 WRBUF wbuf = wrbuf_alloc();
2244 wrbuf_puts(wbuf, xpath[level].predicate->u.relation.name+1);
2245 if (xpath[level].predicate->u.relation.value)
2246 {
2247 const char *cp = xpath[level].predicate->u.relation.value;
2248 wrbuf_putc(wbuf, '=');
2249
2250 while (*cp)
2251 {
2252 if (strchr(REGEX_CHARS, *cp))
2253 wrbuf_putc(wbuf, '\\');
2254 wrbuf_putc(wbuf, *cp);
2255 cp++;
2256 }
2257 }
2258 rset_attr = xpath_trunc(
2259 zh, stream, "0", wrbuf_cstr(wbuf),
2260 ZEBRA_XPATH_ATTR_NAME,
2261 rset_nmem, kc);
2262 wrbuf_destroy(wbuf);
2263 }
2264 else
2265 {
2266 if (!first_path)
2267 {
2268 wrbuf_destroy(xpath_rev);
2269 continue;
2270 }
2271 }
2272 yaz_log(log_level_rpn, "xpath_rev (%d) = %s", level,
2273 wrbuf_cstr(xpath_rev));
2274 if (wrbuf_len(xpath_rev))
2275 {
2276 rset_start_tag = xpath_trunc(zh, stream, "0",
2277 wrbuf_cstr(xpath_rev),
2278 ZEBRA_XPATH_ELM_BEGIN,
2279 rset_nmem, kc);
2280 if (always_matches)
2281 rset = rset_start_tag;
2282 else
2283 {
2284 rset_end_tag = xpath_trunc(zh, stream, "0",
2285 wrbuf_cstr(xpath_rev),
2286 ZEBRA_XPATH_ELM_END,
2287 rset_nmem, kc);
2288
2289 rset = rset_create_between(rset_nmem, kc, kc->scope,
2290 rset_start_tag, rset, NULL,
2291 rset_end_tag, rset_attr);
2292 }
2293 }
2294 wrbuf_destroy(xpath_rev);
2295 first_path = 0;
2296 }
2297 }
2298 *rset_out = rset;
2299 return ZEBRA_OK;
2300}
2301
2302#define MAX_XPATH_STEPS 10
2303
2304static ZEBRA_RES rpn_search_database(ZebraHandle zh,
2305 Z_AttributesPlusTerm *zapt,
2306 const Odr_oid *attributeSet,
2307 zint hits_limit, NMEM stream,
2308 Z_SortKeySpecList *sort_sequence,
2309 NMEM rset_nmem,
2310 RSET *rset,
2311 struct rset_key_control *kc);
2312
2313static ZEBRA_RES rpn_search_APT(ZebraHandle zh, Z_AttributesPlusTerm *zapt,
2314 const Odr_oid *attributeSet,
2315 zint hits_limit, NMEM stream,
2316 Z_SortKeySpecList *sort_sequence,
2317 int num_bases, const char **basenames,
2318 NMEM rset_nmem,
2319 RSET *rset,
2320 struct rset_key_control *kc)
2321{
2322 RSET *rsets = nmem_malloc(stream, num_bases * sizeof(*rsets));
2323 ZEBRA_RES res = ZEBRA_OK;
2324 int i;
2325 for (i = 0; i < num_bases; i++)
2326 {
2327
2328 if (zebraExplain_curDatabase(zh->reg->zei, basenames[i]))
2329 {
2330 zebra_setError(zh, YAZ_BIB1_DATABASE_UNAVAILABLE,
2331 basenames[i]);
2332 res = ZEBRA_FAIL;
2333 break;
2334 }
2335 res = rpn_search_database(zh, zapt, attributeSet, hits_limit, stream,
2336 sort_sequence,
2337 rset_nmem, rsets+i, kc);
2338 if (res != ZEBRA_OK)
2339 break;
2340 }
2341 if (res != ZEBRA_OK)
2342 { /* must clean up the already created sets */
2343 while (--i >= 0)
2344 rset_delete(rsets[i]);
2345 *rset = 0;
2346 }
2347 else
2348 {
2349 if (num_bases == 1)
2350 *rset = rsets[0];
2351 else if (num_bases == 0)
2352 *rset = rset_create_null(rset_nmem, kc, 0);
2353 else
2354 *rset = rset_create_or(rset_nmem, kc, kc->scope, 0 /* TERMID */,
2355 num_bases, rsets);
2356 }
2357 return res;
2358}
2359
2360static ZEBRA_RES rpn_search_database(ZebraHandle zh,
2361 Z_AttributesPlusTerm *zapt,
2362 const Odr_oid *attributeSet,
2363 zint hits_limit, NMEM stream,
2364 Z_SortKeySpecList *sort_sequence,
2365 NMEM rset_nmem,
2366 RSET *rset,
2367 struct rset_key_control *kc)
2368{
2369 ZEBRA_RES res = ZEBRA_OK;
2370 const char *index_type;
2371 char *search_type = NULL;
2372 char rank_type[128];
2373 int complete_flag;
2374 int sort_flag;
2375 char termz[IT_MAX_WORD+1];
2376 int xpath_len;
2377 const char *xpath_use = 0;
2378 struct xpath_location_step xpath[MAX_XPATH_STEPS];
2379
2380 if (!log_level_set)
2381 {
2382 log_level_rpn = yaz_log_module_level("rpn");
2383 log_level_set = 1;
2384 }
2385 zebra_maps_attr(zh->reg->zebra_maps, zapt, &index_type, &search_type,
2386 rank_type, &complete_flag, &sort_flag);
2387
2388 yaz_log(YLOG_DEBUG, "index_type=%s", index_type);
2389 yaz_log(YLOG_DEBUG, "complete_flag=%d", complete_flag);
2390 yaz_log(YLOG_DEBUG, "search_type=%s", search_type);
2391 yaz_log(YLOG_DEBUG, "rank_type=%s", rank_type);
2392
2393 if (zapt_term_to_utf8(zh, zapt, termz) == ZEBRA_FAIL)
2394 return ZEBRA_FAIL;
2395
2396 if (sort_flag)
2397 return rpn_sort_spec(zh, zapt, attributeSet, stream, sort_sequence,
2398 rank_type, rset_nmem, rset, kc);
2399 /* consider if an X-Path query is used */
2400 xpath_len = rpn_check_xpath(zh, zapt, attributeSet,
2401 xpath, MAX_XPATH_STEPS, stream);
2402 if (xpath_len >= 0)
2403 {
2404 if (xpath[xpath_len-1].part[0] == '@')
2405 xpath_use = ZEBRA_XPATH_ATTR_CDATA; /* last step is attribute */
2406 else
2407 xpath_use = ZEBRA_XPATH_CDATA; /* searching for cdata */
2408
2409 if (1)
2410 {
2411 AttrType relation;
2412 int relation_value;
2413
2414 attr_init_APT(&relation, zapt, 2);
2415 relation_value = attr_find(&relation, NULL);
2416
2417 if (relation_value == 103) /* alwaysmatches */
2418 {
2419 *rset = 0; /* signal no "term" set */
2420 return rpn_search_xpath(zh, stream, rank_type, *rset,
2421 xpath_len, xpath, rset_nmem, rset, kc);
2422 }
2423 }
2424 }
2425
2426 /* search using one of the various search type strategies
2427 termz is our UTF-8 search term
2428 attributeSet is top-level default attribute set
2429 stream is ODR for search
2430 reg_id is the register type
2431 complete_flag is 1 for complete subfield, 0 for incomplete
2432 xpath_use is use-attribute to be used for X-Path search, 0 for none
2433 */
2434 if (!strcmp(search_type, "phrase"))
2435 {
2436 res = rpn_search_APT_phrase(zh, zapt, termz, attributeSet, hits_limit,
2437 stream,
2438 index_type, complete_flag, rank_type,
2439 xpath_use,
2440 rset_nmem,
2441 rset, kc);
2442 }
2443 else if (!strcmp(search_type, "and-list"))
2444 {
2445 res = rpn_search_APT_and_list(zh, zapt, termz, attributeSet, hits_limit,
2446 stream,
2447 index_type, complete_flag, rank_type,
2448 xpath_use,
2449 rset_nmem,
2450 rset, kc);
2451 }
2452 else if (!strcmp(search_type, "or-list"))
2453 {
2454 res = rpn_search_APT_or_list(zh, zapt, termz, attributeSet, hits_limit,
2455 stream,
2456 index_type, complete_flag, rank_type,
2457 xpath_use,
2458 rset_nmem,
2459 rset, kc);
2460 }
2461 else if (!strcmp(search_type, "local"))
2462 {
2463 res = rpn_search_APT_local(zh, zapt, termz, attributeSet, stream,
2464 rank_type, rset_nmem, rset, kc);
2465 }
2466 else if (!strcmp(search_type, "numeric"))
2467 {
2468 res = rpn_search_APT_numeric(zh, zapt, termz, attributeSet, hits_limit,
2469 stream,
2470 index_type, complete_flag, rank_type,
2471 xpath_use,
2472 rset_nmem,
2473 rset, kc);
2474 }
2475 else
2476 {
2477 zebra_setError(zh, YAZ_BIB1_UNSUPP_SEARCH, 0);
2478 res = ZEBRA_FAIL;
2479 }
2480 if (res != ZEBRA_OK)
2481 return res;
2482 if (!*rset)
2483 return ZEBRA_FAIL;
2484 return rpn_search_xpath(zh, stream, rank_type, *rset,
2485 xpath_len, xpath, rset_nmem, rset, kc);
2486}
2487
2488static ZEBRA_RES rpn_search_structure(ZebraHandle zh, Z_RPNStructure *zs,
2489 const Odr_oid *attributeSet,
2490 zint hits_limit,
2491 NMEM stream, NMEM rset_nmem,
2492 Z_SortKeySpecList *sort_sequence,
2493 int num_bases, const char **basenames,
2494 RSET **result_sets, int *num_result_sets,
2495 Z_Operator *parent_op,
2496 struct rset_key_control *kc);
2497
2498ZEBRA_RES rpn_get_top_approx_limit(ZebraHandle zh, Z_RPNStructure *zs,
2499 zint *approx_limit)
2500{
2501 ZEBRA_RES res = ZEBRA_OK;
2502 if (zs->which == Z_RPNStructure_complex)
2503 {
2504 if (res == ZEBRA_OK)
2505 res = rpn_get_top_approx_limit(zh, zs->u.complex->s1,
2506 approx_limit);
2507 if (res == ZEBRA_OK)
2508 res = rpn_get_top_approx_limit(zh, zs->u.complex->s2,
2509 approx_limit);
2510 }
2511 else if (zs->which == Z_RPNStructure_simple)
2512 {
2513 if (zs->u.simple->which == Z_Operand_APT)
2514 {
2515 Z_AttributesPlusTerm *zapt = zs->u.simple->u.attributesPlusTerm;
2516 AttrType global_hits_limit_attr;
2517 int l;
2518
2519 attr_init_APT(&global_hits_limit_attr, zapt, 12);
2520
2521 l = attr_find(&global_hits_limit_attr, NULL);
2522 if (l != -1)
2523 *approx_limit = l;
2524 }
2525 }
2526 return res;
2527}
2528
2529ZEBRA_RES rpn_search_top(ZebraHandle zh, Z_RPNStructure *zs,
2530 const Odr_oid *attributeSet,
2531 zint hits_limit,
2532 NMEM stream, NMEM rset_nmem,
2533 Z_SortKeySpecList *sort_sequence,
2534 int num_bases, const char **basenames,
2535 RSET *result_set)
2536{
2537 RSET *result_sets = 0;
2538 int num_result_sets = 0;
2539 ZEBRA_RES res;
2540 struct rset_key_control *kc = zebra_key_control_create(zh);
2541
2542 res = rpn_search_structure(zh, zs, attributeSet, hits_limit,
2543 stream, rset_nmem,
2544 sort_sequence,
2545 num_bases, basenames,
2546 &result_sets, &num_result_sets,
2547 0 /* no parent op */,
2548 kc);
2549 if (res != ZEBRA_OK)
2550 {
2551 int i;
2552 for (i = 0; i < num_result_sets; i++)
2553 rset_delete(result_sets[i]);
2554 *result_set = 0;
2555 }
2556 else
2557 {
2558 assert(num_result_sets == 1);
2559 assert(result_sets);
2560 assert(*result_sets);
2561 *result_set = *result_sets;
2562 }
2563 (*kc->dec)(kc);
2564 return res;
2565}
2566
2567ZEBRA_RES rpn_search_structure(ZebraHandle zh, Z_RPNStructure *zs,
2568 const Odr_oid *attributeSet, zint hits_limit,
2569 NMEM stream, NMEM rset_nmem,
2570 Z_SortKeySpecList *sort_sequence,
2571 int num_bases, const char **basenames,
2572 RSET **result_sets, int *num_result_sets,
2573 Z_Operator *parent_op,
2574 struct rset_key_control *kc)
2575{
2576 *num_result_sets = 0;
2577 if (zs->which == Z_RPNStructure_complex)
2578 {
2579 ZEBRA_RES res;
2580 Z_Operator *zop = zs->u.complex->roperator;
2581 RSET *result_sets_l = 0;
2582 int num_result_sets_l = 0;
2583 RSET *result_sets_r = 0;
2584 int num_result_sets_r = 0;
2585
2586 res = rpn_search_structure(zh, zs->u.complex->s1,
2587 attributeSet, hits_limit, stream, rset_nmem,
2588 sort_sequence,
2589 num_bases, basenames,
2590 &result_sets_l, &num_result_sets_l,
2591 zop, kc);
2592 if (res != ZEBRA_OK)
2593 {
2594 int i;
2595 for (i = 0; i < num_result_sets_l; i++)
2596 rset_delete(result_sets_l[i]);
2597 return res;
2598 }
2599 res = rpn_search_structure(zh, zs->u.complex->s2,
2600 attributeSet, hits_limit, stream, rset_nmem,
2601 sort_sequence,
2602 num_bases, basenames,
2603 &result_sets_r, &num_result_sets_r,
2604 zop, kc);
2605 if (res != ZEBRA_OK)
2606 {
2607 int i;
2608 for (i = 0; i < num_result_sets_l; i++)
2609 rset_delete(result_sets_l[i]);
2610 for (i = 0; i < num_result_sets_r; i++)
2611 rset_delete(result_sets_r[i]);
2612 return res;
2613 }
2614
2615 /* make a new list of result for all children */
2616 *num_result_sets = num_result_sets_l + num_result_sets_r;
2617 *result_sets = nmem_malloc(stream, *num_result_sets *
2618 sizeof(**result_sets));
2619 memcpy(*result_sets, result_sets_l,
2620 num_result_sets_l * sizeof(**result_sets));
2621 memcpy(*result_sets + num_result_sets_l, result_sets_r,
2622 num_result_sets_r * sizeof(**result_sets));
2623
2624 if (!parent_op || parent_op->which != zop->which
2625 || (zop->which != Z_Operator_and &&
2626 zop->which != Z_Operator_or))
2627 {
2628 /* parent node different from this one (or non-present) */
2629 /* we must combine result sets now */
2630 RSET rset;
2631 switch (zop->which)
2632 {
2633 case Z_Operator_and:
2634 rset = rset_create_and(rset_nmem, kc,
2635 kc->scope,
2636 *num_result_sets, *result_sets);
2637 break;
2638 case Z_Operator_or:
2639 rset = rset_create_or(rset_nmem, kc,
2640 kc->scope, 0, /* termid */
2641 *num_result_sets, *result_sets);
2642 break;
2643 case Z_Operator_and_not:
2644 rset = rset_create_not(rset_nmem, kc,
2645 kc->scope,
2646 (*result_sets)[0],
2647 (*result_sets)[1]);
2648 break;
2649 case Z_Operator_prox:
2650 if (zop->u.prox->which != Z_ProximityOperator_known)
2651 {
2652 zebra_setError(zh,
2653 YAZ_BIB1_UNSUPP_PROX_UNIT_CODE,
2654 0);
2655 return ZEBRA_FAIL;
2656 }
2657 if (*zop->u.prox->u.known == Z_ProxUnit_word)
2658 {
2659 rset = rset_create_prox(rset_nmem, kc,
2660 kc->scope,
2661 *num_result_sets, *result_sets,
2662 *zop->u.prox->ordered,
2663 (!zop->u.prox->exclusion ?
2664 0 : *zop->u.prox->exclusion),
2665 *zop->u.prox->relationType,
2666 *zop->u.prox->distance );
2667 }
2668 else if (*zop->u.prox->u.known >= 3 &&
2669 *zop->u.prox->u.known <= 10 &&
2670 *num_result_sets == 2)
2671 {
2672 /* Z39.50 known proximity units */
2673 static const char *units[] = {
2674 "sentence", /* (3) */
2675 "paragraph", /* (4) */
2676 "section", /* (5) */
2677 "chapter", /* (6) */
2678 "document", /* (7) */
2679 "element", /* (8) */
2680 "subelement", /* (9) */
2681 "elementType" /* (10) */
2682 };
2683 const char *unit = units[*zop->u.prox->u.known - 3];
2684 RSET begin_set = search_group(zh, unit, "begin",
2685 rset_nmem, kc);
2686 RSET end_set = search_group(zh, unit, "end",
2687 rset_nmem, kc);
2688 if (begin_set && end_set)
2689 {
2690 rset = rset_create_between(
2691 rset_nmem, kc, kc->scope,
2692 begin_set,
2693 (*result_sets[0]), (*result_sets)[1], end_set,
2694 0 /* rset_attr */);
2695 }
2696 else
2697 {
2698 if (begin_set)
2699 rset_delete(begin_set);
2700 if (end_set)
2701 rset_delete(end_set);
2702 zebra_setError_zint(zh,
2703 YAZ_BIB1_UNSUPP_PROX_UNIT_CODE,
2704 *zop->u.prox->u.known);
2705 return ZEBRA_FAIL;
2706
2707 }
2708 }
2709 else
2710 {
2711 zebra_setError_zint(zh,
2712 YAZ_BIB1_UNSUPP_PROX_UNIT_CODE,
2713 *zop->u.prox->u.known);
2714 return ZEBRA_FAIL;
2715 }
2716 break;
2717 default:
2718 zebra_setError(zh, YAZ_BIB1_OPERATOR_UNSUPP, 0);
2719 return ZEBRA_FAIL;
2720 }
2721 *num_result_sets = 1;
2722 *result_sets = nmem_malloc(stream, *num_result_sets *
2723 sizeof(**result_sets));
2724 (*result_sets)[0] = rset;
2725 }
2726 }
2727 else if (zs->which == Z_RPNStructure_simple)
2728 {
2729 RSET rset;
2730 ZEBRA_RES res;
2731
2732 if (zs->u.simple->which == Z_Operand_APT)
2733 {
2734 yaz_log(YLOG_DEBUG, "rpn_search_APT");
2735 res = rpn_search_APT(zh, zs->u.simple->u.attributesPlusTerm,
2736 attributeSet, hits_limit,
2737 stream, sort_sequence,
2738 num_bases, basenames, rset_nmem, &rset,
2739 kc);
2740 if (res != ZEBRA_OK)
2741 return res;
2742 }
2743 else if (zs->u.simple->which == Z_Operand_resultSetId)
2744 {
2745 yaz_log(YLOG_DEBUG, "rpn_search_ref");
2746 rset = resultSetRef(zh, zs->u.simple->u.resultSetId);
2747 if (!rset)
2748 {
2749 zebra_setError(zh,
2750 YAZ_BIB1_SPECIFIED_RESULT_SET_DOES_NOT_EXIST,
2751 zs->u.simple->u.resultSetId);
2752 return ZEBRA_FAIL;
2753 }
2754 rset_dup(rset);
2755 }
2756 else
2757 {
2758 zebra_setError(zh, YAZ_BIB1_UNSUPP_SEARCH, 0);
2759 return ZEBRA_FAIL;
2760 }
2761 *num_result_sets = 1;
2762 *result_sets = nmem_malloc(stream, *num_result_sets *
2763 sizeof(**result_sets));
2764 (*result_sets)[0] = rset;
2765 }
2766 else
2767 {
2768 zebra_setError(zh, YAZ_BIB1_UNSUPP_SEARCH, 0);
2769 return ZEBRA_FAIL;
2770 }
2771 return ZEBRA_OK;
2772}
2773
2774
2775
2776/*
2777 * Local variables:
2778 * c-basic-offset: 4
2779 * c-file-style: "Stroustrup"
2780 * indent-tabs-mode: nil
2781 * End:
2782 * vim: shiftwidth=4 tabstop=8 expandtab
2783 */
2784
attr_find
int attr_find(AttrType *src, const Odr_oid **attribute_set_oid)
Definition attrfind.c:99
attr_init_APT
void attr_init_APT(AttrType *src, Z_AttributesPlusTerm *zapt, int type)
Definition attrfind.c:27
attr_find_ex
int attr_find_ex(AttrType *src, const Odr_oid **attribute_set_oid, const char **string_value)
Definition attrfind.c:45
zebra_apt_get_ord
ZEBRA_RES zebra_apt_get_ord(ZebraHandle zh, Z_AttributesPlusTerm *zapt, const char *index_type, const char *xpath_use, const Odr_oid *curAttributeSet, int *ord)
Definition attribute.c:135
CHR_SPACE
const char * CHR_SPACE
Definition charmap.c:49
dict_grep_cmap
void dict_grep_cmap(Dict dict, void *vp, const char **(*cmap)(void *vp, const char **from, int len))
install character mapping handler for dict_lookup_grep
Definition lookgrep.c:445
dict_lookup_grep
int dict_lookup_grep(Dict dict, const char *p, int range, void *client, int *max_pos, int init_pos, int(*f)(char *name, const char *info, void *client))
regular expression search with error correction
Definition lookgrep.c:374
dict_lookup
char * dict_lookup(Dict dict, const char *p)
lookup item in dictionary
Definition lookup.c:100
resultSetRef
RSET resultSetRef(ZebraHandle zh, const char *resultSetId)
Definition zsets.c:1075
zebra_set_partial_result
void zebra_set_partial_result(ZebraHandle zh)
Definition zebraapi.c:1064
zebra_term_untrans
int zebra_term_untrans(ZebraHandle zh, const char *index_type, char *dst, const char *src)
Definition untrans.c:31
zebra_key_control_create
struct rset_key_control * zebra_key_control_create(ZebraHandle zh)
Definition kcontrol.c:57
FIRST_IN_FIELD_STR
#define FIRST_IN_FIELD_STR
Definition index.h:419
zapt_term_to_utf8
ZEBRA_RES zapt_term_to_utf8(ZebraHandle zh, Z_AttributesPlusTerm *zapt, char *termz)
Definition zaptterm.c:32
zebra_setError
void zebra_setError(ZebraHandle zh, int code, const char *addinfo)
Definition zebraapi.c:2755
zebra_setError_zint
void zebra_setError_zint(ZebraHandle zh, int code, zint i)
Definition zebraapi.c:2764
FIRST_IN_FIELD_CHAR
#define FIRST_IN_FIELD_CHAR
Definition index.h:420
rset_trunc
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, struct rset_key_control *kctrl, int scope, struct ord_list *ol, const char *index_type, zint hits_limit, const char *term_ref_id)
Definition trunc.c:403
zebra_create_rset_isam
RSET zebra_create_rset_isam(ZebraHandle zh, NMEM rset_nmem, struct rset_key_control *kctl, int scope, ISAM_P pos, TERMID termid)
Definition rset_isam.c:32
resultSetAddTerm
void resultSetAddTerm(ZebraHandle zh, ZebraSet s, int reg_type, const char *db, const char *index_name, const char *term)
Definition zsets.c:188
ISAM_P
zint ISAM_P
Definition isamc.h:28
key_SU_decode
int key_SU_decode(int *ch, const unsigned char *out)
Definition su_codec.c:64
IT_MAX_WORD
#define IT_MAX_WORD
Definition it_key.h:27
key_SU_encode
int key_SU_encode(int ch, char *out)
Definition su_codec.c:31
end
static void end(struct zebra_register *reg, void *set_handle)
Definition rank1.c:156
add
static void add(void *set_handle, int seqno, TERMID term)
Definition rank1.c:168
ZEBRA_XPATH_ELM_END
#define ZEBRA_XPATH_ELM_END
Definition recctrl.h:36
ZEBRA_XPATH_ATTR_CDATA
#define ZEBRA_XPATH_ATTR_CDATA
Definition recctrl.h:45
ZEBRA_XPATH_CDATA
#define ZEBRA_XPATH_CDATA
Definition recctrl.h:39
ZEBRA_XPATH_ELM_BEGIN
#define ZEBRA_XPATH_ELM_BEGIN
Definition recctrl.h:33
ZEBRA_GROUP_INDEX_NAME
#define ZEBRA_GROUP_INDEX_NAME
Definition recctrl.h:47
ZEBRA_XPATH_ATTR_NAME
#define ZEBRA_XPATH_ATTR_NAME
Definition recctrl.h:42
rec_get
Record rec_get(Records p, zint sysno)
gets record - with given system number
Definition records.c:928
rec_free
void rec_free(Record *recpp)
frees record (from memory)
Definition records.c:1044
res_get_def
const char * res_get_def(Res r, const char *name, const char *def)
Definition res.c:313
res_get
const char * res_get(Res r, const char *name)
Definition res.c:294
grep_info_delete
static void grep_info_delete(struct grep_info *grep_info)
Definition rpnsearch.c:1284
esc_str
static void esc_str(char *out_buf, size_t out_size, const char *in_buf, int in_size)
Definition rpnsearch.c:180
grep_info_prepare
static ZEBRA_RES grep_info_prepare(ZebraHandle zh, Z_AttributesPlusTerm *zapt, struct grep_info *grep_info, const char *index_type)
Definition rpnsearch.c:1292
term_104
static int term_104(zebra_map_t zm, const char **src, WRBUF term_dict, int space_split, WRBUF display_term)
Definition rpnsearch.c:502
rpn_search_APT_or_list
static ZEBRA_RES rpn_search_APT_or_list(ZebraHandle zh, Z_AttributesPlusTerm *zapt, const char *termz_org, const Odr_oid *attributeSet, zint hits_limit, NMEM stream, const char *index_type, int complete_flag, const char *rank_type, const char *xpath_use, NMEM rset_nmem, RSET *rset, struct rset_key_control *kc)
returns result set for or-list search
Definition rpnsearch.c:1595
numeric_relation
static int numeric_relation(ZebraHandle zh, Z_AttributesPlusTerm *zapt, const char **term_sub, WRBUF term_dict, const Odr_oid *attributeSet, struct grep_info *grep_info, int *max_pos, zebra_map_t zm, WRBUF display_term, int *error_code)
Definition rpnsearch.c:1731
string_relation
static int string_relation(ZebraHandle zh, Z_AttributesPlusTerm *zapt, const char **term_sub, WRBUF term_dict, const Odr_oid *attributeSet, zebra_map_t zm, int space_split, WRBUF display_term, int *error_code)
Definition rpnsearch.c:745
add_non_space
static void add_non_space(const char *start, const char *end, WRBUF term_dict, WRBUF display_term, const char **map, int q_map_match)
Definition rpnsearch.c:208
xpath_trunc
static RSET xpath_trunc(ZebraHandle zh, NMEM stream, const char *index_type, const char *term, const char *xpath_use, NMEM rset_nmem, struct rset_key_control *kc)
Definition rpnsearch.c:2111
term_pre
static int term_pre(zebra_map_t zm, const char **src, const char *ct1, int first)
Definition rpnsearch.c:158
rpn_sort_spec
static ZEBRA_RES rpn_sort_spec(ZebraHandle zh, Z_AttributesPlusTerm *zapt, const Odr_oid *attributeSet, NMEM stream, Z_SortKeySpecList *sort_sequence, const char *rank_type, NMEM rset_nmem, RSET *rset, struct rset_key_control *kc)
Definition rpnsearch.c:2021
search_terms_list
static ZEBRA_RES search_terms_list(ZebraHandle zh, Z_AttributesPlusTerm *zapt, const char *termz, const Odr_oid *attributeSet, zint hits_limit, NMEM stream, const char *index_type, int complete_flag, const char *rank_type, const char *xpath_use, NMEM rset_nmem, RSET **result_sets, int *num_result_sets, struct rset_key_control *kc)
Create result set(s) for list of terms.
Definition rpnsearch.c:1412
term_101
static int term_101(zebra_map_t zm, const char **src, WRBUF term_dict, int space_split, WRBUF display_term)
Definition rpnsearch.c:411
rpn_char_map_prepare
void rpn_char_map_prepare(struct zebra_register *reg, zebra_map_t zm, struct rpn_char_map_info *map_info)
Definition rpnsearch.c:63
term_102_icu
static int term_102_icu(zebra_map_t zm, const char **src, WRBUF term_dict, int space_split, WRBUF display_term)
Definition rpnsearch.c:250
icu_basechars
static size_t icu_basechars(const char *buf, size_t i)
Definition rpnsearch.c:241
search_term
static ZEBRA_RES search_term(ZebraHandle zh, Z_AttributesPlusTerm *zapt, const char **term_sub, const Odr_oid *attributeSet, zint hits_limit, NMEM stream, struct grep_info *grep_info, const char *index_type, int complete_flag, const char *rank_type, const char *xpath_use, NMEM rset_nmem, RSET *rset, struct rset_key_control *kc, zebra_map_t zm, size_t token_number)
search for term (which may be truncated)
Definition rpnsearch.c:976
term_103
static int term_103(zebra_map_t zm, const char **src, WRBUF term_dict, int *errors, int space_split, WRBUF display_term)
Definition rpnsearch.c:448
term_102
static int term_102(zebra_map_t zm, const char **src, WRBUF term_dict, int space_split, WRBUF display_term)
Definition rpnsearch.c:494
rpn_search_database
static ZEBRA_RES rpn_search_database(ZebraHandle zh, Z_AttributesPlusTerm *zapt, const Odr_oid *attributeSet, zint hits_limit, NMEM stream, Z_SortKeySpecList *sort_sequence, NMEM rset_nmem, RSET *rset, struct rset_key_control *kc)
Definition rpnsearch.c:2360
grep_handle
static int grep_handle(char *name, const char *info, void *p)
Definition rpnsearch.c:153
term_105
static int term_105(zebra_map_t zm, const char **src, WRBUF term_dict, int space_split, WRBUF display_term, int right_truncate)
Definition rpnsearch.c:571
numeric_term
static ZEBRA_RES numeric_term(ZebraHandle zh, Z_AttributesPlusTerm *zapt, const char **term_sub, WRBUF term_dict, const Odr_oid *attributeSet, NMEM stream, struct grep_info *grep_info, const char *index_type, int complete_flag, WRBUF display_term, const char *xpath_use, struct ord_list **ol)
Definition rpnsearch.c:1829
gen_regular_rel
static void gen_regular_rel(WRBUF dst, int val, int islt)
Definition rpnsearch.c:628
REGEX_CHARS
#define REGEX_CHARS
Definition rpnsearch.c:206
string_term
static ZEBRA_RES string_term(ZebraHandle zh, Z_AttributesPlusTerm *zapt, const char **term_sub, WRBUF term_dict, const Odr_oid *attributeSet, NMEM stream, struct grep_info *grep_info, const char *index_type, int complete_flag, WRBUF display_term, const char *xpath_use, struct ord_list **ol, zebra_map_t zm, size_t token_number)
Definition rpnsearch.c:1023
add_isam_p
static int add_isam_p(const char *name, const char *info, struct grep_info *p)
Definition rpnsearch.c:88
term_100_icu
static int term_100_icu(zebra_map_t zm, const char **src, WRBUF term_dict, WRBUF display_term, int mode, size_t token_number)
Definition rpnsearch.c:312
rpn_search_xpath
static ZEBRA_RES rpn_search_xpath(ZebraHandle zh, NMEM stream, const char *rank_type, RSET rset, int xpath_len, struct xpath_location_step *xpath, NMEM rset_nmem, RSET *rset_out, struct rset_key_control *kc)
Definition rpnsearch.c:2162
string_rel_add_char
void string_rel_add_char(WRBUF term_p, WRBUF wsrc, int *indx)
Definition rpnsearch.c:723
rpn_search_APT_local
static ZEBRA_RES rpn_search_APT_local(ZebraHandle zh, Z_AttributesPlusTerm *zapt, const char *termz, const Odr_oid *attributeSet, NMEM stream, const char *rank_type, NMEM rset_nmem, RSET *rset, struct rset_key_control *kc)
Definition rpnsearch.c:1980
rpn_search_structure
static ZEBRA_RES rpn_search_structure(ZebraHandle zh, Z_RPNStructure *zs, const Odr_oid *attributeSet, zint hits_limit, NMEM stream, NMEM rset_nmem, Z_SortKeySpecList *sort_sequence, int num_bases, const char **basenames, RSET **result_sets, int *num_result_sets, Z_Operator *parent_op, struct rset_key_control *kc)
Definition rpnsearch.c:2567
rpn_search_APT_numeric
static ZEBRA_RES rpn_search_APT_numeric(ZebraHandle zh, Z_AttributesPlusTerm *zapt, const char *termz, const Odr_oid *attributeSet, zint hits_limit, NMEM stream, const char *index_type, int complete_flag, const char *rank_type, const char *xpath_use, NMEM rset_nmem, RSET *rset, struct rset_key_control *kc)
Definition rpnsearch.c:1891
zebra_term_limits_APT
ZEBRA_RES zebra_term_limits_APT(ZebraHandle zh, Z_AttributesPlusTerm *zapt, zint *hits_limit_value, const char **term_ref_id_str, NMEM nmem)
Definition rpnsearch.c:943
rpn_get_top_approx_limit
ZEBRA_RES rpn_get_top_approx_limit(ZebraHandle zh, Z_RPNStructure *zs, zint *approx_limit)
Definition rpnsearch.c:2498
rpn_search_APT_and_list
static ZEBRA_RES rpn_search_APT_and_list(ZebraHandle zh, Z_AttributesPlusTerm *zapt, const char *termz_org, const Odr_oid *attributeSet, zint hits_limit, NMEM stream, const char *index_type, int complete_flag, const char *rank_type, const char *xpath_use, NMEM rset_nmem, RSET *rset, struct rset_key_control *kc)
returns result set for and-list search
Definition rpnsearch.c:1663
rpn_check_xpath
static int rpn_check_xpath(ZebraHandle zh, Z_AttributesPlusTerm *zapt, const Odr_oid *attributeSet, struct xpath_location_step *xpath, int max, NMEM mem)
Definition rpnsearch.c:2091
term_100
static int term_100(zebra_map_t zm, const char **src, WRBUF term_dict, int space_split, WRBUF display_term)
Definition rpnsearch.c:355
rpn_search_top
ZEBRA_RES rpn_search_top(ZebraHandle zh, Z_RPNStructure *zs, const Odr_oid *attributeSet, zint hits_limit, NMEM stream, NMEM rset_nmem, Z_SortKeySpecList *sort_sequence, int num_bases, const char **basenames, RSET *result_set)
Definition rpnsearch.c:2529
log_level_rpn
static int log_level_rpn
Definition rpnsearch.c:42
rpn_search_APT_phrase
static ZEBRA_RES rpn_search_APT_phrase(ZebraHandle zh, Z_AttributesPlusTerm *zapt, const char *termz_org, const Odr_oid *attributeSet, zint hits_limit, NMEM stream, const char *index_type, int complete_flag, const char *rank_type, const char *xpath_use, NMEM rset_nmem, RSET *rset, struct rset_key_control *kc)
returns result set for phrase search
Definition rpnsearch.c:1529
search_position
static ZEBRA_RES search_position(ZebraHandle zh, Z_AttributesPlusTerm *zapt, const Odr_oid *attributeSet, const char *index_type, NMEM rset_nmem, RSET *rset, struct rset_key_control *kc)
limit a search by position - returns result set
Definition rpnsearch.c:1465
MAX_XPATH_STEPS
#define MAX_XPATH_STEPS
Definition rpnsearch.c:2302
search_terms_chrmap
static ZEBRA_RES search_terms_chrmap(ZebraHandle zh, Z_AttributesPlusTerm *zapt, const char *termz, const Odr_oid *attributeSet, zint hits_limit, NMEM stream, const char *index_type, int complete_flag, const char *rank_type, const char *xpath_use, NMEM rset_nmem, RSET **result_sets, int *num_result_sets, struct rset_key_control *kc, zebra_map_t zm)
Definition rpnsearch.c:1334
rpn_char_map_handler
static const char ** rpn_char_map_handler(void *vp, const char **from, int len)
Definition rpnsearch.c:44
log_level_set
static int log_level_set
Definition rpnsearch.c:41
search_group
static RSET search_group(ZebraHandle zh, const char *unit, const char *term, NMEM rset_nmem, struct rset_key_control *kc)
Definition rpnsearch.c:1433
rpn_search_APT
static ZEBRA_RES rpn_search_APT(ZebraHandle zh, Z_AttributesPlusTerm *zapt, const Odr_oid *attributeSet, zint hits_limit, NMEM stream, Z_SortKeySpecList *sort_sequence, int num_bases, const char **basenames, NMEM rset_nmem, RSET *rset, struct rset_key_control *kc)
Definition rpnsearch.c:2313
rset_delete
void rset_delete(RSET rs)
Destructor RSETs.
Definition rset.c:218
rset_create_or
RSET rset_create_or(NMEM nmem, struct rset_key_control *kcontrol, int scope, TERMID termid, int no_rsets, RSET *rsets)
Definition rsmultiandor.c:273
rset_create_and
RSET rset_create_and(NMEM nmem, struct rset_key_control *kcontrol, int scope, int no_rsets, RSET *rsets)
Definition rsmultiandor.c:280
rset_dup
RSET rset_dup(RSET rs)
Duplicate an RSET.
Definition rset.c:255
rset_create_not
RSET rset_create_not(NMEM nmem, struct rset_key_control *kcontrol, int scope, RSET rset_l, RSET rset_r)
Definition rsbool.c:92
RSETF_WRITE
#define RSETF_WRITE
Definition rset.h:200
ord_list_create
struct ord_list * ord_list_create(NMEM nmem)
Definition rset.c:301
rset_create_between
RSET rset_create_between(NMEM nmem, struct rset_key_control *kcontrol, int scope, RSET rset_l, RSET rset_m1, RSET rset_m2, RSET rset_r, RSET rset_attr)
Definition rsbetween.c:101
ord_list_append
struct ord_list * ord_list_append(NMEM nmem, struct ord_list *list, int ord)
Definition rset.c:306
rset_create_null
RSET rset_create_null(NMEM nmem, struct rset_key_control *kcontrol, TERMID term)
Definition rsnull.c:47
rset_write
#define rset_write(rfd, buf)
Definition rset.h:220
rset_create_temp
RSET rset_create_temp(NMEM nmem, struct rset_key_control *kcontrol, int scope, const char *temp_path, TERMID term)
Definition rstemp.c:86
rset_open
#define rset_open(rs, wflag)
Definition rset.h:202
rset_close
void rset_close(RSFD rfd)
Closes a result set RFD handle.
Definition rset.c:98
rset_create_prox
RSET rset_create_prox(NMEM nmem, struct rset_key_control *kcontrol, int scope, int rset_no, RSET *rset, int ordered, int exclusion, int relation, int distance)
Definition rsprox.c:72
grep_info
Definition rpnsearch.c:75
grep_info::term_no
int * term_no
Definition rpnsearch.c:77
grep_info::isam_p_buf
ISAM_P * isam_p_buf
Definition rpnsearch.c:79
grep_info::isam_p_size
int isam_p_size
Definition rpnsearch.c:80
grep_info::termset
ZebraSet termset
Definition rpnsearch.c:85
grep_info::index_type
const char * index_type
Definition rpnsearch.c:84
grep_info::isam_p_indx
int isam_p_indx
Definition rpnsearch.c:81
grep_info::zh
ZebraHandle zh
Definition rpnsearch.c:83
grep_info::trunc_max
int trunc_max
Definition rpnsearch.c:82
it_key
Definition it_key.h:30
it_key::len
int len
Definition it_key.h:31
it_key::mem
zint mem[IT_KEY_LEVEL_MAX]
Definition it_key.h:32
ord_list
Definition rset.h:35
record_info
Definition recindex.h:31
rpn_char_map_info
Definition index.h:403
rpn_char_map_info::zm
zebra_map_t zm
Definition index.h:404
rset_key_control
Definition rset.h:126
rset_key_control::dec
void(* dec)(struct rset_key_control *kc)
Definition rset.h:138
rset_key_control::scope
int scope
Definition rset.h:129
rset
Definition rset.h:151
rsfd
Definition rset.h:73
xpath_location_step
Definition zebra_xpath.h:44
xpath_location_step::part
char * part
Definition zebra_xpath.h:45
xpath_location_step::predicate
struct xpath_predicate * predicate
Definition zebra_xpath.h:46
xpath_predicate::u
union xpath_predicate::@8 u
xpath_predicate::name
char * name
Definition zebra_xpath.h:31
xpath_predicate::relation
struct xpath_predicate::@8::@9 relation
xpath_predicate::value
char * value
Definition zebra_xpath.h:33
zebra_map
Definition zebramap.c:43
zebra_register
Definition index.h:126
zebra_register::zei
ZebraExplainInfo zei
Definition index.h:139
zebra_register::zebra_maps
zebra_maps_t zebra_maps
Definition index.h:143
zebra_register::records
Records records
Definition index.h:138
zebra_register::dict
Dict dict
Definition index.h:132
zebra_session
Definition index.h:171
zebra_session::reg
struct zebra_register * reg
Definition index.h:174
zebra_session::res
Res res
Definition index.h:192
zebra_set
Definition zsets.c:46
zint
long zint
Zebra integer.
Definition util.h:66
ZEBRA_FAIL
#define ZEBRA_FAIL
Definition util.h:81
ZINT_FORMAT
#define ZINT_FORMAT
Definition util.h:72
atozint
zint atozint(const char *src)
Definition zint.c:55
ZEBRA_OK
#define ZEBRA_OK
Definition util.h:82
ZEBRA_RES
short ZEBRA_RES
Common return type for Zebra API.
Definition util.h:80
zebra_xpath.h
zebra_parse_xpath_str
int zebra_parse_xpath_str(const char *xpath_string, struct xpath_location_step *xpath, int max, NMEM mem)
Definition xpath.c:162
XPATH_PREDICATE_RELATION
#define XPATH_PREDICATE_RELATION
Definition zebra_xpath.h:29
zebra_maps_input
const char ** zebra_maps_input(zebra_map_t zm, const char **from, int len, int first)
Definition zebramap.c:399
zebra_maps_is_first_in_field
int zebra_maps_is_first_in_field(zebra_map_t zm)
Definition zebramap.c:492
zebra_map_tokenize_next
int zebra_map_tokenize_next(zebra_map_t zm, const char **result_buf, size_t *result_len, const char **display_buf, size_t *display_len)
Definition zebramap.c:658
zebra_maps_attr
int zebra_maps_attr(zebra_maps_t zms, Z_AttributesPlusTerm *zapt, const char **reg_id, char **search_type, char *rank_type, int *complete_flag, int *sort_flag)
Definition zebramap.c:515
zebra_maps_is_icu
int zebra_maps_is_icu(zebra_map_t zm)
Definition zebramap.c:741
zebra_map_tokenize_start
int zebra_map_tokenize_start(zebra_map_t zm, const char *buf, size_t len)
Definition zebramap.c:702
zebra_maps_search
const char ** zebra_maps_search(zebra_map_t zm, const char **from, int len, int *q_map_match)
Definition zebramap.c:412
zebra_map_get_or_add
zebra_map_t zebra_map_get_or_add(zebra_maps_t zms, const char *id)
Definition zebramap.c:364
zebraExplain_curDatabase
int zebraExplain_curDatabase(ZebraExplainInfo zei, const char *database)
Definition zinfo.c:790
zebraExplain_lookup_attr_str
int zebraExplain_lookup_attr_str(ZebraExplainInfo zei, zinfo_index_category_t cat, const char *index_type, const char *str)
lookup ordinal from string index + index type
Definition zinfo.c:1353
zebraExplain_lookup_ord
int zebraExplain_lookup_ord(ZebraExplainInfo zei, int ord, const char **index_type, const char **db, const char **string_index)
Definition zinfo.c:1478
zinfo_index_category_t
zinfo_index_category_t
Definition zinfo.h:37
zinfo_index_category_index
@ zinfo_index_category_index
Definition zinfo.h:38
Generated by doxygen 1.9.8