index/zsets.c

   1 /* $Id: zsets.c,v 1.89 2005-06-09 10:39:53 adam Exp $
   2    Copyright (C) 1995-2005
   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 Zebra; see the file LICENSE.zebra.  If not, write to the
  19 Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.
  21 */
  22
  23
  24 #include <stdio.h>
  25 #include <assert.h>
  26 #ifdef WIN32
  27 #include <io.h>
  28 #else
  29 #include <unistd.h>
  30 #endif
  31
  32 #include "index.h"
  33 #include <yaz/diagbib1.h>
  34 #include <rset.h>
  35
  36 #define SORT_IDX_ENTRYSIZE 64
  37 #define ZSET_SORT_MAX_LEVEL 3
  38
  39 struct zebra_set_term_entry {
  40     int reg_type;
  41     char *db;
  42     int set;
  43     int use;
  44     char *term;
  45 };
  46
  47 struct zebra_set {
  48     char *name;
  49     RSET rset;
  50     NMEM nmem;
  51     NMEM rset_nmem; /* for creating the rsets in */
  52     zint hits;
  53     int num_bases;
  54     char **basenames;
  55     Z_RPNQuery *rpn;
  56     struct zset_sort_info *sort_info;
  57     struct zebra_set_term_entry *term_entries;
  58     int term_entries_max;
  59     struct zebra_set *next;
  60     int locked;
  61
  62     zint cache_position;  /* last position */
  63     RSFD cache_rfd;       /* rfd (NULL if not existing) */
  64     zint cache_psysno;    /* sysno for last position */
  65     zint approx_limit;    /* limit before we do approx */
  66 };
  67
  68 struct zset_sort_entry {
  69     zint sysno;
  70     int score;
  71     char buf[ZSET_SORT_MAX_LEVEL][SORT_IDX_ENTRYSIZE];
  72 };
  73
  74 struct zset_sort_info {
  75     int max_entries;
  76     int num_entries;
  77     struct zset_sort_entry *all_entries;
  78     struct zset_sort_entry **entries;
  79 };
  80
  81 static int log_level_set=0;
  82 static int log_level_sort=0;
  83 static int log_level_searchhits=0;
  84 static int log_level_searchterms=0;
  85 static int log_level_resultsets=0;
  86
  87 static void loglevels()
  88 {
  89     if (log_level_set)
  90         return;
  91     log_level_sort = yaz_log_module_level("sorting");
  92     log_level_searchhits = yaz_log_module_level("searchhits");
  93     log_level_searchterms = yaz_log_module_level("searchterms");
  94     log_level_resultsets = yaz_log_module_level("resultsets");
  95     log_level_set = 1;
  96 }
  97
  98 ZEBRA_RES resultSetSearch(ZebraHandle zh, NMEM nmem, NMEM rset_nmem,
  99                           Z_RPNQuery *rpn, ZebraSet sset)
 100 {
 101     RSET rset = 0;
 102     oident *attrset;
 103     Z_SortKeySpecList *sort_sequence;
 104     int sort_status, i;
 105     ZEBRA_RES res = ZEBRA_OK;
 106
 107     zh->hits = 0;
 108
 109     sort_sequence = (Z_SortKeySpecList *)
 110         nmem_malloc(nmem, sizeof(*sort_sequence));
 111     sort_sequence->num_specs = 10; /* FIXME - Hard-coded number */
 112     sort_sequence->specs = (Z_SortKeySpec **)
 113         nmem_malloc(nmem, sort_sequence->num_specs *
 114                      sizeof(*sort_sequence->specs));
 115     for (i = 0; i<sort_sequence->num_specs; i++)
 116         sort_sequence->specs[i] = 0;
 117
 118     attrset = oid_getentbyoid (rpn->attributeSetId);
 119     res = rpn_search_top(zh, rpn->RPNStructure, attrset->value,
 120                          nmem, rset_nmem,
 121                          sort_sequence,
 122                          sset->num_bases, sset->basenames,
 123                          &rset);
 124     if (res != ZEBRA_OK)
 125     {
 126         sset->rset = 0;
 127         return res;
 128     }
 129     for (i = 0; sort_sequence->specs[i]; i++)
 130         ;
 131     sort_sequence->num_specs = i;
 132     rset->hits_limit = sset->approx_limit;
 133     if (!i)
 134     {
 135         res = resultSetRank (zh, sset, rset, rset_nmem);
 136     }
 137     else
 138     {
 139         res = resultSetSortSingle (zh, nmem, sset, rset,
 140                                    sort_sequence, &sort_status);
 141     }
 142     sset->rset = rset;
 143     return res;
 144 }
 145
 146
 147 ZEBRA_RES resultSetAddRPN (ZebraHandle zh, NMEM m, Z_RPNQuery *rpn,
 148                            int num_bases, char **basenames,
 149                            const char *setname)
 150 {
 151     ZebraSet zebraSet;
 152     int i;
 153     ZEBRA_RES res;
 154
 155     zh->hits = 0;
 156
 157     zebraSet = resultSetAdd(zh, setname, 1);
 158     if (!zebraSet)
 159         return ZEBRA_FAIL;
 160     zebraSet->locked = 1;
 161     zebraSet->rpn = 0;
 162     zebraSet->nmem = m;
 163     zebraSet->rset_nmem = nmem_create();
 164
 165     zebraSet->num_bases = num_bases;
 166     zebraSet->basenames =
 167         nmem_malloc (zebraSet->nmem, num_bases * sizeof(*zebraSet->basenames));
 168     for (i = 0; i<num_bases; i++)
 169         zebraSet->basenames[i] = nmem_strdup(zebraSet->nmem, basenames[i]);
 170
 171     res = resultSetSearch(zh, zebraSet->nmem, zebraSet->rset_nmem,
 172                           rpn, zebraSet);
 173     zh->hits = zebraSet->hits;
 174     if (zebraSet->rset)
 175         zebraSet->rpn = rpn;
 176     zebraSet->locked = 0;
 177     if (!zebraSet->rset)
 178         return ZEBRA_FAIL;
 179     return res;
 180 }
 181
 182 void resultSetAddTerm (ZebraHandle zh, ZebraSet s, int reg_type,
 183                        const char *db, int set,
 184                        int use, const char *term)
 185 {
 186     assert(zh); /* compiler shut up */
 187     if (!s->nmem)
 188         s->nmem = nmem_create ();
 189     if (!s->term_entries)
 190     {
 191         int i;
 192         s->term_entries_max = 1000;
 193         s->term_entries =
 194             nmem_malloc (s->nmem, s->term_entries_max *
 195                          sizeof(*s->term_entries));
 196         for (i = 0; i < s->term_entries_max; i++)
 197             s->term_entries[i].term = 0;
 198     }
 199     if (s->hits < s->term_entries_max)
 200     {
 201         s->term_entries[s->hits].reg_type = reg_type;
 202         s->term_entries[s->hits].db = nmem_strdup (s->nmem, db);
 203         s->term_entries[s->hits].set = set;
 204         s->term_entries[s->hits].use = use;
 205         s->term_entries[s->hits].term = nmem_strdup (s->nmem, term);
 206     }
 207     (s->hits)++;
 208 }
 209
 210 ZebraSet resultSetAdd(ZebraHandle zh, const char *name, int ov)
 211 {
 212     ZebraSet s;
 213     int i;
 214
 215     for (s = zh->sets; s; s = s->next)
 216         if (!strcmp (s->name, name))
 217             break;
 218
 219     if (!log_level_set)
 220         loglevels();
 221     if (s)
 222     {
 223         yaz_log(log_level_resultsets, "updating result set %s", name);
 224         if (!ov || s->locked)
 225             return NULL;
 226         if (s->rset)
 227         {
 228             if (s->cache_rfd)
 229                 rset_close(s->cache_rfd);
 230             rset_delete (s->rset);
 231         }
 232         if (s->rset_nmem)
 233             nmem_destroy (s->rset_nmem);
 234         if (s->nmem)
 235             nmem_destroy (s->nmem);
 236     }
 237     else
 238     {
 239         const char *sort_max_str = zebra_get_resource(zh, "sortmax", "1000");
 240
 241         yaz_log(log_level_resultsets, "adding result set %s", name);
 242         s = (ZebraSet) xmalloc (sizeof(*s));
 243         s->next = zh->sets;
 244         zh->sets = s;
 245         s->name = (char *) xmalloc (strlen(name)+1);
 246         strcpy (s->name, name);
 247
 248         s->sort_info = (struct zset_sort_info *)
 249             xmalloc (sizeof(*s->sort_info));
 250         s->sort_info->max_entries = atoi(sort_max_str);
 251         if (s->sort_info->max_entries < 2)
 252             s->sort_info->max_entries = 2;
 253
 254         s->sort_info->entries = (struct zset_sort_entry **)
 255             xmalloc (sizeof(*s->sort_info->entries) *
 256                      s->sort_info->max_entries);
 257         s->sort_info->all_entries = (struct zset_sort_entry *)
 258             xmalloc (sizeof(*s->sort_info->all_entries) *
 259                      s->sort_info->max_entries);
 260         for (i = 0; i < s->sort_info->max_entries; i++)
 261             s->sort_info->entries[i] = s->sort_info->all_entries + i;
 262     }
 263     s->locked = 0;
 264     s->term_entries = 0;
 265     s->hits = 0;
 266     s->rset = 0;
 267     s->rset_nmem = 0;
 268     s->nmem = 0;
 269     s->rpn = 0;
 270     s->cache_position = 0;
 271     s->cache_rfd = 0;
 272     s->approx_limit = zh->approx_limit;
 273     return s;
 274 }
 275
 276 ZebraSet resultSetGet(ZebraHandle zh, const char *name)
 277 {
 278     ZebraSet s;
 279
 280     for (s = zh->sets; s; s = s->next)
 281         if (!strcmp (s->name, name))
 282         {
 283             if (!s->term_entries && !s->rset && s->rpn)
 284             {
 285                 NMEM nmem = nmem_create ();
 286                 yaz_log(log_level_resultsets, "research %s", name);
 287                 if (!s->rset_nmem)
 288                     s->rset_nmem=nmem_create();
 289                 resultSetSearch(zh, nmem, s->rset_nmem, s->rpn, s);
 290                 nmem_destroy (nmem);
 291             }
 292             return s;
 293         }
 294     return NULL;
 295 }
 296
 297 void resultSetInvalidate (ZebraHandle zh)
 298 {
 299     ZebraSet s = zh->sets;
 300
 301     yaz_log(log_level_resultsets, "invalidating result sets");
 302     for (; s; s = s->next)
 303     {
 304         if (s->rset)
 305         {
 306             if (s->cache_rfd)
 307                 rset_close(s->cache_rfd);
 308             rset_delete (s->rset);
 309         }
 310         s->rset = 0;
 311         s->cache_rfd = 0;
 312         s->cache_position = 0;
 313         if (s->rset_nmem)
 314             nmem_destroy(s->rset_nmem);
 315         s->rset_nmem=0;
 316     }
 317 }
 318
 319 void resultSetDestroy(ZebraHandle zh, int num, char **names,int *statuses)
 320 {
 321     ZebraSet * ss = &zh->sets;
 322     int i;
 323
 324     if (statuses)
 325         for (i = 0; i<num; i++)
 326             statuses[i] = Z_DeleteStatus_resultSetDidNotExist;
 327     while (*ss)
 328     {
 329         int i = -1;
 330         ZebraSet s = *ss;
 331         if (num >= 0)
 332         {
 333             for (i = 0; i<num; i++)
 334                 if (!strcmp (s->name, names[i]))
 335                 {
 336                     if (statuses)
 337                         statuses[i] = Z_DeleteStatus_success;
 338                     i = -1;
 339                     break;
 340                 }
 341         }
 342         if (i < 0)
 343         {
 344             *ss = s->next;
 345
 346             xfree (s->sort_info->all_entries);
 347             xfree (s->sort_info->entries);
 348             xfree (s->sort_info);
 349
 350             if (s->nmem)
 351                 nmem_destroy (s->nmem);
 352             if (s->rset)
 353             {
 354                 if (s->cache_rfd)
 355                     rset_close(s->cache_rfd);
 356                 rset_delete (s->rset);
 357             }
 358             if (s->rset_nmem)
 359                 nmem_destroy(s->rset_nmem);
 360             xfree (s->name);
 361             xfree (s);
 362         }
 363         else
 364             ss = &s->next;
 365     }
 366 }
 367
 368 ZebraMetaRecord *zebra_meta_records_create_range(ZebraHandle zh,
 369                                                  const char *name,
 370                                                  zint start, int num)
 371 {
 372     zint pos_small[10];
 373     zint *pos = pos_small;
 374     ZebraMetaRecord *mr;
 375     int i;
 376
 377     if (num > 10000 || num <= 0)
 378         return 0;
 379
 380     if (num > 10)
 381         pos = xmalloc(sizeof(*pos) * num);
 382
 383     for (i = 0; i<num; i++)
 384         pos[i] = start+i;
 385
 386     mr = zebra_meta_records_create(zh, name, num, pos);
 387
 388     if (num > 10)
 389         xfree(pos);
 390     return mr;
 391 }
 392
 393 ZebraMetaRecord *zebra_meta_records_create(ZebraHandle zh, const char *name,
 394                                            int num, zint *positions)
 395 {
 396     ZebraSet sset;
 397     ZebraMetaRecord *sr = 0;
 398     RSET rset;
 399     int i;
 400     struct zset_sort_info *sort_info;
 401
 402     if (!log_level_set)
 403         loglevels();
 404     if (!(sset = resultSetGet (zh, name)))
 405         return NULL;
 406     if (!(rset = sset->rset))
 407     {
 408         if (!sset->term_entries)
 409             return 0;
 410         sr = (ZebraMetaRecord *) xmalloc (sizeof(*sr) * num);
 411         for (i = 0; i<num; i++)
 412         {
 413             sr[i].sysno = 0;
 414             sr[i].score = -1;
 415             sr[i].term = 0;
 416             sr[i].db = 0;
 417
 418             if (positions[i] <= sset->term_entries_max)
 419             {
 420                 sr[i].term = sset->term_entries[positions[i]-1].term;
 421                 sr[i].db = sset->term_entries[positions[i]-1].db;
 422             }
 423         }
 424     }
 425     else
 426     {
 427         sr = (ZebraMetaRecord *) xmalloc (sizeof(*sr) * num);
 428         for (i = 0; i<num; i++)
 429         {
 430             sr[i].sysno = 0;
 431             sr[i].score = -1;
 432             sr[i].term = 0;
 433             sr[i].db = 0;
 434         }
 435         sort_info = sset->sort_info;
 436         if (sort_info)
 437         {
 438             zint position;
 439
 440             for (i = 0; i<num; i++)
 441             {
 442                 position = positions[i];
 443                 if (position > 0 && position <= sort_info->num_entries)
 444                 {
 445                     yaz_log(log_level_sort, "got pos=" ZINT_FORMAT
 446                             " (sorted)", position);
 447                     sr[i].sysno = sort_info->entries[position-1]->sysno;
 448                     sr[i].score = sort_info->entries[position-1]->score;
 449                 }
 450             }
 451         }
 452         /* did we really get all entries using sort ? */
 453         for (i = 0; i<num; i++)
 454         {
 455             if (!sr[i].sysno)
 456                 break;
 457         }
 458         if (i < num) /* nope, get the rest, unsorted - sorry */
 459         {
 460             zint position = 0;
 461             int num_i = 0;
 462             zint psysno = 0;
 463             RSFD rfd;
 464             struct it_key key;
 465
 466             if (sort_info)
 467                 position = sort_info->num_entries;
 468             while (num_i < num && positions[num_i] <= position)
 469                 num_i++;
 470
 471             if (sset->cache_rfd &&
 472                 num_i < num && positions[num_i] > sset->cache_position)
 473             {
 474                 position = sset->cache_position;
 475                 rfd = sset->cache_rfd;
 476                 psysno = sset->cache_psysno;
 477             }
 478             else
 479             {
 480                 if (sset->cache_rfd)
 481                     rset_close(sset->cache_rfd);
 482                 rfd = rset_open (rset, RSETF_READ);
 483             }
 484             while (num_i < num && rset_read (rfd, &key, 0))
 485             {
 486                 zint this_sys = key.mem[0];
 487                 if (this_sys != psysno)
 488                 {
 489                     psysno = this_sys;
 490                     if (sort_info)
 491                     {
 492                         /* determine we alreay have this in our set */
 493                         for (i = sort_info->num_entries; --i >= 0; )
 494                             if (psysno == sort_info->entries[i]->sysno)
 495                                 break;
 496                         if (i >= 0)
 497                             continue;
 498                     }
 499                     position++;
 500                     assert (num_i < num);
 501                     if (position == positions[num_i])
 502                     {
 503                         sr[num_i].sysno = psysno;
 504                         yaz_log(log_level_sort, "got pos=" ZINT_FORMAT " (unsorted)", position);
 505                         sr[num_i].score = -1;
 506                         num_i++;
 507                     }
 508                 }
 509             }
 510             sset->cache_position = position;
 511             sset->cache_psysno = psysno;
 512             sset->cache_rfd = rfd;
 513         }
 514     }
 515     return sr;
 516 }
 517
 518 void zebra_meta_records_destroy (ZebraHandle zh, ZebraMetaRecord *records,
 519                                  int num)
 520 {
 521     assert(zh); /* compiler shut up about unused arg */
 522     xfree (records);
 523 }
 524
 525 struct sortKeyInfo {
 526     int relation;
 527     int attrUse;
 528     int numerical;
 529 };
 530
 531 void resultSetInsertSort (ZebraHandle zh, ZebraSet sset,
 532                           struct sortKeyInfo *criteria, int num_criteria,
 533                           zint sysno)
 534 {
 535     struct zset_sort_entry this_entry;
 536     struct zset_sort_entry *new_entry = NULL;
 537     struct zset_sort_info *sort_info = sset->sort_info;
 538     int i, j;
 539
 540     sortIdx_sysno (zh->reg->sortIdx, sysno);
 541     for (i = 0; i<num_criteria; i++)
 542     {
 543         sortIdx_type (zh->reg->sortIdx, criteria[i].attrUse);
 544         sortIdx_read (zh->reg->sortIdx, this_entry.buf[i]);
 545     }
 546     i = sort_info->num_entries;
 547     while (--i >= 0)
 548     {
 549         int rel = 0;
 550         for (j = 0; j<num_criteria; j++)
 551         {
 552             if (criteria[j].numerical)
 553             {
 554                 double diff = atof(this_entry.buf[j]) -
 555                               atof(sort_info->entries[i]->buf[j]);
 556                 rel = 0;
 557                 if (diff > 0.0)
 558                     rel = 1;
 559                 else if (diff < 0.0)
 560                     rel = -1;
 561             }
 562             else
 563             {
 564                 rel = memcmp (this_entry.buf[j], sort_info->entries[i]->buf[j],
 565                           SORT_IDX_ENTRYSIZE);
 566             }
 567             if (rel)
 568                 break;
 569         }
 570         if (!rel)
 571             break;
 572         if (criteria[j].relation == 'A')
 573         {
 574             if (rel > 0)
 575                 break;
 576         }
 577         else if (criteria[j].relation == 'D')
 578         {
 579             if (rel < 0)
 580                 break;
 581         }
 582     }
 583     ++i;
 584     j = sort_info->max_entries;
 585     if (i == j)
 586         return;
 587
 588     if (sort_info->num_entries == j)
 589         --j;
 590     else
 591         j = (sort_info->num_entries)++;
 592     new_entry = sort_info->entries[j];
 593     while (j != i)
 594     {
 595         sort_info->entries[j] = sort_info->entries[j-1];
 596         --j;
 597     }
 598     sort_info->entries[i] = new_entry;
 599     assert (new_entry);
 600     for (i = 0; i<num_criteria; i++)
 601         memcpy (new_entry->buf[i], this_entry.buf[i], SORT_IDX_ENTRYSIZE);
 602     new_entry->sysno = sysno;
 603     new_entry->score = -1;
 604 }
 605
 606 void resultSetInsertRank (ZebraHandle zh, struct zset_sort_info *sort_info,
 607                           zint sysno, int score, int relation)
 608 {
 609     struct zset_sort_entry *new_entry = NULL;
 610     int i, j;
 611     assert(zh); /* compiler shut up about unused arg */
 612
 613     i = sort_info->num_entries;
 614     while (--i >= 0)
 615     {
 616         int rel = 0;
 617
 618         rel = score - sort_info->entries[i]->score;
 619
 620         if (relation == 'D')
 621         {
 622             if (rel >= 0)
 623                 break;
 624         }
 625         else if (relation == 'A')
 626         {
 627             if (rel <= 0)
 628                 break;
 629         }
 630     }
 631     ++i;
 632     j = sort_info->max_entries;
 633     if (i == j)
 634         return;
 635
 636     if (sort_info->num_entries == j)
 637         --j;
 638     else
 639         j = (sort_info->num_entries)++;
 640
 641     new_entry = sort_info->entries[j];
 642     while (j != i)
 643     {
 644         sort_info->entries[j] = sort_info->entries[j-1];
 645         --j;
 646     }
 647     sort_info->entries[i] = new_entry;
 648     assert (new_entry);
 649     new_entry->sysno = sysno;
 650     new_entry->score = score;
 651 }
 652
 653 ZEBRA_RES resultSetSort(ZebraHandle zh, NMEM nmem,
 654                         int num_input_setnames, const char **input_setnames,
 655                         const char *output_setname,
 656                         Z_SortKeySpecList *sort_sequence, int *sort_status)
 657 {
 658     ZebraSet sset;
 659     RSET rset;
 660
 661     if (num_input_setnames == 0)
 662     {
 663         zebra_setError(zh, YAZ_BIB1_NO_RESULT_SET_NAME_SUPPLIED_ON_SORT, 0);
 664         return ZEBRA_FAIL;
 665     }
 666     if (num_input_setnames > 1)
 667     {
 668         zebra_setError(zh, YAZ_BIB1_SORT_TOO_MANY_INPUT_RESULTS, 0);
 669         return ZEBRA_FAIL;
 670     }
 671     if (!log_level_set)
 672         loglevels();
 673     yaz_log(log_level_sort, "result set sort input=%s output=%s",
 674           *input_setnames, output_setname);
 675     sset = resultSetGet (zh, input_setnames[0]);
 676     if (!sset)
 677     {
 678         zebra_setError(zh, YAZ_BIB1_SPECIFIED_RESULT_SET_DOES_NOT_EXIST,
 679                        input_setnames[0]);
 680         return ZEBRA_FAIL;
 681     }
 682     if (!(rset = sset->rset))
 683     {
 684         zebra_setError(zh, YAZ_BIB1_SPECIFIED_RESULT_SET_DOES_NOT_EXIST,
 685                        input_setnames[0]);
 686         return ZEBRA_FAIL;
 687     }
 688     if (strcmp (output_setname, input_setnames[0]))
 689     {
 690         rset = rset_dup (rset);
 691         sset = resultSetAdd (zh, output_setname, 1);
 692         sset->rset = rset;
 693     }
 694     return resultSetSortSingle (zh, nmem, sset, rset, sort_sequence,
 695                                 sort_status);
 696 }
 697
 698 ZEBRA_RES resultSetSortSingle(ZebraHandle zh, NMEM nmem,
 699                               ZebraSet sset, RSET rset,
 700                               Z_SortKeySpecList *sort_sequence,
 701                               int *sort_status)
 702 {
 703     int i;
 704     int n = 0;
 705     zint kno = 0;
 706     zint psysno = 0;
 707     struct it_key key;
 708     struct sortKeyInfo sort_criteria[3];
 709     int num_criteria;
 710     RSFD rfd;
 711     TERMID termid;
 712     TERMID *terms;
 713     int numTerms = 0;
 714
 715     assert(nmem); /* compiler shut up about unused param */
 716     sset->sort_info->num_entries = 0;
 717
 718     rset_getterms(rset, 0, 0, &n);
 719     terms = (TERMID *) nmem_malloc(nmem, sizeof(*terms)*n);
 720     rset_getterms(rset, terms, n, &numTerms);
 721
 722     sset->hits = 0;
 723     num_criteria = sort_sequence->num_specs;
 724     if (num_criteria > 3)
 725         num_criteria = 3;
 726     for (i = 0; i < num_criteria; i++)
 727     {
 728         Z_SortKeySpec *sks = sort_sequence->specs[i];
 729         Z_SortKey *sk;
 730
 731         if (*sks->sortRelation == Z_SortKeySpec_ascending)
 732             sort_criteria[i].relation = 'A';
 733         else if (*sks->sortRelation == Z_SortKeySpec_descending)
 734             sort_criteria[i].relation = 'D';
 735         else
 736         {
 737             zebra_setError(zh, YAZ_BIB1_ILLEGAL_SORT_RELATION, 0);
 738             return ZEBRA_FAIL;
 739         }
 740         if (sks->sortElement->which == Z_SortElement_databaseSpecific)
 741         {
 742             zebra_setError(zh, YAZ_BIB1_DATABASE_SPECIFIC_SORT_UNSUPP, 0);
 743             return ZEBRA_FAIL;
 744         }
 745         else if (sks->sortElement->which != Z_SortElement_generic)
 746         {
 747             zebra_setError(zh, YAZ_BIB1_SORT_ILLEGAL_SORT, 0);
 748             return ZEBRA_FAIL;
 749         }
 750         sk = sks->sortElement->u.generic;
 751         switch (sk->which)
 752         {
 753         case Z_SortKey_sortField:
 754             yaz_log(log_level_sort, "key %d is of type sortField",
 755                     i+1);
 756             zebra_setError(zh, YAZ_BIB1_CANNOT_SORT_ACCORDING_TO_SEQUENCE, 0);
 757             return ZEBRA_FAIL;
 758         case Z_SortKey_elementSpec:
 759             yaz_log(log_level_sort, "key %d is of type elementSpec",
 760                     i+1);
 761             zebra_setError(zh, YAZ_BIB1_CANNOT_SORT_ACCORDING_TO_SEQUENCE, 0);
 762             return ZEBRA_FAIL;
 763         case Z_SortKey_sortAttributes:
 764             yaz_log(log_level_sort, "key %d is of type sortAttributes", i+1);
 765             sort_criteria[i].attrUse =
 766                 zebra_maps_sort (zh->reg->zebra_maps,
 767                                  sk->u.sortAttributes,
 768                                  &sort_criteria[i].numerical);
 769             yaz_log(log_level_sort, "use value = %d", sort_criteria[i].attrUse);
 770             if (sort_criteria[i].attrUse == -1)
 771             {
 772                 zebra_setError(
 773                     zh, YAZ_BIB1_USE_ATTRIBUTE_REQUIRED_BUT_NOT_SUPPLIED, 0);
 774                 return ZEBRA_FAIL;
 775             }
 776             if (sortIdx_type (zh->reg->sortIdx, sort_criteria[i].attrUse))
 777             {
 778                 zebra_setError(
 779                     zh, YAZ_BIB1_CANNOT_SORT_ACCORDING_TO_SEQUENCE, 0);
 780                 return ZEBRA_FAIL;
 781             }
 782             break;
 783         }
 784     }
 785     rfd = rset_open (rset, RSETF_READ);
 786     while (rset_read (rfd, &key, &termid))
 787     {
 788         zint this_sys = key.mem[0];
 789         if (log_level_searchhits)
 790             key_logdump_txt(log_level_searchhits, &key, termid->name);
 791         kno++;
 792         if (this_sys != psysno)
 793         {
 794             (sset->hits)++;
 795             psysno = this_sys;
 796             resultSetInsertSort (zh, sset,
 797                                  sort_criteria, num_criteria, psysno);
 798         }
 799     }
 800     rset_close (rfd);
 801     yaz_log(log_level_sort, ZINT_FORMAT " keys, " ZINT_FORMAT " sysnos, sort",
 802             kno, sset->hits);
 803     for (i = 0; i < numTerms; i++)
 804         yaz_log(log_level_sort, "term=\"%s\" type=%s count=" ZINT_FORMAT,
 805                  terms[i]->name, terms[i]->flags, terms[i]->rset->hits_count);
 806     *sort_status = Z_SortResponse_success;
 807     return ZEBRA_OK;
 808 }
 809
 810 RSET resultSetRef(ZebraHandle zh, const char *resultSetId)
 811 {
 812     ZebraSet s;
 813
 814     if ((s = resultSetGet (zh, resultSetId)))
 815         return s->rset;
 816     return NULL;
 817 }
 818
 819 ZEBRA_RES resultSetRank(ZebraHandle zh, ZebraSet zebraSet,
 820                         RSET rset, NMEM nmem)
 821 {
 822     struct it_key key;
 823     TERMID termid;
 824     TERMID *terms;
 825     zint kno = 0;
 826     int numTerms = 0;
 827     int n = 0;
 828     int i;
 829     ZebraRankClass rank_class;
 830     struct zset_sort_info *sort_info;
 831     const char *rank_handler_name = res_get_def(zh->res, "rank", "rank-1");
 832
 833     if (!log_level_set)
 834         loglevels();
 835     sort_info = zebraSet->sort_info;
 836     sort_info->num_entries = 0;
 837     zebraSet->hits = 0;
 838     rset_getterms(rset, 0, 0, &n);
 839     terms = (TERMID *) nmem_malloc(nmem, sizeof(*terms)*n);
 840     rset_getterms(rset, terms, n, &numTerms);
 841
 842     rank_class = zebraRankLookup(zh, rank_handler_name);
 843     if (!rank_class)
 844     {
 845         yaz_log(YLOG_WARN, "No such rank handler: %s", rank_handler_name);
 846         zebra_setError(zh, YAZ_BIB1_UNSUPP_SEARCH, "Cannot find rank handler");
 847         return ZEBRA_FAIL;
 848     }
 849     else
 850     {
 851         RSFD rfd = rset_open(rset, RSETF_READ);
 852         struct rank_control *rc = rank_class->control;
 853         double score;
 854         zint count = 0;
 855
 856         void *handle =
 857             (*rc->begin) (zh->reg, rank_class->class_handle, rset, nmem,
 858                           terms, numTerms);
 859         zint psysno = 0;
 860         while (rset_read(rfd, &key, &termid))
 861         {
 862             zint this_sys = key.mem[0];
 863             zint seqno = key.mem[key.len-1];
 864             kno++;
 865             if (log_level_searchhits)
 866                 key_logdump_txt(log_level_searchhits, &key, termid->name);
 867             if (this_sys != psysno)
 868             {
 869                 if (rfd->counted_items >= rset->hits_limit)
 870                     break;
 871                 if (psysno)
 872                 {
 873                     score = (*rc->calc) (handle, psysno);
 874                     resultSetInsertRank (zh, sort_info, psysno, score, 'A');
 875                     count++;
 876                 }
 877                 psysno = this_sys;
 878             }
 879             (*rc->add) (handle, CAST_ZINT_TO_INT(seqno), termid);
 880         }
 881         if (psysno)
 882         {
 883             score = (*rc->calc)(handle, psysno);
 884             resultSetInsertRank(zh, sort_info, psysno, score, 'A');
 885             count++;
 886         }
 887         (*rc->end) (zh->reg, handle);
 888         rset_close (rfd);
 889     }
 890     zebraSet->hits = rset->hits_count;
 891
 892     yaz_log(log_level_searchterms, ZINT_FORMAT " keys, "
 893             ZINT_FORMAT " sysnos, rank",  kno, zebraSet->hits);
 894     for (i = 0; i < numTerms; i++)
 895     {
 896         yaz_log(log_level_searchterms, "term=\"%s\" type=%s count="
 897                 ZINT_FORMAT,
 898                 terms[i]->name, terms[i]->flags, terms[i]->rset->hits_count);
 899     }
 900     return ZEBRA_OK;
 901 }
 902
 903 ZebraRankClass zebraRankLookup(ZebraHandle zh, const char *name)
 904 {
 905     ZebraRankClass p = zh->reg->rank_classes;
 906     while (p && strcmp (p->control->name, name))
 907         p = p->next;
 908     if (p && !p->init_flag)
 909     {
 910         if (p->control->create)
 911             p->class_handle = (*p->control->create)(zh);
 912         p->init_flag = 1;
 913     }
 914     return p;
 915 }
 916
 917 void zebraRankInstall(struct zebra_register *reg, struct rank_control *ctrl)
 918 {
 919     ZebraRankClass p = (ZebraRankClass) xmalloc (sizeof(*p));
 920     p->control = (struct rank_control *) xmalloc (sizeof(*p->control));
 921     memcpy (p->control, ctrl, sizeof(*p->control));
 922     p->control->name = xstrdup (ctrl->name);
 923     p->init_flag = 0;
 924     p->next = reg->rank_classes;
 925     reg->rank_classes = p;
 926 }
 927
 928 void zebraRankDestroy(struct zebra_register *reg)
 929 {
 930     ZebraRankClass p = reg->rank_classes;
 931     while (p)
 932     {
 933         ZebraRankClass p_next = p->next;
 934         if (p->init_flag && p->control->destroy)
 935             (*p->control->destroy)(reg, p->class_handle);
 936         xfree(p->control->name);
 937         xfree(p->control);
 938         xfree(p);
 939         p = p_next;
 940     }
 941     reg->rank_classes = NULL;
 942 }
 943
 944 static int trav_rset_for_termids(RSET rset, TERMID *termid_array,
 945                                  zint *hits_array, int *approx_array)
 946 {
 947     int no = 0;
 948     int i;
 949     for (i = 0; i<rset->no_children; i++)
 950         no += trav_rset_for_termids(rset->children[i],
 951                                     (termid_array ? termid_array + no : 0),
 952                                     (hits_array ? hits_array + no : 0),
 953                                     (approx_array ? approx_array + no : 0));
 954     if (rset->term)
 955     {
 956         if (termid_array)
 957             termid_array[no] = rset->term;
 958         if (hits_array)
 959             hits_array[no] = rset->hits_count;
 960         if (approx_array)
 961             approx_array[no] = rset->hits_approx;
 962 #if 0
 963         yaz_log(YLOG_LOG, "rset=%p term=%s count=" ZINT_FORMAT,
 964                 rset, rset->term->name, rset->hits_count);
 965 #endif
 966         no++;
 967     }
 968     return no;
 969 }
 970
 971 ZEBRA_RES zebra_result_set_term_no(ZebraHandle zh, const char *setname,
 972                                    int *num_terms)
 973 {
 974     ZebraSet sset = resultSetGet(zh, setname);
 975     *num_terms = 0;
 976     if (sset)
 977     {
 978         *num_terms = trav_rset_for_termids(sset->rset, 0, 0, 0);
 979         return ZEBRA_OK;
 980     }
 981     return ZEBRA_FAIL;
 982 }
 983
 984 ZEBRA_RES zebra_result_set_term_info(ZebraHandle zh, const char *setname,
 985                                      int no, zint *count, int *approx,
 986                                      char *termbuf, size_t *termlen)
 987 {
 988     ZebraSet sset = resultSetGet(zh, setname);
 989     if (sset)
 990     {
 991         int num_terms = trav_rset_for_termids(sset->rset, 0, 0, 0);
 992         if (no >= 0 && no < num_terms)
 993         {
 994             TERMID *term_array = xmalloc(num_terms * sizeof(*term_array));
 995             zint *hits_array = xmalloc(num_terms * sizeof(*hits_array));
 996             int *approx_array = xmalloc(num_terms * sizeof(*approx_array));
 997
 998             trav_rset_for_termids(sset->rset, term_array,
 999                                   hits_array, approx_array);
1000
1001             if (count)
1002                 *count = hits_array[no];
1003             if (approx)
1004                 *approx = approx_array[no];
1005             if (termbuf)
1006             {
1007                 char *inbuf = term_array[no]->name;
1008                 size_t inleft = strlen(inbuf);
1009                 size_t outleft = *termlen - 1;
1010
1011                 if (zh->iconv_from_utf8 != 0)
1012                 {
1013                     char *outbuf = termbuf;
1014                     size_t ret;
1015
1016                     ret = yaz_iconv(zh->iconv_from_utf8, &inbuf, &inleft,
1017                                     &outbuf, &outleft);
1018                     if (ret == (size_t)(-1))
1019                         *termlen = 0;
1020                     else
1021                         *termlen = outbuf - termbuf;
1022                 }
1023                 else
1024                 {
1025                     if (inleft > outleft)
1026                         inleft = outleft;
1027                     *termlen = inleft;
1028                     memcpy(termbuf, inbuf, *termlen);
1029                 }
1030                 termbuf[*termlen] = '\0';
1031             }
1032
1033             xfree(term_array);
1034             xfree(hits_array);
1035             xfree(approx_array);
1036             return ZEBRA_OK;
1037         }
1038     }
1039     return ZEBRA_FAIL;
1040 }
1041
1042 ZEBRA_RES zebra_snippets_hit_vector(ZebraHandle zh, const char *setname,
1043                                     zint sysno, zebra_snippets *snippets)
1044 {
1045     ZebraSet sset = resultSetGet(zh, setname);
1046     yaz_log(YLOG_LOG, "zebra_get_hit_vector setname=%s zysno=" ZINT_FORMAT,
1047             setname, sysno);
1048     if (!sset)
1049         return ZEBRA_FAIL;
1050     else
1051     {
1052         struct rset_key_control *kc = zebra_key_control_create(zh);
1053         NMEM nmem = nmem_create();
1054         struct it_key key;
1055         RSET rsets[2], rset_comb;
1056         RSET rset_temp = rstemp_create(nmem, kc, kc->scope,
1057                                        res_get (zh->res, "setTmpDir"),0 );
1058
1059         TERMID termid;
1060         RSFD rsfd = rset_open(rset_temp, RSETF_WRITE);
1061
1062         key.mem[0] = sysno;
1063         key.mem[1] = 0;
1064         key.mem[2] = 0;
1065         key.mem[3] = 0;
1066         key.len = 2;
1067         rset_write (rsfd, &key);
1068         rset_close (rsfd);
1069
1070         rsets[0] = rset_temp;
1071         rsets[1] = rset_dup(sset->rset);
1072
1073         rset_comb = rsmulti_and_create(nmem, kc, kc->scope, 2, rsets);
1074
1075         rsfd = rset_open(rset_comb, RSETF_READ);
1076
1077         while (rset_read(rsfd, &key, &termid))
1078         {
1079             if (termid)
1080             {
1081                 struct ord_list *ol;
1082                 for (ol = termid->ol; ol; ol = ol->next)
1083                 {
1084                     zebra_snippets_append(snippets, key.mem[key.len-1],
1085                                           termid->reg_type,
1086                                           ol->ord, termid->name);
1087                 }
1088             }
1089         }
1090         rset_close(rsfd);
1091
1092         rset_delete(rset_comb);
1093         nmem_destroy(nmem);
1094     }
1095     return ZEBRA_OK;
1096 }
1097