index/zsets.c

   1 /*
   2  * Copyright (C) 1994-2000, Index Data
   3  * All rights reserved.
   4  * Sebastian Hammer, Adam Dickmeiss
   5  *
   6  * $Log: zsets.c,v $
   7  * Revision 1.32  2002-02-20 17:30:01  adam
   8  * Work on new API. Locking system re-implemented
   9  *
  10  * Revision 1.31  2001/11/19 23:05:22  adam
  11  * Added a few prototypes.
  12  *
  13  * Revision 1.30  2001/10/15 19:53:43  adam
  14  * POSIX thread updates. First work on term sets.
  15  *
  16  * Revision 1.29  2001/01/22 10:42:56  adam
  17  * Added numerical sort.
  18  *
  19  * Revision 1.28  2000/07/07 12:49:20  adam
  20  * Optimized resultSetInsert{Rank,Sort}.
  21  *
  22  * Revision 1.27  2000/04/05 09:49:36  adam
  23  * On Unix, zebra/z'mbol uses automake.
  24  *
  25  * Revision 1.26  2000/03/20 19:08:36  adam
  26  * Added remote record import using Z39.50 extended services and Segment
  27  * Requests.
  28  *
  29  * Revision 1.25  2000/03/15 15:00:31  adam
  30  * First work on threaded version.
  31  *
  32  * Revision 1.24  1999/11/04 15:00:45  adam
  33  * Implemented delete result set(s).
  34  *
  35  * Revision 1.23  1999/05/26 07:49:13  adam
  36  * C++ compilation.
  37  *
  38  * Revision 1.22  1999/02/02 14:51:15  adam
  39  * Updated WIN32 code specific sections. Changed header.
  40  *
  41  * Revision 1.21  1998/11/16 16:03:46  adam
  42  * Moved loggin utilities to Yaz. Was implemented in file zlogs.c.
  43  *
  44  * Revision 1.20  1998/11/16 10:10:53  adam
  45  * Fixed problem with zebraPosSetCreate that occurred when positions were
  46  * less than 1.
  47  *
  48  * Revision 1.19  1998/09/22 10:48:22  adam
  49  * Minor changes in search API.
  50  *
  51  * Revision 1.18  1998/09/22 10:03:45  adam
  52  * Changed result sets to be persistent in the sense that they can
  53  * be re-searched if needed.
  54  * Fixed memory leak in rsm_or.
  55  *
  56  * Revision 1.17  1998/06/23 15:33:36  adam
  57  * Added feature to specify sort criteria in query (type 7 specifies
  58  * sort flags).
  59  *
  60  * Revision 1.16  1998/05/20 10:12:24  adam
  61  * Implemented automatic EXPLAIN database maintenance.
  62  * Modified Zebra to work with ASN.1 compiled version of YAZ.
  63  *
  64  * Revision 1.15  1998/03/05 08:45:14  adam
  65  * New result set model and modular ranking system. Moved towards
  66  * descent server API. System information stored as "SGML" records.
  67  *
  68  * Revision 1.14  1998/02/10 16:39:15  adam
  69  * Minor change.
  70  *
  71  * Revision 1.13  1998/02/10 12:03:06  adam
  72  * Implemented Sort.
  73  *
  74  * Revision 1.12  1997/09/25 14:57:36  adam
  75  * Windows NT port.
  76  *
  77  * Revision 1.11  1996/12/23 15:30:46  adam
  78  * Work on truncation.
  79  * Bug fix: result sets weren't deleted after server shut down.
  80  *
  81  * Revision 1.10  1995/10/30 15:08:08  adam
  82  * Bug fixes.
  83  *
  84  * Revision 1.9  1995/10/17  18:02:14  adam
  85  * New feature: databases. Implemented as prefix to words in dictionary.
  86  *
  87  * Revision 1.8  1995/10/10  13:59:25  adam
  88  * Function rset_open changed its wflag parameter to general flags.
  89  *
  90  * Revision 1.7  1995/10/06  14:38:01  adam
  91  * New result set method: r_score.
  92  * Local no (sysno) and score is transferred to retrieveCtrl.
  93  *
  94  * Revision 1.6  1995/09/28  09:19:49  adam
  95  * xfree/xmalloc used everywhere.
  96  * Extract/retrieve method seems to work for text records.
  97  *
  98  * Revision 1.5  1995/09/27  16:17:32  adam
  99  * More work on retrieve.
 100  *
 101  * Revision 1.4  1995/09/07  13:58:36  adam
 102  * New parameter: result-set file descriptor (RSFD) to support multiple
 103  * positions within the same result-set.
 104  * Boolean operators: and, or, not implemented.
 105  * Result-set references.
 106  *
 107  * Revision 1.3  1995/09/06  16:11:19  adam
 108  * Option: only one word key per file.
 109  *
 110  * Revision 1.2  1995/09/06  10:33:04  adam
 111  * More work on present. Some log messages removed.
 112  *
 113  * Revision 1.1  1995/09/05  15:28:40  adam
 114  * More work on search engine.
 115  *
 116  */
 117 #include <stdio.h>
 118 #include <assert.h>
 119 #ifdef WIN32
 120 #include <io.h>
 121 #else
 122 #include <unistd.h>
 123 #endif
 124
 125 #include "zserver.h"
 126 #include <rstemp.h>
 127
 128 #define SORT_IDX_ENTRYSIZE 64
 129 #define ZSET_SORT_MAX_LEVEL 3
 130
 131 struct zebra_set_term_entry {
 132     int reg_type;
 133     char *db;
 134     int set;
 135     int use;
 136     char *term;
 137 };
 138 struct zebra_set {
 139     char *name;
 140     RSET rset;
 141     NMEM nmem;
 142     int hits;
 143     int num_bases;
 144     char **basenames;
 145     Z_RPNQuery *rpn;
 146     struct zset_sort_info *sort_info;
 147     struct zebra_set_term_entry *term_entries;
 148     int term_entries_max;
 149     struct zebra_set *next;
 150     int locked;
 151 };
 152
 153 struct zset_sort_entry {
 154     int sysno;
 155     int score;
 156     char buf[ZSET_SORT_MAX_LEVEL][SORT_IDX_ENTRYSIZE];
 157 };
 158
 159 struct zset_sort_info {
 160     int max_entries;
 161     int num_entries;
 162     struct zset_sort_entry *all_entries;
 163     struct zset_sort_entry **entries;
 164 };
 165
 166 ZebraSet resultSetAddRPN (ZebraHandle zh, ODR input, ODR output,
 167                           Z_RPNQuery *rpn, int num_bases, char **basenames,
 168                           const char *setname)
 169 {
 170     ZebraSet zebraSet;
 171
 172     zh->errCode = 0;
 173     zh->errString = NULL;
 174     zh->hits = 0;
 175
 176     zebraSet = resultSetAdd (zh, setname, 1);
 177     if (!zebraSet)
 178         return 0;
 179     zebraSet->locked = 1;
 180     zebraSet->rpn = 0;
 181     zebraSet->num_bases = num_bases;
 182     zebraSet->basenames = basenames;
 183     zebraSet->nmem = odr_extract_mem (input);
 184
 185     zebraSet->rset = rpn_search (zh, output->mem, rpn,
 186                                  zebraSet->num_bases,
 187                                  zebraSet->basenames, zebraSet->name,
 188                                  zebraSet);
 189     zh->hits = zebraSet->hits;
 190     if (zebraSet->rset)
 191         zebraSet->rpn = rpn;
 192     zebraSet->locked = 0;
 193     return zebraSet;
 194 }
 195
 196 void resultSetAddTerm (ZebraHandle zh, ZebraSet s, int reg_type,
 197                        const char *db, int set,
 198                        int use, const char *term)
 199 {
 200     if (!s->nmem)
 201         s->nmem = nmem_create ();
 202     if (!s->term_entries)
 203     {
 204         int i;
 205         s->term_entries_max = 1000;
 206         s->term_entries =
 207             nmem_malloc (s->nmem, s->term_entries_max *
 208                          sizeof(*s->term_entries));
 209         for (i = 0; i < s->term_entries_max; i++)
 210             s->term_entries[i].term = 0;
 211     }
 212     if (s->hits < s->term_entries_max)
 213     {
 214         s->term_entries[s->hits].reg_type = reg_type;
 215         s->term_entries[s->hits].db = nmem_strdup (s->nmem, db);
 216         s->term_entries[s->hits].set = set;
 217         s->term_entries[s->hits].use = use;
 218         s->term_entries[s->hits].term = nmem_strdup (s->nmem, term);
 219     }
 220     (s->hits)++;
 221 }
 222
 223 ZebraSet resultSetAdd (ZebraHandle zh, const char *name, int ov)
 224 {
 225     ZebraSet s;
 226     int i;
 227
 228     for (s = zh->sets; s; s = s->next)
 229         if (!strcmp (s->name, name))
 230             break;
 231     if (s)
 232     {
 233         logf (LOG_DEBUG, "updating result set %s", name);
 234         if (!ov || s->locked)
 235             return NULL;
 236         if (s->rset)
 237             rset_delete (s->rset);
 238         if (s->nmem)
 239             nmem_destroy (s->nmem);
 240     }
 241     else
 242     {
 243         logf (LOG_DEBUG, "adding result set %s", name);
 244         s = (ZebraSet) xmalloc (sizeof(*s));
 245         s->next = zh->sets;
 246         zh->sets = s;
 247         s->name = (char *) xmalloc (strlen(name)+1);
 248         strcpy (s->name, name);
 249
 250         s->sort_info = (struct zset_sort_info *)
 251             xmalloc (sizeof(*s->sort_info));
 252         s->sort_info->max_entries = 1000;
 253         s->sort_info->entries = (struct zset_sort_entry **)
 254             xmalloc (sizeof(*s->sort_info->entries) *
 255                      s->sort_info->max_entries);
 256         s->sort_info->all_entries = (struct zset_sort_entry *)
 257             xmalloc (sizeof(*s->sort_info->all_entries) *
 258                      s->sort_info->max_entries);
 259         for (i = 0; i < s->sort_info->max_entries; i++)
 260             s->sort_info->entries[i] = s->sort_info->all_entries + i;
 261     }
 262     s->locked = 0;
 263     s->term_entries = 0;
 264     s->hits = 0;
 265     s->rset = 0;
 266     s->nmem = 0;
 267     s->rpn = 0;
 268     return s;
 269 }
 270
 271 ZebraSet resultSetGet (ZebraHandle zh, const char *name)
 272 {
 273     ZebraSet s;
 274
 275     for (s = zh->sets; s; s = s->next)
 276         if (!strcmp (s->name, name))
 277         {
 278             if (!s->term_entries && !s->rset && s->rpn)
 279             {
 280                 NMEM nmem = nmem_create ();
 281                 yaz_log (LOG_LOG, "research %s", name);
 282                 s->rset =
 283                     rpn_search (zh, nmem, s->rpn, s->num_bases,
 284                                 s->basenames, s->name, s);
 285                 nmem_destroy (nmem);
 286             }
 287             return s;
 288         }
 289     return NULL;
 290 }
 291
 292 void resultSetInvalidate (ZebraHandle zh)
 293 {
 294     ZebraSet s = zh->sets;
 295
 296     for (; s; s = s->next)
 297     {
 298         if (s->rset)
 299             rset_delete (s->rset);
 300         s->rset = 0;
 301     }
 302 }
 303
 304 void resultSetDestroy (ZebraHandle zh, int num, char **names,int *statuses)
 305 {
 306     ZebraSet * ss = &zh->sets;
 307     int i;
 308
 309     if (statuses)
 310         for (i = 0; i<num; i++)
 311             statuses[i] = Z_DeleteStatus_resultSetDidNotExist;
 312     zh->errCode = 0;
 313     zh->errString = NULL;
 314     while (*ss)
 315     {
 316         int i = -1;
 317         ZebraSet s = *ss;
 318         if (num >= 0)
 319         {
 320             for (i = 0; i<num; i++)
 321                 if (!strcmp (s->name, names[i]))
 322                 {
 323                     if (statuses)
 324                         statuses[i] = Z_DeleteStatus_success;
 325                     i = -1;
 326                     break;
 327                 }
 328         }
 329         if (i < 0)
 330         {
 331             *ss = s->next;
 332
 333             xfree (s->sort_info->all_entries);
 334             xfree (s->sort_info->entries);
 335             xfree (s->sort_info);
 336
 337             if (s->nmem)
 338                 nmem_destroy (s->nmem);
 339             if (s->rset)
 340                 rset_delete (s->rset);
 341             xfree (s->name);
 342             xfree (s);
 343         }
 344         else
 345             ss = &s->next;
 346     }
 347 }
 348
 349 ZebraPosSet zebraPosSetCreate (ZebraHandle zh, const char *name,
 350                                int num, int *positions)
 351 {
 352     ZebraSet sset;
 353     ZebraPosSet sr = 0;
 354     RSET rset;
 355     int i;
 356     struct zset_sort_info *sort_info;
 357
 358     if (!(sset = resultSetGet (zh, name)))
 359         return NULL;
 360     if (!(rset = sset->rset))
 361     {
 362         if (!sset->term_entries)
 363             return 0;
 364         sr = (ZebraPosSet) xmalloc (sizeof(*sr) * num);
 365         for (i = 0; i<num; i++)
 366         {
 367             struct zebra_set_term_entry *entry = sset->term_entries;
 368
 369             sr[i].sysno = 0;
 370             sr[i].score = -1;
 371             sr[i].term = 0;
 372             sr[i].db = 0;
 373
 374             if (positions[i] <= sset->term_entries_max)
 375             {
 376                 sr[i].term = sset->term_entries[positions[i]-1].term;
 377                 sr[i].db = sset->term_entries[positions[i]-1].db;
 378             }
 379         }
 380     }
 381     else
 382     {
 383         sr = (ZebraPosSet) xmalloc (sizeof(*sr) * num);
 384         for (i = 0; i<num; i++)
 385         {
 386             sr[i].sysno = 0;
 387             sr[i].score = -1;
 388             sr[i].term = 0;
 389             sr[i].db = 0;
 390         }
 391         sort_info = sset->sort_info;
 392         if (sort_info)
 393         {
 394             int position;
 395
 396             for (i = 0; i<num; i++)
 397             {
 398                 position = positions[i];
 399                 if (position > 0 && position <= sort_info->num_entries)
 400                 {
 401                     logf (LOG_DEBUG, "got pos=%d (sorted)", position);
 402                     sr[i].sysno = sort_info->entries[position-1]->sysno;
 403                     sr[i].score = sort_info->entries[position-1]->score;
 404                 }
 405             }
 406         }
 407         /* did we really get all entries using sort ? */
 408         for (i = 0; i<num; i++)
 409         {
 410             if (!sr[i].sysno)
 411                 break;
 412         }
 413         if (i < num) /* nope, get the rest, unsorted - sorry */
 414         {
 415             int position = 0;
 416             int num_i = 0;
 417             int psysno = 0;
 418             int term_index;
 419             RSFD rfd;
 420             struct it_key key;
 421
 422             if (sort_info)
 423                 position = sort_info->num_entries;
 424             while (num_i < num && positions[num_i] < position)
 425                 num_i++;
 426             rfd = rset_open (rset, RSETF_READ);
 427             while (num_i < num && rset_read (rset, rfd, &key, &term_index))
 428             {
 429                 if (key.sysno != psysno)
 430                 {
 431                     psysno = key.sysno;
 432                     if (sort_info)
 433                     {
 434                         /* determine we alreay have this in our set */
 435                         for (i = sort_info->num_entries; --i >= 0; )
 436                             if (psysno == sort_info->entries[i]->sysno)
 437                                 break;
 438                         if (i >= 0)
 439                             continue;
 440                     }
 441                     position++;
 442                     assert (num_i < num);
 443                     if (position == positions[num_i])
 444                     {
 445                         sr[num_i].sysno = psysno;
 446                         logf (LOG_DEBUG, "got pos=%d (unsorted)", position);
 447                         sr[num_i].score = -1;
 448                         num_i++;
 449                     }
 450                 }
 451             }
 452             rset_close (rset, rfd);
 453         }
 454     }
 455     return sr;
 456 }
 457
 458 void zebraPosSetDestroy (ZebraHandle zh, ZebraPosSet records, int num)
 459 {
 460     xfree (records);
 461 }
 462
 463 struct sortKeyInfo {
 464     int relation;
 465     int attrUse;
 466     int numerical;
 467 };
 468
 469 void resultSetInsertSort (ZebraHandle zh, ZebraSet sset,
 470                           struct sortKeyInfo *criteria, int num_criteria,
 471                           int sysno)
 472 {
 473     struct zset_sort_entry this_entry;
 474     struct zset_sort_entry *new_entry = NULL;
 475     struct zset_sort_info *sort_info = sset->sort_info;
 476     int i, j;
 477
 478     sortIdx_sysno (zh->service->sortIdx, sysno);
 479     for (i = 0; i<num_criteria; i++)
 480     {
 481         sortIdx_type (zh->service->sortIdx, criteria[i].attrUse);
 482         sortIdx_read (zh->service->sortIdx, this_entry.buf[i]);
 483     }
 484     i = sort_info->num_entries;
 485     while (--i >= 0)
 486     {
 487         int rel = 0;
 488         for (j = 0; j<num_criteria; j++)
 489         {
 490             if (criteria[j].numerical)
 491             {
 492                 double diff = atof(this_entry.buf[j]) -
 493                               atof(sort_info->entries[i]->buf[j]);
 494                 rel = 0;
 495                 if (diff > 0.0)
 496                     rel = 1;
 497                 else if (diff < 0.0)
 498                     rel = -1;
 499             }
 500             else
 501             {
 502                 rel = memcmp (this_entry.buf[j], sort_info->entries[i]->buf[j],
 503                           SORT_IDX_ENTRYSIZE);
 504             }
 505             if (rel)
 506                 break;
 507         }
 508         if (!rel)
 509             break;
 510         if (criteria[j].relation == 'A')
 511         {
 512             if (rel > 0)
 513                 break;
 514         }
 515         else if (criteria[j].relation == 'D')
 516         {
 517             if (rel < 0)
 518                 break;
 519         }
 520     }
 521     ++i;
 522     j = sort_info->max_entries;
 523     if (i == j)
 524         return;
 525
 526     if (sort_info->num_entries == j)
 527         --j;
 528     else
 529         j = (sort_info->num_entries)++;
 530     new_entry = sort_info->entries[j];
 531     while (j != i)
 532     {
 533         sort_info->entries[j] = sort_info->entries[j-1];
 534         --j;
 535     }
 536     sort_info->entries[i] = new_entry;
 537     assert (new_entry);
 538     for (i = 0; i<num_criteria; i++)
 539         memcpy (new_entry->buf[i], this_entry.buf[i], SORT_IDX_ENTRYSIZE);
 540     new_entry->sysno = sysno;
 541     new_entry->score = -1;
 542 }
 543
 544 void resultSetInsertRank (ZebraHandle zh, struct zset_sort_info *sort_info,
 545                           int sysno, int score, int relation)
 546 {
 547     struct zset_sort_entry *new_entry = NULL;
 548     int i, j;
 549
 550     i = sort_info->num_entries;
 551     while (--i >= 0)
 552     {
 553         int rel = 0;
 554
 555         rel = score - sort_info->entries[i]->score;
 556
 557         if (relation == 'D')
 558         {
 559             if (rel >= 0)
 560                 break;
 561         }
 562         else if (relation == 'A')
 563         {
 564             if (rel <= 0)
 565                 break;
 566         }
 567     }
 568     ++i;
 569     j = sort_info->max_entries;
 570     if (i == j)
 571         return;
 572
 573     if (sort_info->num_entries == j)
 574         --j;
 575     else
 576         j = (sort_info->num_entries)++;
 577
 578     new_entry = sort_info->entries[j];
 579     while (j != i)
 580     {
 581         sort_info->entries[j] = sort_info->entries[j-1];
 582         --j;
 583     }
 584     sort_info->entries[i] = new_entry;
 585     assert (new_entry);
 586     new_entry->sysno = sysno;
 587     new_entry->score = score;
 588 }
 589
 590 void resultSetSort (ZebraHandle zh, NMEM nmem,
 591                     int num_input_setnames, const char **input_setnames,
 592                     const char *output_setname,
 593                     Z_SortKeySpecList *sort_sequence, int *sort_status)
 594 {
 595     ZebraSet sset;
 596     RSET rset;
 597
 598     if (num_input_setnames == 0)
 599     {
 600         zh->errCode = 208;
 601         return ;
 602     }
 603     if (num_input_setnames > 1)
 604     {
 605         zh->errCode = 230;
 606         return;
 607     }
 608     logf (LOG_DEBUG, "result set sort input=%s output=%s",
 609           *input_setnames, output_setname);
 610     sset = resultSetGet (zh, input_setnames[0]);
 611     if (!sset)
 612     {
 613         zh->errCode = 30;
 614         zh->errString = nmem_strdup (nmem, input_setnames[0]);
 615         return;
 616     }
 617     if (!(rset = sset->rset))
 618     {
 619         zh->errCode = 30;
 620         zh->errString = nmem_strdup (nmem, input_setnames[0]);
 621         return;
 622     }
 623     if (strcmp (output_setname, input_setnames[0]))
 624     {
 625         rset = rset_dup (rset);
 626         sset = resultSetAdd (zh, output_setname, 1);
 627         sset->rset = rset;
 628     }
 629     resultSetSortSingle (zh, nmem, sset, rset, sort_sequence, sort_status);
 630 }
 631
 632 void resultSetSortSingle (ZebraHandle zh, NMEM nmem,
 633                           ZebraSet sset, RSET rset,
 634                           Z_SortKeySpecList *sort_sequence, int *sort_status)
 635 {
 636     int i, psysno = 0;
 637     struct it_key key;
 638     struct sortKeyInfo sort_criteria[3];
 639     int num_criteria;
 640     int term_index;
 641     RSFD rfd;
 642
 643     logf (LOG_DEBUG, "resultSetSortSingle start");
 644     sset->sort_info->num_entries = 0;
 645
 646     sset->hits = 0;
 647     num_criteria = sort_sequence->num_specs;
 648     if (num_criteria > 3)
 649         num_criteria = 3;
 650     for (i = 0; i < num_criteria; i++)
 651     {
 652         Z_SortKeySpec *sks = sort_sequence->specs[i];
 653         Z_SortKey *sk;
 654
 655         if (*sks->sortRelation == Z_SortRelation_ascending)
 656             sort_criteria[i].relation = 'A';
 657         else if (*sks->sortRelation == Z_SortRelation_descending)
 658             sort_criteria[i].relation = 'D';
 659         else
 660         {
 661             zh->errCode = 214;
 662             return;
 663         }
 664         if (sks->sortElement->which == Z_SortElement_databaseSpecific)
 665         {
 666             zh->errCode = 210;
 667             return;
 668         }
 669         else if (sks->sortElement->which != Z_SortElement_generic)
 670         {
 671             zh->errCode = 237;
 672             return;
 673         }
 674         sk = sks->sortElement->u.generic;
 675         switch (sk->which)
 676         {
 677         case Z_SortKey_sortField:
 678             logf (LOG_DEBUG, "Sort: key %d is of type sortField", i+1);
 679             zh->errCode = 207;
 680             return;
 681         case Z_SortKey_elementSpec:
 682             logf (LOG_DEBUG, "Sort: key %d is of type elementSpec", i+1);
 683             zh->errCode = 207;
 684             return;
 685         case Z_SortKey_sortAttributes:
 686             logf (LOG_DEBUG, "Sort: key %d is of type sortAttributes", i+1);
 687             sort_criteria[i].attrUse =
 688                 zebra_maps_sort (zh->service->zebra_maps,
 689                                  sk->u.sortAttributes,
 690                                  &sort_criteria[i].numerical);
 691             logf (LOG_DEBUG, "use value = %d", sort_criteria[i].attrUse);
 692             if (sort_criteria[i].attrUse == -1)
 693             {
 694                 zh->errCode = 116;
 695                 return;
 696             }
 697             if (sortIdx_type (zh->service->sortIdx, sort_criteria[i].attrUse))
 698             {
 699                 zh->errCode = 207;
 700                 return;
 701             }
 702             break;
 703         }
 704     }
 705     rfd = rset_open (rset, RSETF_READ);
 706     while (rset_read (rset, rfd, &key, &term_index))
 707     {
 708         if (key.sysno != psysno)
 709         {
 710             (sset->hits)++;
 711             psysno = key.sysno;
 712             resultSetInsertSort (zh, sset,
 713                                  sort_criteria, num_criteria, psysno);
 714         }
 715     }
 716     rset_close (rset, rfd);
 717
 718     *sort_status = Z_SortStatus_success;
 719     logf (LOG_DEBUG, "resultSetSortSingle end");
 720 }
 721
 722 RSET resultSetRef (ZebraHandle zh, Z_ResultSetId *resultSetId)
 723 {
 724     ZebraSet s;
 725
 726     if ((s = resultSetGet (zh, resultSetId)))
 727         return s->rset;
 728     return NULL;
 729 }
 730
 731 void resultSetRank (ZebraHandle zh, ZebraSet zebraSet, RSET rset)
 732 {
 733     int kno = 0;
 734     struct it_key key;
 735     RSFD rfd;
 736     int term_index, i;
 737     ZebraRankClass rank_class;
 738     struct rank_control *rc;
 739     struct zset_sort_info *sort_info;
 740
 741     sort_info = zebraSet->sort_info;
 742     sort_info->num_entries = 0;
 743     zebraSet->hits = 0;
 744     rfd = rset_open (rset, RSETF_READ);
 745
 746     logf (LOG_DEBUG, "resultSetRank");
 747     for (i = 0; i < rset->no_rset_terms; i++)
 748         logf (LOG_DEBUG, "term=\"%s\" cnt=%d type=%s",
 749               rset->rset_terms[i]->name,
 750               rset->rset_terms[i]->nn,
 751               rset->rset_terms[i]->flags);
 752
 753     rank_class = zebraRankLookup (zh, "rank-1");
 754     rc = rank_class->control;
 755
 756     if (rset_read (rset, rfd, &key, &term_index))
 757     {
 758         int psysno = key.sysno;
 759         int score;
 760         void *handle =
 761             (*rc->begin) (zh, rank_class->class_handle, rset);
 762         (zebraSet->hits)++;
 763         do
 764         {
 765             kno++;
 766             if (key.sysno != psysno)
 767             {
 768                 score = (*rc->calc) (handle, psysno);
 769
 770                 resultSetInsertRank (zh, sort_info, psysno, score, 'A');
 771                 (zebraSet->hits)++;
 772                 psysno = key.sysno;
 773             }
 774             (*rc->add) (handle, key.seqno, term_index);
 775         }
 776         while (rset_read (rset, rfd, &key, &term_index));
 777         score = (*rc->calc) (handle, psysno);
 778         resultSetInsertRank (zh, sort_info, psysno, score, 'A');
 779         (*rc->end) (zh, handle);
 780     }
 781     rset_close (rset, rfd);
 782     logf (LOG_DEBUG, "%d keys, %d distinct sysnos", kno, zebraSet->hits);
 783 }
 784
 785 ZebraRankClass zebraRankLookup (ZebraHandle zh, const char *name)
 786 {
 787     ZebraRankClass p = zh->service->rank_classes;
 788     while (p && strcmp (p->control->name, name))
 789         p = p->next;
 790     if (p && !p->init_flag)
 791     {
 792         if (p->control->create)
 793             p->class_handle = (*p->control->create)(zh->service);
 794         p->init_flag = 1;
 795     }
 796     return p;
 797 }
 798
 799 void zebraRankInstall (ZebraService zh, struct rank_control *ctrl)
 800 {
 801     ZebraRankClass p = (ZebraRankClass) xmalloc (sizeof(*p));
 802     p->control = (struct rank_control *) xmalloc (sizeof(*p->control));
 803     memcpy (p->control, ctrl, sizeof(*p->control));
 804     p->control->name = xstrdup (ctrl->name);
 805     p->init_flag = 0;
 806     p->next = zh->rank_classes;
 807     zh->rank_classes = p;
 808 }
 809
 810 void zebraRankDestroy (ZebraService zh)
 811 {
 812     ZebraRankClass p = zh->rank_classes;
 813     while (p)
 814     {
 815         ZebraRankClass p_next = p->next;
 816         if (p->init_flag && p->control->destroy)
 817             (*p->control->destroy)(zh, p->class_handle);
 818         xfree (p->control->name);
 819         xfree (p->control);
 820         xfree (p);
 821         p = p_next;
 822     }
 823     zh->rank_classes = NULL;
 824 }