index/rpnscan.c

   1 /* $Id: rpnscan.c,v 1.3 2006-09-21 20:22:34 adam Exp $
   2    Copyright (C) 1995-2006
   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
  41 #define RPN_MAX_ORDS 32
  42
  43 int log_scan = YLOG_LOG;
  44
  45 /* convert APT SCAN term to internal cmap */
  46 static ZEBRA_RES trans_scan_term(ZebraHandle zh, Z_AttributesPlusTerm *zapt,
  47                                  char *termz, int reg_type)
  48 {
  49     char termz0[IT_MAX_WORD];
  50
  51     if (zapt_term_to_utf8(zh, zapt, termz0) == ZEBRA_FAIL)
  52         return ZEBRA_FAIL;    /* error */
  53     else
  54     {
  55         const char **map;
  56         const char *cp = (const char *) termz0;
  57         const char *cp_end = cp + strlen(cp);
  58         const char *src;
  59         int i = 0;
  60         const char *space_map = NULL;
  61         int len;
  62
  63         while ((len = (cp_end - cp)) > 0)
  64         {
  65             map = zebra_maps_input(zh->reg->zebra_maps, reg_type, &cp, len, 0);
  66             if (**map == *CHR_SPACE)
  67                 space_map = *map;
  68             else
  69             {
  70                 if (i && space_map)
  71                     for (src = space_map; *src; src++)
  72                         termz[i++] = *src;
  73                 space_map = NULL;
  74                 for (src = *map; *src; src++)
  75                     termz[i++] = *src;
  76             }
  77         }
  78         termz[i] = '\0';
  79     }
  80     return ZEBRA_OK;
  81 }
  82
  83 static void count_set(ZebraHandle zh, RSET rset, zint *count)
  84 {
  85     zint psysno = 0;
  86     struct it_key key;
  87     RSFD rfd;
  88
  89     yaz_log(YLOG_DEBUG, "count_set");
  90
  91     rset->hits_limit = zh->approx_limit;
  92
  93     *count = 0;
  94     rfd = rset_open(rset, RSETF_READ);
  95     while (rset_read(rfd, &key,0 /* never mind terms */))
  96     {
  97         if (key.mem[0] != psysno)
  98         {
  99             psysno = key.mem[0];
 100             if (rfd->counted_items >= rset->hits_limit)
 101                 break;
 102         }
 103     }
 104     rset_close (rfd);
 105     *count = rset->hits_count;
 106 }
 107
 108 struct scan2_info_entry {
 109     WRBUF term;
 110     char prefix[20];
 111     ISAM_P isam_p;
 112     int pos_to_save;
 113 };
 114
 115 static int scan_handle2(char *name, const char *info, int pos, void *client)
 116 {
 117     int len_prefix;
 118     struct scan2_info_entry *scan_info = (struct scan2_info_entry *) client;
 119
 120     if (scan_info->pos_to_save != pos)
 121         return 0;
 122
 123     len_prefix = strlen(scan_info->prefix);
 124     if (memcmp (name, scan_info->prefix, len_prefix))
 125         return 1;
 126
 127     /* skip special terms such as first-in-field specials */
 128     if (name[len_prefix] < CHR_BASE_CHAR)
 129         return 1;
 130
 131     wrbuf_rewind(scan_info->term);
 132     wrbuf_puts(scan_info->term, name+len_prefix);
 133
 134     assert (*info == sizeof(ISAM_P));
 135     memcpy (&scan_info->isam_p, info+1, sizeof(ISAM_P));
 136     return 0;
 137 }
 138
 139
 140 static int scan_save_set(ZebraHandle zh, ODR stream, NMEM nmem,
 141                          struct rset_key_control *kc,
 142                          Z_AttributesPlusTerm *zapt,
 143                          RSET limit_set,
 144                          const char *term,
 145                          int index_type,
 146                          struct scan2_info_entry *ar, int ord_no,
 147                          ZebraScanEntry *glist, int pos)
 148 {
 149     int i;
 150     RSET rset = 0;
 151     for (i = 0; i < ord_no; i++)
 152     {
 153         if (ar[i].isam_p && strcmp(wrbuf_buf(ar[i].term), term) == 0)
 154         {
 155             RSET rset_t = rset_trunc(
 156                     zh, &ar[i].isam_p, 1,
 157                     wrbuf_buf(ar[i].term), wrbuf_len(ar[i].term),
 158                     NULL, 0, zapt->term->which, nmem,
 159                     kc, kc->scope, 0, index_type,
 160                     0 /* hits_limit */,
 161                     0 /* term_ref_id_str */);
 162             if (!rset)
 163                 rset = rset_t;
 164             else
 165             {
 166                 RSET rsets[2];
 167
 168                 rsets[0] = rset;
 169                 rsets[1] = rset_t;
 170                 rset = rset_create_or(nmem, kc, kc->scope, 0 /* termid */,
 171                                       2, rsets);
 172             }
 173             ar[i].isam_p = 0;
 174         }
 175     }
 176     if (rset)
 177     {
 178         zint count;
 179         /* merge with limit_set if given */
 180         if (limit_set)
 181         {
 182             RSET rsets[2];
 183             rsets[0] = rset;
 184             rsets[1] = rset_dup(limit_set);
 185
 186             rset = rset_create_and(nmem, kc, kc->scope, 2, rsets);
 187         }
 188         /* count it */
 189         count_set(zh, rset, &count);
 190         rset_delete(rset);
 191         if (count > 0)
 192         {
 193             if (pos != -1)
 194             {
 195                 zebra_term_untrans_iconv(zh, stream->mem, index_type,
 196                                          &glist[pos].term, term);
 197                 glist[pos].occurrences = count;
 198             }
 199             return 1;
 200         }
 201     }
 202     return 0;
 203 }
 204
 205 static ZEBRA_RES rpn_scan_ver2(ZebraHandle zh, ODR stream, NMEM nmem,
 206                                struct rset_key_control *kc,
 207                                Z_AttributesPlusTerm *zapt,
 208                                int *position, int *num_entries,
 209                                ZebraScanEntry **list,
 210                                int *is_partial, RSET limit_set,
 211                                int index_type, int ord_no, int *ords)
 212 {
 213     struct scan2_info_entry *ar = nmem_malloc(nmem, sizeof(*ar) * ord_no);
 214     struct rpn_char_map_info rcmi;
 215     int i, dif;
 216     int pos = 0;
 217
 218     ZebraScanEntry *glist = (ZebraScanEntry *)
 219         odr_malloc(stream, *num_entries * sizeof(*glist));
 220
 221     *is_partial = 0;
 222     if (*position > *num_entries+1)
 223     {
 224         *is_partial = 1;
 225         *position = 1;
 226         *num_entries = 0;
 227         return ZEBRA_OK;
 228     }
 229     rpn_char_map_prepare (zh->reg, index_type, &rcmi);
 230
 231     for (i = 0; i < ord_no; i++)
 232         ar[i].term = wrbuf_alloc();
 233
 234     for (i = 0; i < ord_no; i++)
 235     {
 236         char termz[IT_MAX_WORD+20];
 237         int prefix_len = 0;
 238
 239         prefix_len = key_SU_encode (ords[i], termz);
 240         termz[prefix_len] = 0;
 241         strcpy(ar[i].prefix, termz);
 242
 243         if (trans_scan_term(zh, zapt, termz+prefix_len, index_type) ==
 244             ZEBRA_FAIL)
 245             return ZEBRA_FAIL;
 246         wrbuf_rewind(ar[i].term);
 247         wrbuf_puts(ar[i].term, termz + prefix_len);
 248         ar[i].isam_p = 0;
 249     }
 250     /** deal with terms before position .. */
 251     /* the glist index starts at zero (unlike scan positions */
 252     for (pos = *position-2; pos >= 0; )
 253     {
 254         const char *hi = 0;
 255
 256         /* scan on all maximum terms */
 257         for (i = 0; i < ord_no; i++)
 258         {
 259             if (ar[i].isam_p == 0)
 260             {
 261                 char termz[IT_MAX_WORD+20];
 262                 int before = 1;
 263                 int after = 0;
 264
 265                 ar[i].pos_to_save = -1;
 266
 267                 strcpy(termz, ar[i].prefix);
 268                 strcat(termz, wrbuf_buf(ar[i].term));
 269                 dict_scan(zh->reg->dict, termz, &before, &after,
 270                           ar+i, scan_handle2);
 271             }
 272         }
 273         /* get maximum after scan */
 274         for (i = 0; i < ord_no; i++)
 275         {
 276             if (ar[i].isam_p
 277                 && (hi == 0 || strcmp(wrbuf_buf(ar[i].term), hi) > 0))
 278                 hi = wrbuf_buf(ar[i].term);
 279         }
 280         if (!hi)
 281             break;
 282         if (scan_save_set(zh, stream, nmem, kc, zapt, limit_set, hi,
 283                           index_type, ar, ord_no, glist,
 284                           (pos >= 0 && pos < *num_entries) ? pos : -1))
 285             --pos;
 286     }
 287     /* see if we got all terms before.. */
 288     dif = 1 + pos;
 289     if (dif > 0)
 290     {
 291         /* did not get all terms; adjust the real position and reduce
 292            number of entries */
 293         yaz_log(YLOG_LOG, "before terms dif=%d", dif);
 294         glist = glist + dif;
 295         *num_entries -= dif;
 296         *position -= dif;
 297         *is_partial = 1;
 298     }
 299     for (i = 0; i < ord_no; i++)
 300     {
 301         char termz[IT_MAX_WORD+20];
 302         int prefix_len = 0;
 303
 304         prefix_len = key_SU_encode (ords[i], termz);
 305         termz[prefix_len] = 0;
 306         strcpy(ar[i].prefix, termz);
 307
 308         if (trans_scan_term(zh, zapt, termz+prefix_len, index_type) ==
 309             ZEBRA_FAIL)
 310             return ZEBRA_FAIL;
 311         wrbuf_rewind(ar[i].term);
 312         wrbuf_puts(ar[i].term, termz + prefix_len);
 313         ar[i].isam_p = 0;
 314     }
 315
 316     for (pos = *position-1; pos < *num_entries; )
 317     {
 318         const char *lo = 0;
 319
 320         /* scan on all minimum terms */
 321         for (i = 0; i < ord_no; i++)
 322         {
 323             if (ar[i].isam_p == 0)
 324             {
 325                 char termz[IT_MAX_WORD+20];
 326                 int before = 0;
 327                 int after = (pos == *position-1) ? 1 : 2;
 328
 329                 ar[i].pos_to_save = 1;
 330
 331                 strcpy(termz, ar[i].prefix);
 332                 strcat(termz, wrbuf_buf(ar[i].term));
 333                 dict_scan(zh->reg->dict, termz, &before, &after,
 334                           ar+i, scan_handle2);
 335             }
 336         }
 337         /* get minimum after scan */
 338         for (i = 0; i < ord_no; i++)
 339         {
 340             if (ar[i].isam_p
 341                 && (lo == 0 || strcmp(wrbuf_buf(ar[i].term), lo) < 0))
 342                 lo = wrbuf_buf(ar[i].term);
 343         }
 344         if (!lo)
 345             break;
 346         if (scan_save_set(zh, stream, nmem, kc, zapt, limit_set, lo,
 347                           index_type, ar, ord_no, glist,
 348                           (pos >= 0 && pos < *num_entries) ? pos : -1))
 349             pos++;
 350
 351     }
 352     if (pos != *num_entries)
 353     {
 354         if (pos >= 0)
 355             *num_entries = pos;
 356         else
 357             *num_entries = 0;
 358         *is_partial = 1;
 359     }
 360
 361     *list = glist;
 362
 363     return ZEBRA_OK;
 364 }
 365
 366 struct scan1_info_entry {
 367     char *term;
 368     ISAM_P isam_p;
 369 };
 370
 371 struct scan_info {
 372     struct scan1_info_entry *list;
 373     ODR odr;
 374     int before, after;
 375     char prefix[20];
 376 };
 377
 378 static int scan_handle1(char *name, const char *info, int pos, void *client)
 379 {
 380     int len_prefix, idx;
 381     struct scan_info *scan_info = (struct scan_info *) client;
 382
 383     len_prefix = strlen(scan_info->prefix);
 384     if (memcmp (name, scan_info->prefix, len_prefix))
 385         return 1;
 386     if (pos > 0)
 387         idx = scan_info->after - pos + scan_info->before;
 388     else
 389         idx = - pos - 1;
 390
 391     /* skip special terms such as first-in-field specials */
 392     if (name[len_prefix] < CHR_BASE_CHAR)
 393         return 1;
 394
 395     if (idx < 0)
 396         return 0;
 397     scan_info->list[idx].term = (char *)
 398         odr_malloc(scan_info->odr, strlen(name + len_prefix)+1);
 399     strcpy(scan_info->list[idx].term, name + len_prefix);
 400     assert (*info == sizeof(ISAM_P));
 401     memcpy (&scan_info->list[idx].isam_p, info+1, sizeof(ISAM_P));
 402     return 0;
 403 }
 404
 405 static ZEBRA_RES rpn_scan_ver1(ZebraHandle zh, ODR stream, NMEM rset_nmem,
 406                                struct rset_key_control *kc,
 407                                Z_AttributesPlusTerm *zapt,
 408                                int *position, int *num_entries,
 409                                ZebraScanEntry **list,
 410                                int *is_partial, RSET limit_set,
 411                                int index_type, int ord_no, int *ords)
 412 {
 413     int pos = *position;
 414     int num = *num_entries;
 415     int before;
 416     int after;
 417     int i;
 418     struct scan_info *scan_info_array;
 419     char termz[IT_MAX_WORD+20];
 420     ZebraScanEntry *glist;
 421     int ptr[RPN_MAX_ORDS];
 422
 423     before = pos-1;
 424     if (before < 0)
 425         before = 0;
 426     after = 1+num-pos;
 427     if (after < 0)
 428         after = 0;
 429     yaz_log(YLOG_DEBUG, "rpn_scan pos=%d num=%d before=%d "
 430             "after=%d before+after=%d",
 431             pos, num, before, after, before+after);
 432     scan_info_array = (struct scan_info *)
 433         odr_malloc(stream, ord_no * sizeof(*scan_info_array));
 434     for (i = 0; i < ord_no; i++)
 435     {
 436         int j, prefix_len = 0;
 437         int before_tmp = before, after_tmp = after;
 438         struct scan_info *scan_info = scan_info_array + i;
 439         struct rpn_char_map_info rcmi;
 440
 441         rpn_char_map_prepare (zh->reg, index_type, &rcmi);
 442
 443         scan_info->before = before;
 444         scan_info->after = after;
 445         scan_info->odr = stream;
 446
 447         scan_info->list = (struct scan1_info_entry *)
 448             odr_malloc(stream, (before+after) * sizeof(*scan_info->list));
 449         for (j = 0; j<before+after; j++)
 450             scan_info->list[j].term = NULL;
 451
 452         prefix_len += key_SU_encode (ords[i], termz + prefix_len);
 453         termz[prefix_len] = 0;
 454         strcpy(scan_info->prefix, termz);
 455
 456         if (trans_scan_term(zh, zapt, termz+prefix_len, index_type) ==
 457             ZEBRA_FAIL)
 458             return ZEBRA_FAIL;
 459
 460         dict_scan(zh->reg->dict, termz, &before_tmp, &after_tmp,
 461                   scan_info, scan_handle1);
 462     }
 463     glist = (ZebraScanEntry *)
 464         odr_malloc(stream, (before+after)*sizeof(*glist));
 465
 466     /* consider terms after main term */
 467     for (i = 0; i < ord_no; i++)
 468         ptr[i] = before;
 469
 470     *is_partial = 0;
 471     for (i = 0; i<after; i++)
 472     {
 473         int j, j0 = -1;
 474         const char *mterm = NULL;
 475         const char *tst;
 476         RSET rset = 0;
 477         int lo = i + pos-1; /* offset in result list */
 478
 479         /* find: j0 is the first of the minimal values */
 480         for (j = 0; j < ord_no; j++)
 481         {
 482             if (ptr[j] < before+after && ptr[j] >= 0 &&
 483                 (tst = scan_info_array[j].list[ptr[j]].term) &&
 484                 (!mterm || strcmp (tst, mterm) < 0))
 485             {
 486                 j0 = j;
 487                 mterm = tst;
 488             }
 489         }
 490         if (j0 == -1)
 491             break;  /* no value found, stop */
 492
 493         /* get result set for first one , but only if it's within bounds */
 494         if (lo >= 0)
 495         {
 496             /* get result set for first term */
 497             zebra_term_untrans_iconv(zh, stream->mem, index_type,
 498                                      &glist[lo].term, mterm);
 499             rset = rset_trunc(zh, &scan_info_array[j0].list[ptr[j0]].isam_p, 1,
 500                               glist[lo].term, strlen(glist[lo].term),
 501                               NULL, 0, zapt->term->which, rset_nmem,
 502                               kc, kc->scope, 0, index_type, 0 /* hits_limit */,
 503                               0 /* term_ref_id_str */);
 504         }
 505         ptr[j0]++; /* move index for this set .. */
 506         /* get result set for remaining scan terms */
 507         for (j = j0+1; j<ord_no; j++)
 508         {
 509             if (ptr[j] < before+after && ptr[j] >= 0 &&
 510                 (tst = scan_info_array[j].list[ptr[j]].term) &&
 511                 !strcmp (tst, mterm))
 512             {
 513                 if (lo >= 0)
 514                 {
 515                     RSET rsets[2];
 516
 517                     rsets[0] = rset;
 518                     rsets[1] =
 519                         rset_trunc(
 520                             zh, &scan_info_array[j].list[ptr[j]].isam_p, 1,
 521                             glist[lo].term,
 522                             strlen(glist[lo].term), NULL, 0,
 523                             zapt->term->which,rset_nmem,
 524                             kc, kc->scope, 0, index_type, 0 /* hits_limit */,
 525                             0 /* term_ref_id_str */ );
 526                     rset = rset_create_or(rset_nmem, kc,
 527                                           kc->scope, 0 /* termid */,
 528                                           2, rsets);
 529                 }
 530                 ptr[j]++;
 531             }
 532         }
 533         if (lo >= 0)
 534         {
 535             zint count;
 536             /* merge with limit_set if given */
 537             if (limit_set)
 538             {
 539                 RSET rsets[2];
 540                 rsets[0] = rset;
 541                 rsets[1] = rset_dup(limit_set);
 542
 543                 rset = rset_create_and(rset_nmem, kc, kc->scope, 2, rsets);
 544             }
 545             /* count it */
 546             count_set(zh, rset, &count);
 547             glist[lo].occurrences = count;
 548             rset_delete(rset);
 549         }
 550     }
 551     if (i < after)
 552     {
 553         *num_entries -= (after-i);
 554         *is_partial = 1;
 555         if (*num_entries < 0)
 556         {
 557             *num_entries = 0;
 558             return ZEBRA_OK;
 559         }
 560     }
 561     /* consider terms before main term */
 562     for (i = 0; i<ord_no; i++)
 563         ptr[i] = 0;
 564
 565     for (i = 0; i<before; i++)
 566     {
 567         int j, j0 = -1;
 568         const char *mterm = NULL;
 569         const char *tst;
 570         RSET rset;
 571         int lo = before-1-i; /* offset in result list */
 572         zint count;
 573
 574         for (j = 0; j <ord_no; j++)
 575         {
 576             if (ptr[j] < before && ptr[j] >= 0 &&
 577                 (tst = scan_info_array[j].list[before-1-ptr[j]].term) &&
 578                 (!mterm || strcmp (tst, mterm) > 0))
 579             {
 580                 j0 = j;
 581                     mterm = tst;
 582             }
 583         }
 584         if (j0 == -1)
 585             break;
 586
 587         zebra_term_untrans_iconv(zh, stream->mem, index_type,
 588                                  &glist[lo].term, mterm);
 589
 590         rset = rset_trunc
 591             (zh, &scan_info_array[j0].list[before-1-ptr[j0]].isam_p, 1,
 592              glist[lo].term, strlen(glist[lo].term),
 593              NULL, 0, zapt->term->which, rset_nmem,
 594              kc, kc->scope, 0, index_type, 0 /* hits_limit */,
 595              0 /* term_ref_id_str */);
 596
 597         ptr[j0]++;
 598
 599         for (j = j0+1; j<ord_no; j++)
 600         {
 601             if (ptr[j] < before && ptr[j] >= 0 &&
 602                 (tst = scan_info_array[j].list[before-1-ptr[j]].term) &&
 603                 !strcmp (tst, mterm))
 604             {
 605                 RSET rsets[2];
 606
 607                 rsets[0] = rset;
 608                 rsets[1] = rset_trunc(
 609                     zh,
 610                     &scan_info_array[j].list[before-1-ptr[j]].isam_p, 1,
 611                     glist[lo].term,
 612                     strlen(glist[lo].term), NULL, 0,
 613                     zapt->term->which, rset_nmem,
 614                     kc, kc->scope, 0, index_type, 0 /* hits_limit */,
 615                     0 /* term_ref_id_str */);
 616                 rset = rset_create_or(rset_nmem, kc,
 617                                       kc->scope, 0 /* termid */, 2, rsets);
 618
 619                 ptr[j]++;
 620             }
 621         }
 622         if (limit_set)
 623         {
 624             RSET rsets[2];
 625             rsets[0] = rset;
 626             rsets[1] = rset_dup(limit_set);
 627
 628             rset = rset_create_and(rset_nmem, kc, kc->scope, 2, rsets);
 629         }
 630         count_set(zh, rset, &count);
 631         glist[lo].occurrences = count;
 632         rset_delete (rset);
 633     }
 634     i = before-i;
 635     if (i)
 636     {
 637         *is_partial = 1;
 638         *position -= i;
 639         *num_entries -= i;
 640         if (*num_entries <= 0)
 641         {
 642             *num_entries = 0;
 643             return ZEBRA_OK;
 644         }
 645     }
 646
 647     *list = glist + i;               /* list is set to first 'real' entry */
 648
 649     yaz_log(YLOG_DEBUG, "position = %d, num_entries = %d",
 650             *position, *num_entries);
 651     return ZEBRA_OK;
 652 }
 653
 654
 655 ZEBRA_RES rpn_scan(ZebraHandle zh, ODR stream, Z_AttributesPlusTerm *zapt,
 656                    oid_value attributeset,
 657                    int num_bases, char **basenames,
 658                    int *position, int *num_entries, ZebraScanEntry **list,
 659                    int *is_partial, RSET limit_set)
 660 {
 661     int base_no;
 662     int ords[RPN_MAX_ORDS], ord_no = 0;
 663
 664     unsigned index_type;
 665     char *search_type = NULL;
 666     char rank_type[128];
 667     int complete_flag;
 668     int sort_flag;
 669     NMEM nmem;
 670     ZEBRA_RES res;
 671     struct rset_key_control *kc = 0;
 672
 673     *list = 0;
 674     *is_partial = 0;
 675
 676     if (attributeset == VAL_NONE)
 677         attributeset = VAL_BIB1;
 678
 679     if (!limit_set) /* no limit set given already */
 680     {
 681         /* see if there is a @attr 8=set */
 682         AttrType termset;
 683         int termset_value_numeric;
 684         const char *termset_value_string;
 685         attr_init_APT(&termset, zapt, 8);
 686         termset_value_numeric =
 687             attr_find_ex(&termset, NULL, &termset_value_string);
 688         if (termset_value_numeric != -1)
 689         {
 690             char resname[32];
 691             const char *termset_name = 0;
 692
 693             if (termset_value_numeric != -2)
 694             {
 695
 696                 sprintf(resname, "%d", termset_value_numeric);
 697                 termset_name = resname;
 698             }
 699             else
 700                 termset_name = termset_value_string;
 701
 702             limit_set = resultSetRef (zh, termset_name);
 703         }
 704     }
 705
 706     yaz_log(YLOG_DEBUG, "position = %d, num = %d set=%d",
 707             *position, *num_entries, attributeset);
 708
 709     if (zebra_maps_attr(zh->reg->zebra_maps, zapt, &index_type, &search_type,
 710                         rank_type, &complete_flag, &sort_flag))
 711     {
 712         *num_entries = 0;
 713         zebra_setError(zh, YAZ_BIB1_UNSUPP_ATTRIBUTE_TYPE, 0);
 714         return ZEBRA_FAIL;
 715     }
 716     if (num_bases > RPN_MAX_ORDS)
 717     {
 718         zebra_setError(zh, YAZ_BIB1_TOO_MANY_DATABASES_SPECIFIED, 0);
 719         return ZEBRA_FAIL;
 720     }
 721
 722     for (base_no = 0; base_no < num_bases; base_no++)
 723     {
 724         int ord;
 725
 726         if (zebraExplain_curDatabase (zh->reg->zei, basenames[base_no]))
 727         {
 728             zebra_setError(zh, YAZ_BIB1_DATABASE_UNAVAILABLE,
 729                            basenames[base_no]);
 730             *num_entries = 0;
 731             return ZEBRA_FAIL;
 732         }
 733         if (zebra_apt_get_ord(zh, zapt, index_type, 0, attributeset, &ord)
 734             != ZEBRA_OK)
 735             continue;
 736         ords[ord_no++] = ord;
 737     }
 738     if (ord_no == 0)
 739     {
 740         *num_entries = 0; /* zebra_apt_get_ord should set error reason */
 741         return ZEBRA_FAIL;
 742     }
 743     if (*num_entries < 1)
 744     {
 745         *num_entries = 0;
 746         return ZEBRA_OK;
 747     }
 748     nmem = nmem_create();
 749     kc = zebra_key_control_create(zh);
 750
 751     res = rpn_scan_ver2(zh, stream, nmem, kc, zapt, position, num_entries,
 752                         list,
 753                         is_partial, limit_set, index_type, ord_no, ords);
 754     nmem_destroy(nmem);
 755     (*kc->dec)(kc);
 756     return res;
 757 }
 758
 759 /*
 760  * Local variables:
 761  * c-basic-offset: 4
 762  * indent-tabs-mode: nil
 763  * End:
 764  * vim: shiftwidth=4 tabstop=8 expandtab
 765  */
 766