index/zrpn.c

   1 /*
   2  * Copyright (C) 1995-1998, Index Data I/S
   3  * All rights reserved.
   4  * Sebastian Hammer, Adam Dickmeiss
   5  *
   6  * $Log: zrpn.c,v $
   7  * Revision 1.76  1998-04-02 14:35:29  adam
   8  * First version of Zebra that works with compiled ASN.1.
   9  *
  10  * Revision 1.75  1998/03/05 08:45:13  adam
  11  * New result set model and modular ranking system. Moved towards
  12  * descent server API. System information stored as "SGML" records.
  13  *
  14  * Revision 1.74  1998/02/10 12:03:06  adam
  15  * Implemented Sort.
  16  *
  17  * Revision 1.73  1998/01/29 13:40:11  adam
  18  * Better logging for scan service.
  19  *
  20  * Revision 1.72  1998/01/07 13:53:41  adam
  21  * Queries using simple ranked operands returns right number of hits.
  22  *
  23  * Revision 1.71  1997/12/18 10:54:24  adam
  24  * New method result set method rs_hits that returns the number of
  25  * hits in result-set (if known). The ranked result set returns real
  26  * number of hits but only when not combined with other operands.
  27  *
  28  * Revision 1.70  1997/10/31 12:34:43  adam
  29  * Changed a few log statements.
  30  *
  31  * Revision 1.69  1997/10/29 12:05:02  adam
  32  * Server produces diagnostic "Unsupported Attribute Set" when appropriate.
  33  *
  34  * Revision 1.68  1997/10/27 14:33:06  adam
  35  * Moved towards generic character mapping depending on "structure"
  36  * field in abstract syntax file. Fixed a few memory leaks. Fixed
  37  * bug with negative integers when doing searches with relational
  38  * operators.
  39  *
  40  * Revision 1.67  1997/09/29 09:06:10  adam
  41  * Removed one static var in order to make this module thread safe.
  42  *
  43  * Revision 1.66  1997/09/25 14:58:03  adam
  44  * Windows NT port.
  45  *
  46  * Revision 1.65  1997/09/22 12:39:06  adam
  47  * Added get_pos method for the ranked result sets.
  48  *
  49  * Revision 1.64  1997/09/18 08:59:20  adam
  50  * Extra generic handle for the character mapping routines.
  51  *
  52  * Revision 1.63  1997/09/17 12:19:18  adam
  53  * Zebra version corresponds to YAZ version 1.4.
  54  * Changed Zebra server so that it doesn't depend on global common_resource.
  55  *
  56  * Revision 1.62  1997/09/05 15:30:09  adam
  57  * Changed prototype for chr_map_input - added const.
  58  * Added support for C++, headers uses extern "C" for public definitions.
  59  *
  60  * Revision 1.61  1997/02/10 10:21:14  adam
  61  * Bug fix: in search terms character (^) wasn't observed.
  62  *
  63  * Revision 1.60  1997/01/31 11:10:34  adam
  64  * Bug fix: Leading and trailing white space weren't removed in scan tokens.
  65  *
  66  * Revision 1.59  1997/01/17 11:31:46  adam
  67  * Bug fix: complete phrase search didn't work.
  68  *
  69  * Revision 1.58  1996/12/23 15:30:45  adam
  70  * Work on truncation.
  71  * Bug fix: result sets weren't deleted after server shut down.
  72  *
  73  * Revision 1.57  1996/11/11 13:38:02  adam
  74  * Added proximity support in search.
  75  *
  76  * Revision 1.56  1996/11/08 11:10:32  adam
  77  * Buffers used during file match got bigger.
  78  * Compressed ISAM support everywhere.
  79  * Bug fixes regarding masking characters in queries.
  80  * Redesigned Regexp-2 queries.
  81  *
  82  * Revision 1.55  1996/11/04 14:07:44  adam
  83  * Moved truncation code to trunc.c.
  84  *
  85  * Revision 1.54  1996/10/29 14:09:52  adam
  86  * Use of cisam system - enabled if setting isamc is 1.
  87  *
  88  * Revision 1.53  1996/06/26 09:21:43  adam
  89  * Bug fix: local attribute set wasn't obeyed in scan.
  90  *
  91  * Revision 1.52  1996/06/17  14:26:20  adam
  92  * Function gen_regular_rel changed to handle negative numbers.
  93  *
  94  * Revision 1.51  1996/06/11 10:54:15  quinn
  95  * Relevance work
  96  *
  97  * Revision 1.50  1996/06/07  08:51:53  adam
  98  * Bug fix: Character mapping was broken (introducued by last revision).
  99  *
 100  * Revision 1.49  1996/06/04  10:18:11  adam
 101  * Search/scan uses character mapping module.
 102  *
 103  * Revision 1.48  1996/05/28  15:15:01  adam
 104  * Bug fix: Didn't handle unknown database correctly.
 105  *
 106  * Revision 1.47  1996/05/15  18:36:28  adam
 107  * Function trans_term transforms unsearchable characters to blanks.
 108  *
 109  * Revision 1.46  1996/05/15  11:57:56  adam
 110  * Fixed bug introduced by set/field mapping in search operations.
 111  *
 112  * Revision 1.45  1996/05/14  11:34:00  adam
 113  * Scan support in multiple registers/databases.
 114  *
 115  * Revision 1.44  1996/05/14  06:16:44  adam
 116  * Compact use/set bytes used in search service.
 117  *
 118  * Revision 1.43  1996/05/09 09:54:43  adam
 119  * Server supports maps from one logical attributes to a list of physical
 120  * attributes.
 121  * The extraction process doesn't make space consuming 'any' keys.
 122  *
 123  * Revision 1.42  1996/05/09  07:28:56  quinn
 124  * Work towards phrases and multiple registers
 125  *
 126  * Revision 1.41  1996/03/20  09:36:43  adam
 127  * Function dict_lookup_grep got extra parameter, init_pos, which marks
 128  * from which position in pattern approximate pattern matching should occur.
 129  * Approximate pattern matching is used in relevance=re-2.
 130  *
 131  * Revision 1.40  1996/02/02  13:44:44  adam
 132  * The public dictionary functions simply use char instead of Dict_char
 133  * to represent search strings. Dict_char is used internally only.
 134  *
 135  * Revision 1.39  1996/01/03  16:22:13  quinn
 136  * operator->roperator
 137  *
 138  * Revision 1.38  1995/12/11  09:12:55  adam
 139  * The rec_get function returns NULL if record doesn't exist - will
 140  * happen in the server if the result set records have been deleted since
 141  * the creation of the set (i.e. the search).
 142  * The server saves a result temporarily if it is 'volatile', i.e. the
 143  * set is register dependent.
 144  *
 145  * Revision 1.37  1995/12/06  15:05:28  adam
 146  * More verbose in count_set.
 147  *
 148  * Revision 1.36  1995/12/06  12:41:27  adam
 149  * New command 'stat' for the index program.
 150  * Filenames can be read from stdin by specifying '-'.
 151  * Bug fix/enhancement of the transformation from terms to regular
 152  * expressons in the search engine.
 153  *
 154  * Revision 1.35  1995/11/27  09:29:00  adam
 155  * Bug fixes regarding conversion to regular expressions.
 156  *
 157  * Revision 1.34  1995/11/16  17:00:56  adam
 158  * Better logging of rpn query.
 159  *
 160  * Revision 1.33  1995/11/01  13:58:28  quinn
 161  * Moving data1 to yaz/retrieval
 162  *
 163  * Revision 1.32  1995/10/27  14:00:11  adam
 164  * Implemented detection of database availability.
 165  *
 166  * Revision 1.31  1995/10/17  18:02:10  adam
 167  * New feature: databases. Implemented as prefix to words in dictionary.
 168  *
 169  * Revision 1.30  1995/10/16  09:32:38  adam
 170  * More work on relational op.
 171  *
 172  * Revision 1.29  1995/10/13  16:01:49  adam
 173  * Work on relations.
 174  *
 175  * Revision 1.28  1995/10/13  12:26:43  adam
 176  * Optimization of truncation.
 177  *
 178  * Revision 1.27  1995/10/12  17:07:22  adam
 179  * Truncation works.
 180  *
 181  * Revision 1.26  1995/10/12  12:40:54  adam
 182  * Bug fixes in rpn_prox.
 183  *
 184  * Revision 1.25  1995/10/10  13:59:24  adam
 185  * Function rset_open changed its wflag parameter to general flags.
 186  *
 187  * Revision 1.24  1995/10/09  16:18:37  adam
 188  * Function dict_lookup_grep got extra client data parameter.
 189  *
 190  * Revision 1.23  1995/10/06  16:33:37  adam
 191  * Use attribute mappings.
 192  *
 193  * Revision 1.22  1995/10/06  15:07:39  adam
 194  * Structure 'local-number' handled.
 195  *
 196  * Revision 1.21  1995/10/06  13:52:06  adam
 197  * Bug fixes. Handler may abort further scanning.
 198  *
 199  * Revision 1.20  1995/10/06  11:06:33  adam
 200  * Scan entries include 'occurrences' now.
 201  *
 202  * Revision 1.19  1995/10/06  10:43:56  adam
 203  * Scan added. 'occurrences' in scan entries not set yet.
 204  *
 205  * Revision 1.18  1995/10/04  16:57:20  adam
 206  * Key input and merge sort in one pass.
 207  *
 208  * Revision 1.17  1995/10/04  12:55:17  adam
 209  * Bug fix in ranked search. Use=Any keys inserted.
 210  *
 211  * Revision 1.16  1995/10/02  16:24:40  adam
 212  * Use attribute actually used in search requests.
 213  *
 214  * Revision 1.15  1995/10/02  15:18:52  adam
 215  * New member in recRetrieveCtrl: diagnostic.
 216  *
 217  * Revision 1.14  1995/09/28  12:10:32  adam
 218  * Bug fixes. Field prefix used in queries.
 219  *
 220  * Revision 1.13  1995/09/18  14:17:50  adam
 221  * Minor changes.
 222  *
 223  * Revision 1.12  1995/09/15  14:45:21  adam
 224  * Retrieve control.
 225  * Work on truncation.
 226  *
 227  * Revision 1.11  1995/09/14  11:53:27  adam
 228  * First work on regular expressions/truncations.
 229  *
 230  * Revision 1.10  1995/09/11  15:23:26  adam
 231  * More work on relevance search.
 232  *
 233  * Revision 1.9  1995/09/11  13:09:35  adam
 234  * More work on relevance feedback.
 235  *
 236  * Revision 1.8  1995/09/08  14:52:27  adam
 237  * Minor changes. Dictionary is lower case now.
 238  *
 239  * Revision 1.7  1995/09/07  13:58:36  adam
 240  * New parameter: result-set file descriptor (RSFD) to support multiple
 241  * positions within the same result-set.
 242  * Boolean operators: and, or, not implemented.
 243  * Result-set references.
 244  *
 245  * Revision 1.6  1995/09/06  16:11:18  adam
 246  * Option: only one word key per file.
 247  *
 248  * Revision 1.5  1995/09/06  10:33:04  adam
 249  * More work on present. Some log messages removed.
 250  *
 251  * Revision 1.4  1995/09/05  15:28:40  adam
 252  * More work on search engine.
 253  *
 254  * Revision 1.3  1995/09/04  15:20:22  adam
 255  * Minor changes.
 256  *
 257  * Revision 1.2  1995/09/04  12:33:43  adam
 258  * Various cleanup. YAZ util used instead.
 259  *
 260  * Revision 1.1  1995/09/04  09:10:40  adam
 261  * More work on index add/del/update.
 262  * Merge sort implemented.
 263  * Initial work on z39 server.
 264  *
 265  */
 266 #include <stdio.h>
 267 #include <assert.h>
 268 #ifdef WINDOWS
 269 #include <io.h>
 270 #else
 271 #include <unistd.h>
 272 #endif
 273 #include <ctype.h>
 274
 275 #include "zserver.h"
 276
 277 #include <charmap.h>
 278 #include <rstemp.h>
 279 #include <rsnull.h>
 280 #include <rsbool.h>
 281
 282 struct rpn_char_map_info {
 283     ZebraMaps zm;
 284     int reg_type;
 285 };
 286
 287 static const char **rpn_char_map_handler (void *vp, const char **from, int len)
 288 {
 289     struct rpn_char_map_info *p = vp;
 290     return zebra_maps_input (p->zm, p->reg_type, from, len);
 291 }
 292
 293 static void rpn_char_map_prepare (ZebraHandle zh, int reg_type,
 294                                   struct rpn_char_map_info *map_info)
 295 {
 296     map_info->zm = zh->zebra_maps;
 297     map_info->reg_type = reg_type;
 298     dict_grep_cmap (zh->dict, map_info, rpn_char_map_handler);
 299 }
 300
 301 typedef struct {
 302     int type;
 303     int major;
 304     int minor;
 305     Z_AttributesPlusTerm *zapt;
 306 } AttrType;
 307
 308 static int attr_find (AttrType *src, oid_value *attributeSetP)
 309 {
 310     int num_attributes;
 311
 312 #ifdef ASN_COMPILED
 313     num_attributes = src->zapt->attributes->num_attributes;
 314 #else
 315     num_attributes = src->zapt->num_attributes;
 316 #endif
 317     while (src->major < num_attributes)
 318     {
 319         Z_AttributeElement *element;
 320
 321 #ifdef ASN_COMPILED
 322         element = src->zapt->attributes->attributes[src->major];
 323 #else
 324         element = src->zapt->attributeList[src->major];
 325 #endif
 326         if (src->type == *element->attributeType)
 327         {
 328             switch (element->which)
 329             {
 330             case Z_AttributeValue_numeric:
 331                 ++(src->major);
 332                 if (element->attributeSet && attributeSetP)
 333                 {
 334                     oident *attrset;
 335
 336                     attrset = oid_getentbyoid (element->attributeSet);
 337                     *attributeSetP = attrset->value;
 338                 }
 339                 return *element->value.numeric;
 340                 break;
 341             case Z_AttributeValue_complex:
 342                 if (src->minor >= element->value.complex->num_list ||
 343                     element->value.complex->list[src->minor]->which !=
 344                     Z_StringOrNumeric_numeric)
 345                     break;
 346                 ++(src->minor);
 347                 if (element->attributeSet && attributeSetP)
 348                 {
 349                     oident *attrset;
 350
 351                     attrset = oid_getentbyoid (element->attributeSet);
 352                     *attributeSetP = attrset->value;
 353                 }
 354                 return *element->value.complex->list[src->minor-1]->u.numeric;
 355             default:
 356                 assert (0);
 357             }
 358         }
 359         ++(src->major);
 360     }
 361     return -1;
 362 }
 363
 364 static void attr_init (AttrType *src, Z_AttributesPlusTerm *zapt,
 365                        int type)
 366 {
 367     src->zapt = zapt;
 368     src->type = type;
 369     src->major = 0;
 370     src->minor = 0;
 371 }
 372
 373 #define TERM_COUNT
 374
 375 struct grep_info {
 376 #ifdef TERM_COUNT
 377     int *term_no;
 378 #endif
 379     ISAM_P *isam_p_buf;
 380     int isam_p_size;
 381     int isam_p_indx;
 382     ZebraHandle zh;
 383     int reg_type;
 384 };
 385
 386 static void term_untrans  (ZebraHandle zh, int reg_type,
 387                            char *dst, const char *src)
 388 {
 389     while (*src)
 390     {
 391         const char *cp = zebra_maps_output (zh->zebra_maps, reg_type, &src);
 392         while (*cp)
 393             *dst++ = *cp++;
 394     }
 395     *dst = '\0';
 396 }
 397
 398 static void add_isam_p (const char *name, const char *info,
 399                         struct grep_info *p)
 400 {
 401     char term_tmp[1024];
 402     if (p->isam_p_indx == p->isam_p_size)
 403     {
 404         ISAM_P *new_isam_p_buf;
 405 #ifdef TERM_COUNT
 406         int *new_term_no;
 407 #endif
 408         p->isam_p_size = 2*p->isam_p_size + 100;
 409         new_isam_p_buf = xmalloc (sizeof(*new_isam_p_buf) *
 410                                   p->isam_p_size);
 411         if (p->isam_p_buf)
 412         {
 413             memcpy (new_isam_p_buf, p->isam_p_buf,
 414                     p->isam_p_indx * sizeof(*p->isam_p_buf));
 415             xfree (p->isam_p_buf);
 416         }
 417         p->isam_p_buf = new_isam_p_buf;
 418
 419 #ifdef TERM_COUNT
 420         new_term_no = xmalloc (sizeof(*new_term_no) *
 421                                   p->isam_p_size);
 422         if (p->term_no)
 423         {
 424             memcpy (new_term_no, p->isam_p_buf,
 425                     p->isam_p_indx * sizeof(*p->term_no));
 426             xfree (p->term_no);
 427         }
 428         p->term_no = new_term_no;
 429 #endif
 430     }
 431     assert (*info == sizeof(*p->isam_p_buf));
 432     memcpy (p->isam_p_buf + p->isam_p_indx, info+1, sizeof(*p->isam_p_buf));
 433
 434     term_untrans  (p->zh, p->reg_type, term_tmp, name+2);
 435     logf (LOG_DEBUG, "grep: %s", term_tmp);
 436
 437     (p->isam_p_indx)++;
 438 }
 439
 440 static int grep_handle (char *name, const char *info, void *p)
 441 {
 442     add_isam_p (name, info, p);
 443     return 0;
 444 }
 445
 446 static int term_pre (ZebraMaps zebra_maps, int reg_type, const char **src,
 447                      const char *ct1, const char *ct2)
 448 {
 449     const char *s1, *s0 = *src;
 450     const char **map;
 451
 452     /* skip white space */
 453     while (*s0)
 454     {
 455         if (ct1 && strchr (ct1, *s0))
 456             break;
 457         if (ct2 && strchr (ct2, *s0))
 458             break;
 459         s1 = s0;
 460         map = zebra_maps_input (zebra_maps, reg_type, &s1, strlen(s1));
 461         if (**map != *CHR_SPACE)
 462             break;
 463         s0 = s1;
 464     }
 465     *src = s0;
 466     return *s0;
 467 }
 468
 469 static int term_100 (ZebraMaps zebra_maps, int reg_type,
 470                      const char **src, char *dst, int space_split,
 471                      char *dst_term)
 472 {
 473     const char *s0, *s1;
 474     const char **map;
 475     int i = 0;
 476     int j = 0;
 477
 478     if (!term_pre (zebra_maps, reg_type, src, NULL, NULL))
 479         return 0;
 480     s0 = *src;
 481     while (*s0)
 482     {
 483         s1 = s0;
 484         map = zebra_maps_input (zebra_maps, reg_type, &s0, strlen(s0));
 485         if (space_split && **map == *CHR_SPACE)
 486             break;
 487         while (s1 < s0)
 488         {
 489             if (!isalnum (*s1) && *s1 != '-')
 490                 dst[i++] = '\\';
 491             dst_term[j++] = *s1;
 492             dst[i++] = *s1++;
 493         }
 494     }
 495     dst[i] = '\0';
 496     dst_term[j] = '\0';
 497     *src = s0;
 498     return i;
 499 }
 500
 501 static int term_101 (ZebraMaps zebra_maps, int reg_type,
 502                      const char **src, char *dst, int space_split,
 503                      char *dst_term)
 504 {
 505     const char *s0, *s1;
 506     const char **map;
 507     int i = 0;
 508     int j = 0;
 509
 510     if (!term_pre (zebra_maps, reg_type, src, "#", "#"))
 511         return 0;
 512     s0 = *src;
 513     while (*s0)
 514     {
 515         if (*s0 == '#')
 516         {
 517             dst[i++] = '.';
 518             dst[i++] = '*';
 519             dst_term[j++] = *s0++;
 520         }
 521         else
 522         {
 523             s1 = s0;
 524             map = zebra_maps_input (zebra_maps, reg_type, &s0, strlen(s0));
 525             if (space_split && **map == *CHR_SPACE)
 526                 break;
 527             while (s1 < s0)
 528             {
 529                 if (!isalnum (*s1))
 530                     dst[i++] = '\\';
 531                 dst_term[j++] = *s1;
 532                 dst[i++] = *s1++;
 533             }
 534         }
 535     }
 536     dst[i] = '\0';
 537     dst_term[j++] = '\0';
 538     *src = s0;
 539     return i;
 540 }
 541
 542
 543 static int term_103 (ZebraMaps zebra_maps, int reg_type, const char **src,
 544                      char *dst, int *errors, int space_split,
 545                      char *dst_term)
 546 {
 547     int i = 0;
 548     int j = 0;
 549     const char *s0, *s1;
 550     const char **map;
 551
 552     if (!term_pre (zebra_maps, reg_type, src, "^\\()[].*+?|", "("))
 553         return 0;
 554     s0 = *src;
 555     if (errors && *s0 == '+' && s0[1] && s0[2] == '+' && s0[3] &&
 556         isdigit (s0[1]))
 557     {
 558         *errors = s0[1] - '0';
 559         s0 += 3;
 560         if (*errors > 3)
 561             *errors = 3;
 562     }
 563     while (*s0)
 564     {
 565         if (strchr ("^\\()[].*+?|-", *s0))
 566         {
 567             dst_term[j++] = *s0;
 568             dst[i++] = *s0++;
 569         }
 570         else
 571         {
 572             s1 = s0;
 573             map = zebra_maps_input (zebra_maps, reg_type, &s0, strlen(s0));
 574             if (**map == *CHR_SPACE)
 575                 break;
 576             while (s1 < s0)
 577             {
 578                 if (!isalnum (*s1))
 579                     dst[i++] = '\\';
 580                 dst_term[j++] = *s1;
 581                 dst[i++] = *s1++;
 582             }
 583         }
 584     }
 585     dst[i] = '\0';
 586     dst_term[j] = '\0';
 587     *src = s0;
 588     return i;
 589 }
 590
 591 static int term_102 (ZebraMaps zebra_maps, int reg_type, const char **src,
 592                      char *dst, int space_split, char *dst_term)
 593 {
 594     return term_103 (zebra_maps, reg_type, src, dst, NULL, space_split,
 595                      dst_term);
 596 }
 597
 598 /* gen_regular_rel - generate regular expression from relation
 599  *  val:     border value (inclusive)
 600  *  islt:    1 if <=; 0 if >=.
 601  */
 602 static void gen_regular_rel (char *dst, int val, int islt)
 603 {
 604     int dst_p;
 605     int w, d, i;
 606     int pos = 0;
 607     char numstr[20];
 608
 609     logf (LOG_DEBUG, "gen_regular_rel. val=%d, islt=%d", val, islt);
 610     if (val >= 0)
 611     {
 612         if (islt)
 613             strcpy (dst, "(-[0-9]+|(");
 614         else
 615             strcpy (dst, "((");
 616     }
 617     else
 618     {
 619         if (!islt)
 620         {
 621             strcpy (dst, "([0-9]+|-(");
 622             dst_p = strlen (dst);
 623             islt = 1;
 624         }
 625         else
 626         {
 627             strcpy (dst, "((-");
 628             islt = 0;
 629         }
 630         val = -val;
 631     }
 632     dst_p = strlen (dst);
 633     sprintf (numstr, "%d", val);
 634     for (w = strlen(numstr); --w >= 0; pos++)
 635     {
 636         d = numstr[w];
 637         if (pos > 0)
 638         {
 639             if (islt)
 640             {
 641                 if (d == '0')
 642                     continue;
 643                 d--;
 644             }
 645             else
 646             {
 647                 if (d == '9')
 648                     continue;
 649                 d++;
 650             }
 651         }
 652
 653         strcpy (dst + dst_p, numstr);
 654         dst_p = strlen(dst) - pos - 1;
 655
 656         if (islt)
 657         {
 658             if (d != '0')
 659             {
 660                 dst[dst_p++] = '[';
 661                 dst[dst_p++] = '0';
 662                 dst[dst_p++] = '-';
 663                 dst[dst_p++] = d;
 664                 dst[dst_p++] = ']';
 665             }
 666             else
 667                 dst[dst_p++] = d;
 668         }
 669         else
 670         {
 671             if (d != '9')
 672             {
 673                 dst[dst_p++] = '[';
 674                 dst[dst_p++] = d;
 675                 dst[dst_p++] = '-';
 676                 dst[dst_p++] = '9';
 677                 dst[dst_p++] = ']';
 678             }
 679             else
 680                 dst[dst_p++] = d;
 681         }
 682         for (i = 0; i<pos; i++)
 683         {
 684             dst[dst_p++] = '[';
 685             dst[dst_p++] = '0';
 686             dst[dst_p++] = '-';
 687             dst[dst_p++] = '9';
 688             dst[dst_p++] = ']';
 689         }
 690         dst[dst_p++] = '|';
 691     }
 692     dst[dst_p] = '\0';
 693     if (islt)
 694     {
 695         for (i=1; i<pos; i++)
 696             strcat (dst, "[0-9]?");
 697     }
 698     else
 699     {
 700         for (i = 0; i <= pos; i++)
 701             strcat (dst, "[0-9]");
 702         strcat (dst, "[0-9]*");
 703     }
 704     strcat (dst, "))");
 705 }
 706
 707 static int relational_term (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
 708                             const char **term_sub,
 709                             char *term_dict,
 710                             oid_value attributeSet,
 711                             struct grep_info *grep_info,
 712                             int *max_pos,
 713                             int reg_type,
 714                             char *term_dst)
 715 {
 716     AttrType relation;
 717     int relation_value;
 718     int term_value;
 719     int r;
 720     char *term_tmp = term_dict + strlen(term_dict);
 721
 722     attr_init (&relation, zapt, 2);
 723     relation_value = attr_find (&relation, NULL);
 724
 725     logf (LOG_DEBUG, "relation value=%d", relation_value);
 726     switch (relation_value)
 727     {
 728     case 1:
 729         if (!term_100 (zh->zebra_maps, reg_type, term_sub, term_tmp, 1,
 730                        term_dst))
 731             return 0;
 732         term_value = atoi (term_tmp);
 733         logf (LOG_DEBUG, "Relation <");
 734         gen_regular_rel (term_tmp, term_value-1, 1);
 735         break;
 736     case 2:
 737         if (!term_100 (zh->zebra_maps, reg_type, term_sub, term_tmp, 1,
 738                        term_dst))
 739             return 0;
 740         term_value = atoi (term_tmp);
 741         logf (LOG_DEBUG, "Relation <=");
 742         gen_regular_rel (term_tmp, term_value, 1);
 743         break;
 744     case 4:
 745         if (!term_100 (zh->zebra_maps, reg_type, term_sub, term_tmp, 1,
 746                        term_dst))
 747             return 0;
 748         term_value = atoi (term_tmp);
 749         logf (LOG_DEBUG, "Relation >=");
 750         gen_regular_rel (term_tmp, term_value, 0);
 751         break;
 752     case 5:
 753         if (!term_100 (zh->zebra_maps, reg_type, term_sub, term_tmp, 1,
 754                        term_dst))
 755             return 0;
 756         term_value = atoi (term_tmp);
 757         logf (LOG_DEBUG, "Relation >");
 758         gen_regular_rel (term_tmp, term_value+1, 0);
 759         break;
 760     default:
 761         return 0;
 762     }
 763     logf (LOG_DEBUG, "dict_lookup_grep: %s", term_tmp);
 764     r = dict_lookup_grep (zh->dict, term_dict, 0, grep_info, max_pos,
 765                           0, grep_handle);
 766     if (r)
 767         logf (LOG_WARN, "dict_lookup_grep fail, rel=gt: %d", r);
 768     logf (LOG_DEBUG, "%d positions", grep_info->isam_p_indx);
 769     return 1;
 770 }
 771
 772 static int field_term (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
 773                        const char **term_sub,
 774                        oid_value attributeSet, struct grep_info *grep_info,
 775                        int reg_type, int complete_flag,
 776                        int num_bases, char **basenames,
 777                        char *term_dst)
 778 {
 779     char term_dict[2*IT_MAX_WORD+2];
 780     int j, r, base_no;
 781     AttrType truncation;
 782     int truncation_value;
 783     AttrType use;
 784     int use_value;
 785     oid_value curAttributeSet = attributeSet;
 786     const char *termp;
 787     struct rpn_char_map_info rcmi;
 788     int space_split = complete_flag ? 0 : 1;
 789
 790     rpn_char_map_prepare (zh, reg_type, &rcmi);
 791     attr_init (&use, zapt, 1);
 792     use_value = attr_find (&use, &curAttributeSet);
 793     logf (LOG_DEBUG, "field_term, use value %d", use_value);
 794     attr_init (&truncation, zapt, 5);
 795     truncation_value = attr_find (&truncation, NULL);
 796     logf (LOG_DEBUG, "truncation value %d", truncation_value);
 797
 798     if (use_value == -1)
 799         use_value = 1016;
 800
 801     for (base_no = 0; base_no < num_bases; base_no++)
 802     {
 803         attent attp;
 804         data1_local_attribute *local_attr;
 805         int max_pos, prefix_len = 0;
 806
 807         termp = *term_sub;
 808         if ((r=att_getentbyatt (zh, &attp, curAttributeSet, use_value)))
 809         {
 810             logf (LOG_DEBUG, "att_getentbyatt fail. set=%d use=%d r=%d",
 811                   curAttributeSet, use_value, r);
 812             if (r == -1)
 813                 zh->errCode = 114;
 814             else
 815                 zh->errCode = 121;
 816             return -1;
 817         }
 818         if (zebraExplain_curDatabase (zh->zei, basenames[base_no]))
 819         {
 820             zh->errCode = 109; /* Database unavailable */
 821             zh->errString = basenames[base_no];
 822             return -1;
 823         }
 824         for (local_attr = attp.local_attributes; local_attr;
 825              local_attr = local_attr->next)
 826         {
 827             int ord;
 828
 829             ord = zebraExplain_lookupSU (zh->zei, attp.attset_ordinal,
 830                                           local_attr->local);
 831             if (ord < 0)
 832                 continue;
 833             if (prefix_len)
 834                 term_dict[prefix_len++] = '|';
 835             else
 836                 term_dict[prefix_len++] = '(';
 837             term_dict[prefix_len++] = 1;
 838             term_dict[prefix_len++] = ord;
 839         }
 840         if (!prefix_len)
 841         {
 842             zh->errCode = 114;
 843             return -1;
 844         }
 845         term_dict[prefix_len++] = ')';
 846         term_dict[prefix_len++] = 1;
 847         term_dict[prefix_len++] = reg_type;
 848         logf (LOG_DEBUG, "reg_type = %d", term_dict[prefix_len-1]);
 849         term_dict[prefix_len] = '\0';
 850         if (!relational_term (zh, zapt, &termp, term_dict,
 851                               attributeSet, grep_info, &max_pos, reg_type,
 852                               term_dst))
 853         {
 854             j = prefix_len;
 855             switch (truncation_value)
 856             {
 857             case -1:         /* not specified */
 858             case 100:        /* do not truncate */
 859                 term_dict[j++] = '(';
 860                 if (!term_100 (zh->zebra_maps, reg_type,
 861                                &termp, term_dict + j, space_split, term_dst))
 862                     return 0;
 863                 strcat (term_dict, ")");
 864                 r = dict_lookup_grep (zh->dict, term_dict, 0, grep_info,
 865                                       &max_pos, 0, grep_handle);
 866                 if (r)
 867                     logf (LOG_WARN, "dict_lookup_grep err, trunc=none:%d", r);
 868                 break;
 869             case 1:          /* right truncation */
 870                 term_dict[j++] = '(';
 871                 if (!term_100 (zh->zebra_maps, reg_type,
 872                                &termp, term_dict + j, space_split, term_dst))
 873                     return 0;
 874                 strcat (term_dict, ".*)");
 875                 dict_lookup_grep (zh->dict, term_dict, 0, grep_info,
 876                                   &max_pos, 0, grep_handle);
 877                 break;
 878             case 2:          /* left truncation */
 879             case 3:          /* left&right truncation */
 880                 zh->errCode = 120;
 881                 return -1;
 882             case 101:        /* process # in term */
 883                 term_dict[j++] = '(';
 884                 if (!term_101 (zh->zebra_maps, reg_type,
 885                                &termp, term_dict + j, space_split, term_dst))
 886                     return 0;
 887                 strcat (term_dict, ")");
 888                 r = dict_lookup_grep (zh->dict, term_dict, 0, grep_info,
 889                                       &max_pos, 0, grep_handle);
 890                 if (r)
 891                     logf (LOG_WARN, "dict_lookup_grep err, trunc=#: %d", r);
 892                 break;
 893             case 102:        /* Regexp-1 */
 894                 term_dict[j++] = '(';
 895                 if (!term_102 (zh->zebra_maps, reg_type,
 896                                &termp, term_dict + j, space_split, term_dst))
 897                     return 0;
 898                 strcat (term_dict, ")");
 899                 logf (LOG_DEBUG, "Regexp-1 tolerance=%d", r);
 900                 r = dict_lookup_grep (zh->dict, term_dict, 0, grep_info,
 901                                       &max_pos, 0, grep_handle);
 902                 if (r)
 903                     logf (LOG_WARN, "dict_lookup_grep err, trunc=regular: %d",
 904                           r);
 905                 break;
 906              case 103:       /* Regexp-2 */
 907                 r = 1;
 908                 term_dict[j++] = '(';
 909                 if (!term_103 (zh->zebra_maps, reg_type,
 910                                &termp, term_dict + j, &r, space_split, term_dst))
 911                     return 0;
 912                 strcat (term_dict, ")");
 913                 logf (LOG_DEBUG, "Regexp-2 tolerance=%d", r);
 914                 r = dict_lookup_grep (zh->dict, term_dict, r, grep_info,
 915                                       &max_pos, 2, grep_handle);
 916                 if (r)
 917                     logf (LOG_WARN, "dict_lookup_grep err, trunc=eregular: %d",
 918                           r);
 919                 break;
 920             }
 921         }
 922     }
 923     *term_sub = termp;
 924     logf (LOG_DEBUG, "%d positions", grep_info->isam_p_indx);
 925     return 1;
 926 }
 927
 928 static void trans_term (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
 929                         char *termz)
 930 {
 931     size_t sizez;
 932     Z_Term *term = zapt->term;
 933
 934     sizez = term->u.general->len;
 935     if (sizez > IT_MAX_WORD-1)
 936         sizez = IT_MAX_WORD-1;
 937     memcpy (termz, term->u.general->buf, sizez);
 938     termz[sizez] = '\0';
 939 }
 940
 941 static void trans_scan_term (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
 942                              char *termz, int reg_type)
 943 {
 944     Z_Term *term = zapt->term;
 945     const char **map;
 946     const char *cp = (const char *) term->u.general->buf;
 947     const char *cp_end = cp + term->u.general->len;
 948     const char *src;
 949     int i = 0;
 950     const char *space_map = NULL;
 951     int len;
 952
 953     while ((len = (cp_end - cp)) > 0)
 954     {
 955         map = zebra_maps_input (zh->zebra_maps, reg_type, &cp, len);
 956         if (**map == *CHR_SPACE)
 957             space_map = *map;
 958         else
 959         {
 960             if (i && space_map)
 961                 for (src = space_map; *src; src++)
 962                     termz[i++] = *src;
 963             space_map = NULL;
 964             for (src = *map; *src; src++)
 965                 termz[i++] = *src;
 966         }
 967     }
 968     termz[i] = '\0';
 969 }
 970
 971 static RSET rpn_proximity (ZebraHandle zh, RSET rset1, RSET rset2,
 972                            int ordered,
 973                            int exclusion, int relation, int distance)
 974 {
 975     int i;
 976     RSFD rsfd1, rsfd2;
 977     int  more1, more2;
 978     struct it_key buf1, buf2;
 979     RSFD rsfd_result;
 980     RSET result;
 981     rset_temp_parms parms;
 982     int term_index;
 983
 984     rsfd1 = rset_open (rset1, RSETF_READ);
 985     more1 = rset_read (rset1, rsfd1, &buf1, &term_index);
 986
 987     rsfd2 = rset_open (rset2, RSETF_READ);
 988     more2 = rset_read (rset2, rsfd2, &buf2, &term_index);
 989
 990     parms.key_size = sizeof (struct it_key);
 991     parms.temp_path = res_get (zh->res, "setTmpDir");
 992     result = rset_create (rset_kind_temp, &parms);
 993     rsfd_result = rset_open (result, RSETF_WRITE);
 994
 995     logf (LOG_DEBUG, "rpn_proximity  excl=%d ord=%d rel=%d dis=%d",
 996           exclusion, ordered, relation, distance);
 997     while (more1 && more2)
 998     {
 999         int cmp = key_compare_it (&buf1, &buf2);
1000         if (cmp < -1)
1001             more1 = rset_read (rset1, rsfd1, &buf1, &term_index);
1002         else if (cmp > 1)
1003             more2 = rset_read (rset2, rsfd2, &buf2, &term_index);
1004         else
1005         {
1006             int sysno = buf1.sysno;
1007             int seqno[500];
1008             int n = 0;
1009
1010             seqno[n++] = buf1.seqno;
1011             while ((more1 = rset_read (rset1, rsfd1, &buf1, &term_index)) &&
1012                    sysno == buf1.sysno)
1013                 if (n < 500)
1014                     seqno[n++] = buf1.seqno;
1015             do
1016             {
1017                 for (i = 0; i<n; i++)
1018                 {
1019                     int diff = buf2.seqno - seqno[i];
1020                     int excl = exclusion;
1021                     if (!ordered && diff < 0)
1022                         diff = -diff;
1023                     switch (relation)
1024                     {
1025                     case 1:      /* < */
1026                         if (diff < distance)
1027                             excl = !excl;
1028                         break;
1029                     case 2:      /* <= */
1030                         if (diff <= distance)
1031                             excl = !excl;
1032                         break;
1033                     case 3:      /* == */
1034                         if (diff == distance)
1035                             excl = !excl;
1036                         break;
1037                     case 4:      /* >= */
1038                         if (diff >= distance)
1039                             excl = !excl;
1040                         break;
1041                     case 5:      /* > */
1042                         if (diff > distance)
1043                             excl = !excl;
1044                         break;
1045                     case 6:      /* != */
1046                         if (diff != distance)
1047                             excl = !excl;
1048                         break;
1049                     }
1050                     if (excl)
1051                         rset_write (result, rsfd_result, &buf2);
1052                 }
1053             } while ((more2 = rset_read (rset2, rsfd2, &buf2, &term_index)) &&
1054                       sysno == buf2.sysno);
1055         }
1056     }
1057     rset_close (result, rsfd_result);
1058     rset_close (rset1, rsfd1);
1059     rset_close (rset2, rsfd2);
1060     return result;
1061 }
1062
1063 static RSET rpn_prox (ZebraHandle zh, RSET *rset, int rset_no)
1064 {
1065     int i;
1066     RSFD *rsfd;
1067     int  *more;
1068     struct it_key **buf;
1069     RSET result;
1070     char prox_term[1024];
1071     int length_prox_term = 0;
1072     int min_nn = 10000000;
1073     int term_index;
1074     const char *flags = NULL;
1075
1076     rsfd = xmalloc (sizeof(*rsfd)*rset_no);
1077     more = xmalloc (sizeof(*more)*rset_no);
1078     buf = xmalloc (sizeof(*buf)*rset_no);
1079
1080     for (i = 0; i<rset_no; i++)
1081     {
1082         int j;
1083         buf[i] = xmalloc (sizeof(**buf));
1084         rsfd[i] = rset_open (rset[i], RSETF_READ);
1085         if (!(more[i] = rset_read (rset[i], rsfd[i], buf[i], &term_index)))
1086             break;
1087         for (j = 0; j<rset[i]->no_rset_terms; j++)
1088         {
1089             const char *nflags = rset[i]->rset_terms[j]->flags;
1090             char *term = rset[i]->rset_terms[j]->name;
1091             int lterm = strlen(term);
1092             if (length_prox_term)
1093                 prox_term[length_prox_term++] = ' ';
1094             strcpy (prox_term + length_prox_term, term);
1095             length_prox_term += lterm;
1096             if (min_nn > rset[i]->rset_terms[j]->nn)
1097                 min_nn = rset[i]->rset_terms[j]->nn;
1098             flags = nflags;
1099         }
1100     }
1101     if (i != rset_no)
1102     {
1103         rset_null_parms parms;
1104
1105         while (i >= 0)
1106         {
1107             rset_close (rset[i], rsfd[i]);
1108             xfree (buf[i]);
1109             --i;
1110         }
1111         parms.rset_term = rset_term_create (prox_term, -1, flags);
1112         parms.rset_term->nn = 0;
1113         result = rset_create (rset_kind_null, &parms);
1114     }
1115     else
1116     {
1117         rset_temp_parms parms;
1118         RSFD rsfd_result;
1119
1120         parms.rset_term = rset_term_create (prox_term, -1, flags);
1121         parms.rset_term->nn = min_nn;
1122         parms.key_size = sizeof (struct it_key);
1123         parms.temp_path = res_get (zh->res, "setTmpDir");
1124         result = rset_create (rset_kind_temp, &parms);
1125         rsfd_result = rset_open (result, RSETF_WRITE);
1126
1127         while (*more)
1128         {
1129             for (i = 1; i<rset_no; i++)
1130             {
1131                 int cmp;
1132
1133                 if (!more[i])
1134                 {
1135                     *more = 0;
1136                     break;
1137                 }
1138                 cmp = key_compare_it (buf[i], buf[i-1]);
1139                 if (cmp > 1)
1140                 {
1141                     more[i-1] = rset_read (rset[i-1], rsfd[i-1],
1142                                            buf[i-1], &term_index);
1143                     break;
1144                 }
1145                 else if (cmp == 1)
1146                 {
1147                     if (buf[i-1]->seqno+1 != buf[i]->seqno)
1148                     {
1149                         more[i-1] = rset_read (rset[i-1], rsfd[i-1],
1150                                                buf[i-1], &term_index);
1151                         break;
1152                     }
1153                 }
1154                 else
1155                 {
1156                     more[i] = rset_read (rset[i], rsfd[i], buf[i],
1157                                          &term_index);
1158                     break;
1159                 }
1160             }
1161             if (i == rset_no)
1162             {
1163                 rset_write (result, rsfd_result, buf[0]);
1164                 more[0] = rset_read (*rset, *rsfd, *buf, &term_index);
1165             }
1166         }
1167
1168         for (i = 0; i<rset_no; i++)
1169         {
1170             rset_close (rset[i], rsfd[i]);
1171             xfree (buf[i]);
1172         }
1173         rset_close (result, rsfd_result);
1174     }
1175     xfree (buf);
1176     xfree (more);
1177     xfree (rsfd);
1178     return result;
1179 }
1180
1181 static RSET rpn_search_APT_phrase (ZebraHandle zh,
1182                                    Z_AttributesPlusTerm *zapt,
1183                                    const char *termz,
1184                                    oid_value attributeSet,
1185                                    int reg_type, int complete_flag,
1186                                    const char *rank_type,
1187                                    int num_bases, char **basenames)
1188 {
1189     char term_dst[IT_MAX_WORD+1];
1190     const char *termp = termz;
1191     RSET rset[60], result;
1192     int i, r, rset_no = 0;
1193     struct grep_info grep_info;
1194
1195 #ifdef TERM_COUNT
1196     grep_info.term_no = 0;
1197 #endif
1198     grep_info.isam_p_size = 0;
1199     grep_info.isam_p_buf = NULL;
1200     grep_info.zh = zh;
1201     grep_info.reg_type = reg_type;
1202
1203     while (1)
1204     {
1205         logf (LOG_DEBUG, "APT_phrase termp=%s", termp);
1206         grep_info.isam_p_indx = 0;
1207         r = field_term (zh, zapt, &termp, attributeSet, &grep_info,
1208                         reg_type, complete_flag, num_bases, basenames,
1209                         term_dst);
1210         if (r < 1)
1211             break;
1212         logf (LOG_DEBUG, "term: %s", term_dst);
1213         rset[rset_no] = rset_trunc (zh, grep_info.isam_p_buf,
1214                                     grep_info.isam_p_indx, term_dst,
1215                                     strlen(term_dst), rank_type);
1216         assert (rset[rset_no]);
1217         if (++rset_no >= sizeof(rset)/sizeof(*rset))
1218             break;
1219     }
1220 #ifdef TERM_COUNT
1221     xfree(grep_info.term_no);
1222 #endif
1223     xfree (grep_info.isam_p_buf);
1224     if (rset_no == 0)
1225     {
1226         rset_null_parms parms;
1227
1228         parms.rset_term = rset_term_create (term_dst, -1, rank_type);
1229         return rset_create (rset_kind_null, &parms);
1230     }
1231     else if (rset_no == 1)
1232         return (rset[0]);
1233     result = rpn_prox (zh, rset, rset_no);
1234     for (i = 0; i<rset_no; i++)
1235         rset_delete (rset[i]);
1236     return result;
1237 }
1238
1239 static RSET rpn_search_APT_or_list (ZebraHandle zh,
1240                                     Z_AttributesPlusTerm *zapt,
1241                                     const char *termz,
1242                                     oid_value attributeSet,
1243                                     int reg_type, int complete_flag,
1244                                     const char *rank_type,
1245                                     int num_bases, char **basenames)
1246 {
1247     char term_dst[IT_MAX_WORD+1];
1248     const char *termp = termz;
1249     RSET rset[60], result;
1250     int i, r, rset_no = 0;
1251     struct grep_info grep_info;
1252
1253 #ifdef TERM_COUNT
1254     grep_info.term_no = 0;
1255 #endif
1256     grep_info.isam_p_size = 0;
1257     grep_info.isam_p_buf = NULL;
1258     grep_info.zh = zh;
1259     grep_info.reg_type = reg_type;
1260
1261     while (1)
1262     {
1263         logf (LOG_DEBUG, "APT_or_list termp=%s", termp);
1264         grep_info.isam_p_indx = 0;
1265         r = field_term (zh, zapt, &termp, attributeSet, &grep_info,
1266                         reg_type, complete_flag, num_bases, basenames,
1267                         term_dst);
1268         if (r < 1)
1269             break;
1270         logf (LOG_DEBUG, "term: %s", term_dst);
1271         rset[rset_no] = rset_trunc (zh, grep_info.isam_p_buf,
1272                                     grep_info.isam_p_indx, term_dst,
1273                                     strlen(term_dst), rank_type);
1274         assert (rset[rset_no]);
1275         if (++rset_no >= sizeof(rset)/sizeof(*rset))
1276             break;
1277     }
1278 #ifdef TERM_COUNT
1279     xfree(grep_info.term_no);
1280 #endif
1281     xfree (grep_info.isam_p_buf);
1282     if (rset_no == 0)
1283     {
1284         rset_null_parms parms;
1285
1286         parms.rset_term = rset_term_create (term_dst, -1, rank_type);
1287         return rset_create (rset_kind_null, &parms);
1288     }
1289     result = rset[0];
1290     for (i = 1; i<rset_no; i++)
1291     {
1292         rset_bool_parms bool_parms;
1293
1294         bool_parms.rset_l = result;
1295         bool_parms.rset_r = rset[i];
1296         bool_parms.key_size = sizeof(struct it_key);
1297         bool_parms.cmp = key_compare_it;
1298         result = rset_create (rset_kind_or, &bool_parms);
1299     }
1300     return result;
1301 }
1302
1303 static RSET rpn_search_APT_and_list (ZebraHandle zh,
1304                                      Z_AttributesPlusTerm *zapt,
1305                                      const char *termz,
1306                                      oid_value attributeSet,
1307                                      int reg_type, int complete_flag,
1308                                      const char *rank_type,
1309                                      int num_bases, char **basenames)
1310 {
1311     char term_dst[IT_MAX_WORD+1];
1312     const char *termp = termz;
1313     RSET rset[60], result;
1314     int i, r, rset_no = 0;
1315     struct grep_info grep_info;
1316
1317 #ifdef TERM_COUNT
1318     grep_info.term_no = 0;
1319 #endif
1320     grep_info.isam_p_size = 0;
1321     grep_info.isam_p_buf = NULL;
1322     grep_info.zh = zh;
1323     grep_info.reg_type = reg_type;
1324
1325     while (1)
1326     {
1327         logf (LOG_DEBUG, "APT_and_list termp=%s", termp);
1328         grep_info.isam_p_indx = 0;
1329         r = field_term (zh, zapt, &termp, attributeSet, &grep_info,
1330                         reg_type, complete_flag, num_bases, basenames,
1331                         term_dst);
1332         if (r < 1)
1333             break;
1334         logf (LOG_DEBUG, "term: %s", term_dst);
1335         rset[rset_no] = rset_trunc (zh, grep_info.isam_p_buf,
1336                                     grep_info.isam_p_indx, term_dst,
1337                                     strlen(term_dst), rank_type);
1338         assert (rset[rset_no]);
1339         if (++rset_no >= sizeof(rset)/sizeof(*rset))
1340             break;
1341     }
1342 #ifdef TERM_COUNT
1343     xfree(grep_info.term_no);
1344 #endif
1345     xfree (grep_info.isam_p_buf);
1346     if (rset_no == 0)
1347     {
1348         rset_null_parms parms;
1349
1350         parms.rset_term = rset_term_create (term_dst, -1, rank_type);
1351         return rset_create (rset_kind_null, &parms);
1352     }
1353     result = rset[0];
1354     for (i = 1; i<rset_no; i++)
1355     {
1356         rset_bool_parms bool_parms;
1357
1358         bool_parms.rset_l = result;
1359         bool_parms.rset_r = rset[i];
1360         bool_parms.key_size = sizeof(struct it_key);
1361         bool_parms.cmp = key_compare_it;
1362         result = rset_create (rset_kind_and, &bool_parms);
1363     }
1364     return result;
1365 }
1366
1367
1368 static RSET rpn_search_APT_local (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
1369                                   const char *termz,
1370                                   oid_value attributeSet,
1371                                   const char *rank_type)
1372 {
1373     RSET result;
1374     RSFD rsfd;
1375     struct it_key key;
1376     rset_temp_parms parms;
1377
1378     parms.rset_term = rset_term_create (termz, -1, rank_type);
1379     parms.key_size = sizeof (struct it_key);
1380     parms.temp_path = res_get (zh->res, "setTmpDir");
1381     result = rset_create (rset_kind_temp, &parms);
1382     rsfd = rset_open (result, RSETF_WRITE);
1383
1384     key.sysno = atoi (termz);
1385     key.seqno = 1;
1386     if (key.sysno <= 0)
1387         key.sysno = 1;
1388     rset_write (result, rsfd, &key);
1389     rset_close (result, rsfd);
1390     return result;
1391 }
1392
1393 static RSET rpn_search_APT (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
1394                             oid_value attributeSet,
1395                             int num_bases, char **basenames)
1396 {
1397     unsigned reg_id;
1398     char *search_type = NULL;
1399     char *rank_type = NULL;
1400     int complete_flag;
1401     char termz[IT_MAX_WORD+1];
1402
1403     zebra_maps_attr (zh->zebra_maps, zapt, &reg_id, &search_type,
1404                      &rank_type, &complete_flag);
1405
1406     logf (LOG_DEBUG, "reg_id=%c", reg_id);
1407     logf (LOG_DEBUG, "complete_flag=%d", complete_flag);
1408     logf (LOG_DEBUG, "search_type=%s", search_type);
1409     logf (LOG_DEBUG, "rank_type=%s", rank_type);
1410
1411     if (zapt->term->which != Z_Term_general)
1412     {
1413         zh->errCode = 124;
1414         return NULL;
1415     }
1416     trans_term (zh, zapt, termz);
1417
1418     if (!strcmp (search_type, "phrase"))
1419     {
1420         return rpn_search_APT_phrase (zh, zapt, termz, attributeSet,
1421                                       reg_id, complete_flag, rank_type,
1422                                       num_bases, basenames);
1423     }
1424     else if (!strcmp (search_type, "and-list"))
1425     {
1426         return rpn_search_APT_and_list (zh, zapt, termz, attributeSet,
1427                                         reg_id, complete_flag, rank_type,
1428                                         num_bases, basenames);
1429     }
1430     else if (!strcmp (search_type, "or-list"))
1431     {
1432         return rpn_search_APT_or_list (zh, zapt, termz, attributeSet,
1433                                        reg_id, complete_flag, rank_type,
1434                                        num_bases, basenames);
1435     }
1436     else if (!strcmp (search_type, "local"))
1437     {
1438         return rpn_search_APT_local (zh, zapt, termz, attributeSet,
1439                                      rank_type);
1440     }
1441     zh->errCode = 118;
1442     return NULL;
1443 }
1444
1445 static RSET rpn_search_structure (ZebraHandle zh, Z_RPNStructure *zs,
1446                                   oid_value attributeSet, ODR stream,
1447                                   int num_bases, char **basenames)
1448 {
1449     RSET r = NULL;
1450     if (zs->which == Z_RPNStructure_complex)
1451     {
1452         Z_Operator *zop = zs->u.complex->roperator;
1453         rset_bool_parms bool_parms;
1454
1455         bool_parms.rset_l = rpn_search_structure (zh, zs->u.complex->s1,
1456                                                   attributeSet, stream,
1457                                                   num_bases, basenames);
1458         if (bool_parms.rset_l == NULL)
1459             return NULL;
1460         bool_parms.rset_r = rpn_search_structure (zh, zs->u.complex->s2,
1461                                                   attributeSet, stream,
1462                                                   num_bases, basenames);
1463         if (bool_parms.rset_r == NULL)
1464         {
1465             rset_delete (bool_parms.rset_l);
1466             return NULL;
1467         }
1468         bool_parms.key_size = sizeof(struct it_key);
1469         bool_parms.cmp = key_compare_it;
1470
1471         switch (zop->which)
1472         {
1473         case Z_Operator_and:
1474             r = rset_create (rset_kind_and, &bool_parms);
1475             break;
1476         case Z_Operator_or:
1477             r = rset_create (rset_kind_or, &bool_parms);
1478             break;
1479         case Z_Operator_and_not:
1480             r = rset_create (rset_kind_not, &bool_parms);
1481             break;
1482         case Z_Operator_prox:
1483 #ifdef ASN_COMPILED
1484             if (zop->u.prox->which != Z_ProximityOperator_known)
1485             {
1486                 zh->errCode = 132;
1487                 return NULL;
1488             }
1489 #else
1490             if (zop->u.prox->which != Z_ProxCode_known)
1491             {
1492                 zh->errCode = 132;
1493                 return NULL;
1494             }
1495 #endif
1496
1497 #ifdef ASN_COMPILED
1498             if (*zop->u.prox->u.known != Z_ProxUnit_word)
1499             {
1500                 char *val = odr_malloc (stream, 16);
1501                 zh->errCode = 132;
1502                 zh->errString = val;
1503                 sprintf (val, "%d", *zop->u.prox->u.known);
1504                 return NULL;
1505             }
1506 #else
1507             if (*zop->u.prox->proximityUnitCode != Z_ProxUnit_word)
1508             {
1509                 char *val = odr_malloc (stream, 16);
1510                 zh->errCode = 132;
1511                 zh->errString = val;
1512                 sprintf (val, "%d", *zop->u.prox->proximityUnitCode);
1513                 return NULL;
1514             }
1515 #endif
1516             r = rpn_proximity (zh, bool_parms.rset_l, bool_parms.rset_r,
1517                                *zop->u.prox->ordered,
1518                                (!zop->u.prox->exclusion ? 0 :
1519                                          *zop->u.prox->exclusion),
1520                                *zop->u.prox->relationType,
1521                                *zop->u.prox->distance);
1522             break;
1523         default:
1524             zh->errCode = 110;
1525             return NULL;
1526         }
1527     }
1528     else if (zs->which == Z_RPNStructure_simple)
1529     {
1530         if (zs->u.simple->which == Z_Operand_APT)
1531         {
1532             logf (LOG_DEBUG, "rpn_search_APT");
1533             r = rpn_search_APT (zh, zs->u.simple->u.attributesPlusTerm,
1534                                 attributeSet, num_bases, basenames);
1535         }
1536         else if (zs->u.simple->which == Z_Operand_resultSetId)
1537         {
1538             logf (LOG_DEBUG, "rpn_search_ref");
1539             r = resultSetRef (zh, zs->u.simple->u.resultSetId);
1540             if (!r)
1541                 r = rset_create (rset_kind_null, NULL);
1542         }
1543         else
1544         {
1545             zh->errCode = 3;
1546             return NULL;
1547         }
1548     }
1549     else
1550     {
1551         zh->errCode = 3;
1552         return NULL;
1553     }
1554     return r;
1555 }
1556
1557 void rpn_search (ZebraHandle zh, ODR stream,
1558                  Z_RPNQuery *rpn, int num_bases, char **basenames,
1559                  const char *setname)
1560 {
1561     RSET rset;
1562     oident *attrset;
1563     oid_value attributeSet;
1564
1565     zlog_rpn (rpn);
1566
1567     zh->errCode = 0;
1568     zh->errString = NULL;
1569     zh->hits = 0;
1570
1571     attrset = oid_getentbyoid (rpn->attributeSetId);
1572     attributeSet = attrset->value;
1573     rset = rpn_search_structure (zh, rpn->RPNStructure, attributeSet, stream,
1574                                  num_bases, basenames);
1575     if (!rset)
1576         return;
1577
1578     resultSetAdd (zh, setname, 1, rset, &zh->hits);
1579     if (zh->errCode)
1580         logf (LOG_DEBUG, "search error: %d", zh->errCode);
1581 }
1582
1583 struct scan_info_entry {
1584     char *term;
1585     ISAM_P isam_p;
1586 };
1587
1588 struct scan_info {
1589     struct scan_info_entry *list;
1590     ODR odr;
1591     int before, after;
1592     char prefix[20];
1593 };
1594
1595 static int scan_handle (char *name, const char *info, int pos, void *client)
1596 {
1597     int len_prefix, idx;
1598     struct scan_info *scan_info = client;
1599
1600     len_prefix = strlen(scan_info->prefix);
1601     if (memcmp (name, scan_info->prefix, len_prefix))
1602         return 1;
1603     if (pos > 0)
1604         idx = scan_info->after - pos + scan_info->before;
1605     else
1606         idx = - pos - 1;
1607     scan_info->list[idx].term = odr_malloc (scan_info->odr,
1608                                             strlen(name + len_prefix)+1);
1609     strcpy (scan_info->list[idx].term, name + len_prefix);
1610     assert (*info == sizeof(ISAM_P));
1611     memcpy (&scan_info->list[idx].isam_p, info+1, sizeof(ISAM_P));
1612     return 0;
1613 }
1614
1615 static void scan_term_untrans (ZebraHandle zh, ODR stream, int reg_type,
1616                                char **dstp, const char *src)
1617 {
1618     char term_dst[1024], **dst;
1619
1620     term_untrans (zh, reg_type, term_dst, src);
1621
1622     *dst = odr_malloc (stream, strlen(term_dst)+1);
1623     strcpy (*dst, term_dst);
1624 }
1625
1626 static void count_set (RSET r, int *count)
1627 {
1628     int psysno = 0;
1629     int kno = 0;
1630     struct it_key key;
1631     RSFD rfd;
1632     int term_index;
1633
1634     logf (LOG_DEBUG, "count_set");
1635
1636     *count = 0;
1637     rfd = rset_open (r, RSETF_READ);
1638     while (rset_read (r, rfd, &key, &term_index))
1639     {
1640         if (key.sysno != psysno)
1641         {
1642             psysno = key.sysno;
1643             (*count)++;
1644         }
1645         kno++;
1646     }
1647     rset_close (r, rfd);
1648     logf (LOG_DEBUG, "%d keys, %d records", kno, *count);
1649 }
1650
1651 void rpn_scan (ZebraHandle zh, ODR stream, Z_AttributesPlusTerm *zapt,
1652                oid_value attributeset,
1653                int num_bases, char **basenames,
1654                int *position, int *num_entries, ZebraScanEntry **list,
1655                int *is_partial)
1656 {
1657     int i;
1658     int pos = *position;
1659     int num = *num_entries;
1660     int before;
1661     int after;
1662     int base_no;
1663     char termz[IT_MAX_WORD+20];
1664     AttrType use;
1665     int use_value;
1666     struct scan_info *scan_info_array;
1667     ZebraScanEntry *glist;
1668     int ords[32], ord_no = 0;
1669     int ptr[32];
1670
1671     unsigned reg_id;
1672     char *search_type = NULL;
1673     char *rank_type = NULL;
1674     int complete_flag;
1675
1676     if (attributeset == VAL_NONE)
1677         attributeset = VAL_BIB1;
1678
1679     zlog_scan (zapt, attributeset);
1680     logf (LOG_DEBUG, "position = %d, num = %d", pos, num);
1681
1682     attr_init (&use, zapt, 1);
1683     use_value = attr_find (&use, &attributeset);
1684
1685     if (zebra_maps_attr (zh->zebra_maps, zapt, &reg_id, &search_type,
1686                          &rank_type, &complete_flag))
1687     {
1688         zh->errCode = 113;
1689         return ;
1690     }
1691
1692     if (use_value == -1)
1693         use_value = 1016;
1694     for (base_no = 0; base_no < num_bases && ord_no < 32; base_no++)
1695     {
1696         int r;
1697         attent attp;
1698         data1_local_attribute *local_attr;
1699
1700         if ((r=att_getentbyatt (zh, &attp, attributeset, use_value)))
1701         {
1702             logf (LOG_DEBUG, "att_getentbyatt fail. set=%d use=%d",
1703                   attributeset, use_value);
1704             if (r == -1)
1705                 zh->errCode = 114;
1706             else
1707                 zh->errCode = 121;
1708         }
1709         if (zebraExplain_curDatabase (zh->zei, basenames[base_no]))
1710         {
1711             zh->errString = basenames[base_no];
1712             zh->errCode = 109; /* Database unavailable */
1713             return;
1714         }
1715         for (local_attr = attp.local_attributes; local_attr && ord_no < 32;
1716              local_attr = local_attr->next)
1717         {
1718             int ord;
1719
1720             ord = zebraExplain_lookupSU (zh->zei, attp.attset_ordinal,
1721                                          local_attr->local);
1722             if (ord > 0)
1723                 ords[ord_no++] = ord;
1724         }
1725     }
1726     if (ord_no == 0)
1727     {
1728         zh->errCode = 113;
1729         return;
1730     }
1731     before = pos-1;
1732     after = 1+num-pos;
1733     scan_info_array = odr_malloc (stream, ord_no * sizeof(*scan_info_array));
1734     for (i = 0; i < ord_no; i++)
1735     {
1736         int j, prefix_len = 0;
1737         int before_tmp = before, after_tmp = after;
1738         struct scan_info *scan_info = scan_info_array + i;
1739         struct rpn_char_map_info rcmi;
1740
1741         rpn_char_map_prepare (zh, reg_id, &rcmi);
1742
1743         scan_info->before = before;
1744         scan_info->after = after;
1745         scan_info->odr = stream;
1746
1747         scan_info->list = odr_malloc (stream, (before+after)*
1748                                       sizeof(*scan_info->list));
1749         for (j = 0; j<before+after; j++)
1750             scan_info->list[j].term = NULL;
1751         termz[prefix_len++] = ords[i];
1752         termz[prefix_len++] = reg_id;
1753         termz[prefix_len] = 0;
1754         strcpy (scan_info->prefix, termz);
1755
1756         trans_scan_term (zh, zapt, termz+prefix_len, reg_id);
1757
1758         dict_scan (zh->dict, termz, &before_tmp, &after_tmp, scan_info,
1759                    scan_handle);
1760     }
1761     glist = odr_malloc (stream, (before+after)*sizeof(*glist));
1762     for (i = 0; i < ord_no; i++)
1763         ptr[i] = before;
1764
1765     *is_partial = 0;
1766     for (i = 0; i<after; i++)
1767     {
1768         int j, j0 = -1;
1769         const char *mterm = NULL;
1770         const char *tst;
1771         RSET rset;
1772
1773         for (j = 0; j < ord_no; j++)
1774         {
1775             if (ptr[j] < before+after &&
1776                 (tst=scan_info_array[j].list[ptr[j]].term) &&
1777                 (!mterm || strcmp (tst, mterm) < 0))
1778             {
1779                 j0 = j;
1780                 mterm = tst;
1781             }
1782         }
1783         if (j0 == -1)
1784             break;
1785         scan_term_untrans (zh, stream, reg_id,
1786                            &glist[i+before].term, mterm);
1787         rset = rset_trunc (zh, &scan_info_array[j0].list[ptr[j0]].isam_p, 1,
1788                            glist[i+before].term, strlen(glist[i+before].term),
1789                            NULL);
1790
1791         ptr[j0]++;
1792         for (j = j0+1; j<ord_no; j++)
1793         {
1794             if (ptr[j] < before+after &&
1795                 (tst=scan_info_array[j].list[ptr[j]].term) &&
1796                 !strcmp (tst, mterm))
1797             {
1798                 rset_bool_parms bool_parms;
1799                 RSET rset2;
1800
1801                 rset2 =
1802                    rset_trunc (zh, &scan_info_array[j].list[ptr[j]].isam_p, 1,
1803                                glist[i+before].term,
1804                                strlen(glist[i+before].term), NULL);
1805
1806                 bool_parms.key_size = sizeof(struct it_key);
1807                 bool_parms.cmp = key_compare_it;
1808                 bool_parms.rset_l = rset;
1809                 bool_parms.rset_r = rset2;
1810
1811                 rset = rset_create (rset_kind_or, &bool_parms);
1812
1813                 ptr[j]++;
1814             }
1815         }
1816         count_set (rset, &glist[i+before].occurrences);
1817         rset_delete (rset);
1818     }
1819     if (i < after)
1820     {
1821         *num_entries -= (after-i);
1822         *is_partial = 1;
1823     }
1824
1825     for (i = 0; i<ord_no; i++)
1826         ptr[i] = 0;
1827
1828     for (i = 0; i<before; i++)
1829     {
1830         int j, j0 = -1;
1831         const char *mterm = NULL;
1832         const char *tst;
1833         RSET rset;
1834
1835         for (j = 0; j <ord_no; j++)
1836         {
1837             if (ptr[j] < before &&
1838                 (tst=scan_info_array[j].list[before-1-ptr[j]].term) &&
1839                 (!mterm || strcmp (tst, mterm) > 0))
1840             {
1841                 j0 = j;
1842                 mterm = tst;
1843             }
1844         }
1845         if (j0 == -1)
1846             break;
1847
1848         scan_term_untrans (zh, stream, reg_id,
1849                            &glist[before-1-i].term, mterm);
1850
1851         rset = rset_trunc
1852                (zh, &scan_info_array[j0].list[before-1-ptr[j0]].isam_p, 1,
1853                 glist[before-1-i].term, strlen(glist[before-1-i].term),
1854                 NULL);
1855
1856         ptr[j0]++;
1857
1858         for (j = j0+1; j<ord_no; j++)
1859         {
1860             if (ptr[j] < before &&
1861                 (tst=scan_info_array[j].list[before-1-ptr[j]].term) &&
1862                 !strcmp (tst, mterm))
1863             {
1864                 rset_bool_parms bool_parms;
1865                 RSET rset2;
1866
1867                 rset2 = rset_trunc (zh,
1868                          &scan_info_array[j].list[before-1-ptr[j]].isam_p, 1,
1869                                     glist[before-1-i].term,
1870                                     strlen(glist[before-1-i].term), NULL);
1871
1872                 bool_parms.key_size = sizeof(struct it_key);
1873                 bool_parms.cmp = key_compare_it;
1874                 bool_parms.rset_l = rset;
1875                 bool_parms.rset_r = rset2;
1876
1877                 rset = rset_create (rset_kind_or, &bool_parms);
1878
1879                 ptr[j]++;
1880             }
1881         }
1882         count_set (rset, &glist[before-1-i].occurrences);
1883         rset_delete (rset);
1884     }
1885     i = before-i;
1886     if (i)
1887     {
1888         *is_partial = 1;
1889         *position -= i;
1890         *num_entries -= i;
1891     }
1892     *list = glist + i;               /* list is set to first 'real' entry */
1893
1894     logf (LOG_DEBUG, "position = %d, num_entries = %d",
1895           *position, *num_entries);
1896     if (zh->errCode)
1897         logf (LOG_DEBUG, "scan error: %d", zh->errCode);
1898 }
1899