index/rpnscan.c

   1 /* $Id: rpnscan.c,v 1.10 2007-05-08 14:49:38 adam Exp $
   2    Copyright (C) 1995-2007
   3    Index Data ApS
   4
   5 This file is part of the Zebra server.
   6
   7 Zebra is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 Zebra is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  20
  21 */
  22
  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 "index.h"
  35 #include <zebra_xpath.h>
  36 #include <yaz/wrbuf.h>
  37 #include <attrfind.h>
  38 #include <charmap.h>
  39 #include <rset.h>
  40 #include <yaz/oid_db.h>
  41
  42 #define RPN_MAX_ORDS 32
  43
  44 int log_scan = YLOG_LOG;
  45
  46 /* convert APT SCAN term to internal cmap */
  47 static ZEBRA_RES trans_scan_term(ZebraHandle zh, Z_AttributesPlusTerm *zapt,
  48                                  char *termz, int reg_type)
  49 {
  50     char termz0[IT_MAX_WORD];
  51
  52     if (zapt_term_to_utf8(zh, zapt, termz0) == ZEBRA_FAIL)
  53         return ZEBRA_FAIL;    /* error */
  54     else
  55     {
  56         const char **map;
  57         const char *cp = (const char *) termz0;
  58         const char *cp_end = cp + strlen(cp);
  59         const char *src;
  60         int i = 0;
  61         const char *space_map = NULL;
  62         int len;
  63
  64         while ((len = (cp_end - cp)) > 0)
  65         {
  66             map = zebra_maps_input(zh->reg->zebra_maps, reg_type, &cp, len, 0);
  67             if (**map == *CHR_SPACE)
  68                 space_map = *map;
  69             else
  70             {
  71                 if (i && space_map)
  72                     for (src = space_map; *src; src++)
  73                         termz[i++] = *src;
  74                 space_map = NULL;
  75                 for (src = *map; *src; src++)
  76                     termz[i++] = *src;
  77             }
  78         }
  79         termz[i] = '\0';
  80     }
  81     return ZEBRA_OK;
  82 }
  83
  84 static void count_set(ZebraHandle zh, RSET rset, zint *count)
  85 {
  86     zint psysno = 0;
  87     struct it_key key;
  88     RSFD rfd;
  89
  90     yaz_log(YLOG_DEBUG, "count_set");
  91
  92     rset->hits_limit = zh->approx_limit;
  93
  94     *count = 0;
  95     rfd = rset_open(rset, RSETF_READ);
  96     while (rset_read(rfd, &key,0 /* never mind terms */))
  97     {
  98         if (key.mem[0] != psysno)
  99         {
 100             psysno = key.mem[0];
 101             if (rfd->counted_items >= rset->hits_limit)
 102                 break;
 103         }
 104     }
 105     rset_close (rfd);
 106     *count = rset->hits_count;
 107 }
 108
 109 struct scan2_info_entry {
 110     WRBUF term;
 111     char prefix[20];
 112     ISAM_P isam_p;
 113     int pos_to_save;
 114 };
 115
 116 static int scan_handle2(char *name, const char *info, int pos, void *client)
 117 {
 118     int len_prefix;
 119     struct scan2_info_entry *scan_info = (struct scan2_info_entry *) client;
 120
 121     if (scan_info->pos_to_save != pos)
 122         return 0;
 123
 124     len_prefix = strlen(scan_info->prefix);
 125     if (memcmp (name, scan_info->prefix, len_prefix))
 126         return 1;
 127
 128     /* skip special terms such as first-in-field specials */
 129     if (name[len_prefix] < CHR_BASE_CHAR)
 130         return 1;
 131
 132     wrbuf_rewind(scan_info->term);
 133     wrbuf_puts(scan_info->term, name+len_prefix);
 134
 135     assert (*info == sizeof(ISAM_P));
 136     memcpy (&scan_info->isam_p, info+1, sizeof(ISAM_P));
 137     return 0;
 138 }
 139
 140
 141 static int scan_save_set(ZebraHandle zh, ODR stream, NMEM nmem,
 142                          struct rset_key_control *kc,
 143                          Z_AttributesPlusTerm *zapt,
 144                          RSET limit_set,
 145                          const char *term,
 146                          int index_type,
 147                          struct scan2_info_entry *ar, int ord_no,
 148                          ZebraScanEntry *glist, int pos)
 149 {
 150     int i;
 151     RSET rset = 0;
 152     for (i = 0; i < ord_no; i++)
 153     {
 154         if (ar[i].isam_p && strcmp(wrbuf_cstr(ar[i].term), term) == 0)
 155         {
 156             RSET rset_t = rset_trunc(
 157                     zh, &ar[i].isam_p, 1,
 158                     wrbuf_buf(ar[i].term), wrbuf_len(ar[i].term),
 159                     NULL, 0, zapt->term->which, nmem,
 160                     kc, kc->scope, 0, index_type,
 161                     0 /* hits_limit */,
 162                     0 /* term_ref_id_str */);
 163             if (!rset)
 164                 rset = rset_t;
 165             else
 166             {
 167                 RSET rsets[2];
 168
 169                 rsets[0] = rset;
 170                 rsets[1] = rset_t;
 171                 rset = rset_create_or(nmem, kc, kc->scope, 0 /* termid */,
 172                                       2, rsets);
 173             }
 174             ar[i].isam_p = 0;
 175         }
 176     }
 177     if (rset)
 178     {
 179         zint count;
 180         /* merge with limit_set if given */
 181         if (limit_set)
 182         {
 183             RSET rsets[2];
 184             rsets[0] = rset;
 185             rsets[1] = rset_dup(limit_set);
 186
 187             rset = rset_create_and(nmem, kc, kc->scope, 2, rsets);
 188         }
 189         /* count it */
 190         count_set(zh, rset, &count);
 191         rset_delete(rset);
 192         if (count > 0)
 193         {
 194             if (pos != -1)
 195             {
 196                 zebra_term_untrans_iconv(zh, stream->mem, index_type,
 197                                          &glist[pos].term, term);
 198                 glist[pos].occurrences = count;
 199             }
 200             return 1;
 201         }
 202     }
 203     return 0;
 204 }
 205
 206 static ZEBRA_RES rpn_scan_ver2(ZebraHandle zh, ODR stream, NMEM nmem,
 207                                struct rset_key_control *kc,
 208                                Z_AttributesPlusTerm *zapt,
 209                                int *position, int *num_entries,
 210                                ZebraScanEntry **list,
 211                                int *is_partial, RSET limit_set,
 212                                int index_type, int ord_no, int *ords)
 213 {
 214     struct scan2_info_entry *ar = nmem_malloc(nmem, sizeof(*ar) * ord_no);
 215     struct rpn_char_map_info rcmi;
 216     int i, dif;
 217     int pos = 0;
 218
 219     ZebraScanEntry *glist = (ZebraScanEntry *)
 220         odr_malloc(stream, *num_entries * sizeof(*glist));
 221
 222     *is_partial = 0;
 223     if (*position > *num_entries+1)
 224     {
 225         *is_partial = 1;
 226         *position = 1;
 227         *num_entries = 0;
 228         return ZEBRA_OK;
 229     }
 230     rpn_char_map_prepare (zh->reg, index_type, &rcmi);
 231
 232     for (i = 0; i < ord_no; i++)
 233         ar[i].term = wrbuf_alloc();
 234
 235     for (i = 0; i < ord_no; i++)
 236     {
 237         char termz[IT_MAX_WORD+20];
 238         int prefix_len = 0;
 239
 240         prefix_len = key_SU_encode (ords[i], termz);
 241         termz[prefix_len] = 0;
 242         strcpy(ar[i].prefix, termz);
 243
 244         if (trans_scan_term(zh, zapt, termz+prefix_len, index_type) ==
 245             ZEBRA_FAIL)
 246         {
 247             for (i = 0; i < ord_no; i++)
 248                 wrbuf_destroy(ar[i].term);
 249             return ZEBRA_FAIL;
 250         }
 251         wrbuf_rewind(ar[i].term);
 252         wrbuf_puts(ar[i].term, termz + prefix_len);
 253         ar[i].isam_p = 0;
 254     }
 255     /** deal with terms before position .. */
 256     /* the glist index starts at zero (unlike scan positions */
 257     for (pos = *position-2; pos >= 0; )
 258     {
 259         const char *hi = 0;
 260
 261         /* scan on all maximum terms */
 262         for (i = 0; i < ord_no; i++)
 263         {
 264             if (ar[i].isam_p == 0)
 265             {
 266                 char termz[IT_MAX_WORD+20];
 267                 int before = 1;
 268                 int after = 0;
 269
 270                 ar[i].pos_to_save = -1;
 271
 272                 strcpy(termz, ar[i].prefix);
 273                 strcat(termz, wrbuf_cstr(ar[i].term));
 274                 dict_scan(zh->reg->dict, termz, &before, &after,
 275                           ar+i, scan_handle2);
 276             }
 277         }
 278         /* get maximum after scan */
 279         for (i = 0; i < ord_no; i++)
 280         {
 281             if (ar[i].isam_p
 282                 && (hi == 0 || strcmp(wrbuf_cstr(ar[i].term), hi) > 0))
 283                 hi = wrbuf_cstr(ar[i].term);
 284         }
 285         if (!hi)
 286             break;
 287         if (scan_save_set(zh, stream, nmem, kc, zapt, limit_set, hi,
 288                           index_type, ar, ord_no, glist,
 289                           (pos >= 0 && pos < *num_entries) ? pos : -1))
 290             --pos;
 291     }
 292     /* see if we got all terms before.. */
 293     dif = 1 + pos;
 294     if (dif > 0)
 295     {
 296         /* did not get all terms; adjust the real position and reduce
 297            number of entries */
 298         yaz_log(YLOG_LOG, "before terms dif=%d", dif);
 299         glist = glist + dif;
 300         *num_entries -= dif;
 301         *position -= dif;
 302         *is_partial = 1;
 303     }
 304     for (i = 0; i < ord_no; i++)
 305     {
 306         char termz[IT_MAX_WORD+20];
 307         int prefix_len = 0;
 308
 309         prefix_len = key_SU_encode (ords[i], termz);
 310         termz[prefix_len] = 0;
 311         strcpy(ar[i].prefix, termz);
 312
 313         if (trans_scan_term(zh, zapt, termz+prefix_len, index_type) ==
 314             ZEBRA_FAIL)
 315             return ZEBRA_FAIL;
 316         wrbuf_rewind(ar[i].term);
 317         wrbuf_puts(ar[i].term, termz + prefix_len);
 318         ar[i].isam_p = 0;
 319     }
 320
 321     for (pos = *position-1; pos < *num_entries; )
 322     {
 323         const char *lo = 0;
 324
 325         /* scan on all minimum terms */
 326         for (i = 0; i < ord_no; i++)
 327         {
 328             if (ar[i].isam_p == 0)
 329             {
 330                 char termz[IT_MAX_WORD+20];
 331                 int before = 0;
 332                 int after = (pos == *position-1) ? 1 : 2;
 333
 334                 ar[i].pos_to_save = 1;
 335
 336                 strcpy(termz, ar[i].prefix);
 337                 strcat(termz, wrbuf_cstr(ar[i].term));
 338                 dict_scan(zh->reg->dict, termz, &before, &after,
 339                           ar+i, scan_handle2);
 340             }
 341         }
 342         /* get minimum after scan */
 343         for (i = 0; i < ord_no; i++)
 344         {
 345             if (ar[i].isam_p
 346                 && (lo == 0 || strcmp(wrbuf_cstr(ar[i].term), lo) < 0))
 347                 lo = wrbuf_cstr(ar[i].term);
 348         }
 349         if (!lo)
 350             break;
 351         if (scan_save_set(zh, stream, nmem, kc, zapt, limit_set, lo,
 352                           index_type, ar, ord_no, glist,
 353                           (pos >= 0 && pos < *num_entries) ? pos : -1))
 354             pos++;
 355
 356     }
 357     if (pos != *num_entries)
 358     {
 359         if (pos >= 0)
 360             *num_entries = pos;
 361         else
 362             *num_entries = 0;
 363         *is_partial = 1;
 364     }
 365
 366     *list = glist;
 367
 368     for (i = 0; i < ord_no; i++)
 369         wrbuf_destroy(ar[i].term);
 370
 371     return ZEBRA_OK;
 372 }
 373
 374 struct scan1_info_entry {
 375     char *term;
 376     ISAM_P isam_p;
 377 };
 378
 379 struct scan_info {
 380     struct scan1_info_entry *list;
 381     ODR odr;
 382     int before, after;
 383     char prefix[20];
 384 };
 385
 386 ZEBRA_RES rpn_scan(ZebraHandle zh, ODR stream, Z_AttributesPlusTerm *zapt,
 387                    const Odr_oid *attributeset,
 388                    int num_bases, char **basenames,
 389                    int *position, int *num_entries, ZebraScanEntry **list,
 390                    int *is_partial, RSET limit_set)
 391 {
 392     int base_no;
 393     int ords[RPN_MAX_ORDS], ord_no = 0;
 394
 395     unsigned index_type;
 396     char *search_type = NULL;
 397     char rank_type[128];
 398     int complete_flag;
 399     int sort_flag;
 400     NMEM nmem;
 401     ZEBRA_RES res;
 402     struct rset_key_control *kc = 0;
 403
 404     *list = 0;
 405     *is_partial = 0;
 406
 407     if (!attributeset)
 408         attributeset = yaz_oid_attset_bib_1;
 409
 410     if (!limit_set) /* no limit set given already */
 411     {
 412         /* see if there is a @attr 8=set */
 413         AttrType termset;
 414         int termset_value_numeric;
 415         const char *termset_value_string;
 416         attr_init_APT(&termset, zapt, 8);
 417         termset_value_numeric =
 418             attr_find_ex(&termset, NULL, &termset_value_string);
 419         if (termset_value_numeric != -1)
 420         {
 421             char resname[32];
 422             const char *termset_name = 0;
 423
 424             if (termset_value_numeric != -2)
 425             {
 426                 sprintf(resname, "%d", termset_value_numeric);
 427                 termset_name = resname;
 428             }
 429             else
 430                 termset_name = termset_value_string;
 431
 432             limit_set = resultSetRef (zh, termset_name);
 433
 434             if (!limit_set)
 435             {
 436                 zebra_setError(zh,
 437                                YAZ_BIB1_SPECIFIED_RESULT_SET_DOES_NOT_EXIST,
 438                                termset_name);
 439                 return ZEBRA_FAIL;
 440             }
 441         }
 442     }
 443
 444     yaz_log(YLOG_DEBUG, "position = %d, num = %d",
 445             *position, *num_entries);
 446
 447     if (zebra_maps_attr(zh->reg->zebra_maps, zapt, &index_type, &search_type,
 448                         rank_type, &complete_flag, &sort_flag))
 449     {
 450         *num_entries = 0;
 451         zebra_setError(zh, YAZ_BIB1_UNSUPP_ATTRIBUTE_TYPE, 0);
 452         return ZEBRA_FAIL;
 453     }
 454     if (num_bases > RPN_MAX_ORDS)
 455     {
 456         zebra_setError(zh, YAZ_BIB1_TOO_MANY_DATABASES_SPECIFIED, 0);
 457         return ZEBRA_FAIL;
 458     }
 459
 460     for (base_no = 0; base_no < num_bases; base_no++)
 461     {
 462         int ord;
 463
 464         if (zebraExplain_curDatabase (zh->reg->zei, basenames[base_no]))
 465         {
 466             zebra_setError(zh, YAZ_BIB1_DATABASE_UNAVAILABLE,
 467                            basenames[base_no]);
 468             *num_entries = 0;
 469             return ZEBRA_FAIL;
 470         }
 471         if (zebra_apt_get_ord(zh, zapt, index_type, 0, attributeset, &ord)
 472             != ZEBRA_OK)
 473             continue;
 474         ords[ord_no++] = ord;
 475     }
 476     if (ord_no == 0)
 477     {
 478         *num_entries = 0; /* zebra_apt_get_ord should set error reason */
 479         return ZEBRA_FAIL;
 480     }
 481     if (*num_entries < 1)
 482     {
 483         *num_entries = 0;
 484         return ZEBRA_OK;
 485     }
 486     nmem = nmem_create();
 487     kc = zebra_key_control_create(zh);
 488
 489     res = rpn_scan_ver2(zh, stream, nmem, kc, zapt, position, num_entries,
 490                         list,
 491                         is_partial, limit_set, index_type, ord_no, ords);
 492     nmem_destroy(nmem);
 493     (*kc->dec)(kc);
 494     return res;
 495 }
 496
 497 /*
 498  * Local variables:
 499  * c-basic-offset: 4
 500  * indent-tabs-mode: nil
 501  * End:
 502  * vim: shiftwidth=4 tabstop=8 expandtab
 503  */
 504