index/zsets.c

   1 /* $Id: zsets.c,v 1.74 2004-12-10 11:56:22 heikki Exp $
   2    Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
   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 <rset.h>
  34
  35 #define SORT_IDX_ENTRYSIZE 64
  36 #define ZSET_SORT_MAX_LEVEL 3
  37
  38 struct zebra_set_term_entry {
  39     int reg_type;
  40     char *db;
  41     int set;
  42     int use;
  43     char *term;
  44 };
  45 struct zebra_set {
  46     char *name;
  47     RSET rset;
  48     NMEM nmem;
  49     NMEM rset_nmem; /* for creating the rsets in */
  50     zint hits;
  51     int num_bases;
  52     char **basenames;
  53     Z_RPNQuery *rpn;
  54     struct zset_sort_info *sort_info;
  55     struct zebra_set_term_entry *term_entries;
  56     int term_entries_max;
  57     struct zebra_set *next;
  58     int locked;
  59 };
  60
  61 struct zset_sort_entry {
  62     zint sysno;
  63     int score;
  64     char buf[ZSET_SORT_MAX_LEVEL][SORT_IDX_ENTRYSIZE];
  65 };
  66
  67 struct zset_sort_info {
  68     int max_entries;
  69     int num_entries;
  70     struct zset_sort_entry *all_entries;
  71     struct zset_sort_entry **entries;
  72 };
  73
  74 static int log_level_set=0;
  75 static int log_level_sorting=0;
  76 static int log_level_searchhits=0;
  77 static int log_level_searchterms=0;
  78 static int log_level_resultsets=0;
  79
  80 static void loglevels()
  81 {
  82     if (log_level_set)
  83         return;
  84     log_level_sorting = yaz_log_module_level("sorting");
  85     log_level_searchhits = yaz_log_module_level("searchhits");
  86     log_level_searchterms = yaz_log_module_level("searchterms");
  87     log_level_resultsets = yaz_log_module_level("resultsets");
  88 }
  89
  90 ZebraSet resultSetAddRPN (ZebraHandle zh, NMEM m,
  91                           Z_RPNQuery *rpn, int num_bases,
  92                           char **basenames,
  93                           const char *setname)
  94 {
  95     ZebraSet zebraSet;
  96     int i;
  97
  98     zh->errCode = 0;
  99     zh->errString = NULL;
 100     zh->hits = 0;
 101
 102     zebraSet = resultSetAdd (zh, setname, 1);
 103     if (!zebraSet)
 104         return 0;
 105     zebraSet->locked = 1;
 106     zebraSet->rpn = 0;
 107     zebraSet->nmem = m;
 108     zebraSet->rset_nmem=nmem_create();
 109
 110     zebraSet->num_bases = num_bases;
 111     zebraSet->basenames =
 112         nmem_malloc (zebraSet->nmem, num_bases * sizeof(*zebraSet->basenames));
 113     for (i = 0; i<num_bases; i++)
 114         zebraSet->basenames[i] = nmem_strdup (zebraSet->nmem, basenames[i]);
 115
 116
 117     zebraSet->rset = rpn_search (zh, zebraSet->nmem, zebraSet->rset_nmem,
 118                                  rpn, zebraSet->num_bases,
 119                                  zebraSet->basenames, zebraSet->name,
 120                                  zebraSet);
 121     zh->hits = zebraSet->hits;
 122     if (zebraSet->rset)
 123         zebraSet->rpn = rpn;
 124     zebraSet->locked = 0;
 125     return zebraSet;
 126 }
 127
 128 void resultSetAddTerm (ZebraHandle zh, ZebraSet s, int reg_type,
 129                        const char *db, int set,
 130                        int use, const char *term)
 131 {
 132     assert(zh); /* compiler shut up */
 133     if (!s->nmem)
 134         s->nmem = nmem_create ();
 135     if (!s->term_entries)
 136     {
 137         int i;
 138         s->term_entries_max = 1000;
 139         s->term_entries =
 140             nmem_malloc (s->nmem, s->term_entries_max *
 141                          sizeof(*s->term_entries));
 142         for (i = 0; i < s->term_entries_max; i++)
 143             s->term_entries[i].term = 0;
 144     }
 145     if (s->hits < s->term_entries_max)
 146     {
 147         s->term_entries[s->hits].reg_type = reg_type;
 148         s->term_entries[s->hits].db = nmem_strdup (s->nmem, db);
 149         s->term_entries[s->hits].set = set;
 150         s->term_entries[s->hits].use = use;
 151         s->term_entries[s->hits].term = nmem_strdup (s->nmem, term);
 152     }
 153     (s->hits)++;
 154 }
 155
 156 ZebraSet resultSetAdd (ZebraHandle zh, const char *name, int ov)
 157 {
 158     ZebraSet s;
 159     int i;
 160
 161     for (s = zh->sets; s; s = s->next)
 162         if (!strcmp (s->name, name))
 163             break;
 164
 165     if (!log_level_set)
 166         loglevels();
 167     if (s)
 168     {
 169         yaz_log(log_level_resultsets, "updating result set %s", name);
 170         if (!ov || s->locked)
 171             return NULL;
 172         if (s->rset)
 173             rset_delete (s->rset);
 174         if (s->rset_nmem)
 175             nmem_destroy (s->rset_nmem);
 176         if (s->nmem)
 177             nmem_destroy (s->nmem);
 178     }
 179     else
 180     {
 181         const char *sort_max_str = zebra_get_resource(zh, "sortmax", "1000");
 182
 183         yaz_log(log_level_resultsets, "adding result set %s", name);
 184         s = (ZebraSet) xmalloc (sizeof(*s));
 185         s->next = zh->sets;
 186         zh->sets = s;
 187         s->name = (char *) xmalloc (strlen(name)+1);
 188         strcpy (s->name, name);
 189
 190         s->sort_info = (struct zset_sort_info *)
 191             xmalloc (sizeof(*s->sort_info));
 192         s->sort_info->max_entries = atoi(sort_max_str);
 193         if (s->sort_info->max_entries < 2)
 194             s->sort_info->max_entries = 2;
 195
 196         s->sort_info->entries = (struct zset_sort_entry **)
 197             xmalloc (sizeof(*s->sort_info->entries) *
 198                      s->sort_info->max_entries);
 199         s->sort_info->all_entries = (struct zset_sort_entry *)
 200             xmalloc (sizeof(*s->sort_info->all_entries) *
 201                      s->sort_info->max_entries);
 202         for (i = 0; i < s->sort_info->max_entries; i++)
 203             s->sort_info->entries[i] = s->sort_info->all_entries + i;
 204     }
 205     s->locked = 0;
 206     s->term_entries = 0;
 207     s->hits = 0;
 208     s->rset = 0;
 209     s->rset_nmem=0;
 210     s->nmem = 0;
 211     s->rpn = 0;
 212     return s;
 213 }
 214
 215 ZebraSet resultSetGet (ZebraHandle zh, const char *name)
 216 {
 217     ZebraSet s;
 218
 219     for (s = zh->sets; s; s = s->next)
 220         if (!strcmp (s->name, name))
 221         {
 222             if (!s->term_entries && !s->rset && s->rpn)
 223             {
 224                 NMEM nmem = nmem_create ();
 225                 yaz_log(log_level_resultsets, "research %s", name);
 226                 if (!s->rset_nmem)
 227                     s->rset_nmem=nmem_create();
 228                 s->rset =
 229                     rpn_search (zh, nmem, s->rset_nmem, s->rpn, s->num_bases,
 230                                 s->basenames, s->name, s);
 231                 nmem_destroy (nmem);
 232             }
 233             return s;
 234         }
 235     return NULL;
 236 }
 237
 238 void resultSetInvalidate (ZebraHandle zh)
 239 {
 240     ZebraSet s = zh->sets;
 241
 242     yaz_log(log_level_resultsets, "invalidating result sets");
 243     for (; s; s = s->next)
 244     {
 245         if (s->rset)
 246             rset_delete (s->rset);
 247         s->rset = 0;
 248         if (s->rset_nmem)
 249             nmem_destroy(s->rset_nmem);
 250         s->rset_nmem=0;
 251     }
 252 }
 253
 254 void resultSetDestroy (ZebraHandle zh, int num, char **names,int *statuses)
 255 {
 256     ZebraSet * ss = &zh->sets;
 257     int i;
 258
 259     if (statuses)
 260         for (i = 0; i<num; i++)
 261             statuses[i] = Z_DeleteStatus_resultSetDidNotExist;
 262     zh->errCode = 0;
 263     zh->errString = NULL;
 264     while (*ss)
 265     {
 266         int i = -1;
 267         ZebraSet s = *ss;
 268         if (num >= 0)
 269         {
 270             for (i = 0; i<num; i++)
 271                 if (!strcmp (s->name, names[i]))
 272                 {
 273                     if (statuses)
 274                         statuses[i] = Z_DeleteStatus_success;
 275                     i = -1;
 276                     break;
 277                 }
 278         }
 279         if (i < 0)
 280         {
 281             *ss = s->next;
 282
 283             xfree (s->sort_info->all_entries);
 284             xfree (s->sort_info->entries);
 285             xfree (s->sort_info);
 286
 287             if (s->nmem)
 288                 nmem_destroy (s->nmem);
 289             if (s->rset)
 290                 rset_delete (s->rset);
 291             if (s->rset_nmem)
 292                 nmem_destroy(s->rset_nmem);
 293             xfree (s->name);
 294             xfree (s);
 295         }
 296         else
 297             ss = &s->next;
 298     }
 299 }
 300
 301 ZebraMetaRecord *zebra_meta_records_create_range (ZebraHandle zh,
 302                                                   const char *name,
 303                                                   zint start, int num)
 304 {
 305     zint pos_small[10];
 306     zint *pos = pos_small;
 307     ZebraMetaRecord *mr;
 308     int i;
 309
 310     if (num > 10000 || num <= 0)
 311         return 0;
 312
 313     if (num > 10)
 314         pos = xmalloc(sizeof(*pos) * num);
 315
 316     for (i = 0; i<num; i++)
 317         pos[i] = start+i;
 318
 319     mr = zebra_meta_records_create(zh, name, num, pos);
 320
 321     if (num > 10)
 322         xfree(pos);
 323     return mr;
 324 }
 325
 326 ZebraMetaRecord *zebra_meta_records_create (ZebraHandle zh, const char *name,
 327                                             int num, zint *positions)
 328 {
 329     ZebraSet sset;
 330     ZebraMetaRecord *sr = 0;
 331     RSET rset;
 332     int i;
 333     struct zset_sort_info *sort_info;
 334
 335     if (!log_level_set)
 336         loglevels();
 337     if (!(sset = resultSetGet (zh, name)))
 338         return NULL;
 339     if (!(rset = sset->rset))
 340     {
 341         if (!sset->term_entries)
 342             return 0;
 343         sr = (ZebraMetaRecord *) xmalloc (sizeof(*sr) * num);
 344         for (i = 0; i<num; i++)
 345         {
 346             sr[i].sysno = 0;
 347             sr[i].score = -1;
 348             sr[i].term = 0;
 349             sr[i].db = 0;
 350
 351             if (positions[i] <= sset->term_entries_max)
 352             {
 353                 sr[i].term = sset->term_entries[positions[i]-1].term;
 354                 sr[i].db = sset->term_entries[positions[i]-1].db;
 355             }
 356         }
 357     }
 358     else
 359     {
 360         sr = (ZebraMetaRecord *) xmalloc (sizeof(*sr) * num);
 361         for (i = 0; i<num; i++)
 362         {
 363             sr[i].sysno = 0;
 364             sr[i].score = -1;
 365             sr[i].term = 0;
 366             sr[i].db = 0;
 367         }
 368         sort_info = sset->sort_info;
 369         if (sort_info)
 370         {
 371             int position;
 372
 373             for (i = 0; i<num; i++)
 374             {
 375                 position = positions[i];
 376                 if (position > 0 && position <= sort_info->num_entries)
 377                 {
 378                     yaz_log(log_level_sorting, "got pos=%d (sorted)", position);
 379                     sr[i].sysno = sort_info->entries[position-1]->sysno;
 380                     sr[i].score = sort_info->entries[position-1]->score;
 381                 }
 382             }
 383         }
 384         /* did we really get all entries using sort ? */
 385         for (i = 0; i<num; i++)
 386         {
 387             if (!sr[i].sysno)
 388                 break;
 389         }
 390         if (i < num) /* nope, get the rest, unsorted - sorry */
 391         {
 392             int position = 0;
 393             int num_i = 0;
 394             zint psysno = 0;
 395             RSFD rfd;
 396             struct it_key key;
 397
 398             if (sort_info)
 399                 position = sort_info->num_entries;
 400             while (num_i < num && positions[num_i] < position)
 401                 num_i++;
 402             rfd = rset_open (rset, RSETF_READ);
 403             while (num_i < num && rset_read (rfd, &key, 0))
 404             {
 405                 zint this_sys = key.mem[0];
 406                 if (this_sys != psysno)
 407                 {
 408                     psysno = this_sys;
 409                     if (sort_info)
 410                     {
 411                         /* determine we alreay have this in our set */
 412                         for (i = sort_info->num_entries; --i >= 0; )
 413                             if (psysno == sort_info->entries[i]->sysno)
 414                                 break;
 415                         if (i >= 0)
 416                             continue;
 417                     }
 418                     position++;
 419                     assert (num_i < num);
 420                     if (position == positions[num_i])
 421                     {
 422                         sr[num_i].sysno = psysno;
 423                         yaz_log(log_level_sorting, "got pos=%d (unsorted)", position);
 424                         sr[num_i].score = -1;
 425                         num_i++;
 426                     }
 427                 }
 428             }
 429             rset_close (rfd);
 430         }
 431     }
 432     return sr;
 433 }
 434
 435 void zebra_meta_records_destroy (ZebraHandle zh, ZebraMetaRecord *records,
 436                                  int num)
 437 {
 438     assert(zh); /* compiler shut up about unused arg */
 439     xfree (records);
 440 }
 441
 442 struct sortKeyInfo {
 443     int relation;
 444     int attrUse;
 445     int numerical;
 446 };
 447
 448 void resultSetInsertSort (ZebraHandle zh, ZebraSet sset,
 449                           struct sortKeyInfo *criteria, int num_criteria,
 450                           zint sysno)
 451 {
 452     struct zset_sort_entry this_entry;
 453     struct zset_sort_entry *new_entry = NULL;
 454     struct zset_sort_info *sort_info = sset->sort_info;
 455     int i, j;
 456
 457     sortIdx_sysno (zh->reg->sortIdx, sysno);
 458     for (i = 0; i<num_criteria; i++)
 459     {
 460         sortIdx_type (zh->reg->sortIdx, criteria[i].attrUse);
 461         sortIdx_read (zh->reg->sortIdx, this_entry.buf[i]);
 462     }
 463     i = sort_info->num_entries;
 464     while (--i >= 0)
 465     {
 466         int rel = 0;
 467         for (j = 0; j<num_criteria; j++)
 468         {
 469             if (criteria[j].numerical)
 470             {
 471                 double diff = atof(this_entry.buf[j]) -
 472                               atof(sort_info->entries[i]->buf[j]);
 473                 rel = 0;
 474                 if (diff > 0.0)
 475                     rel = 1;
 476                 else if (diff < 0.0)
 477                     rel = -1;
 478             }
 479             else
 480             {
 481                 rel = memcmp (this_entry.buf[j], sort_info->entries[i]->buf[j],
 482                           SORT_IDX_ENTRYSIZE);
 483             }
 484             if (rel)
 485                 break;
 486         }
 487         if (!rel)
 488             break;
 489         if (criteria[j].relation == 'A')
 490         {
 491             if (rel > 0)
 492                 break;
 493         }
 494         else if (criteria[j].relation == 'D')
 495         {
 496             if (rel < 0)
 497                 break;
 498         }
 499     }
 500     ++i;
 501     j = sort_info->max_entries;
 502     if (i == j)
 503         return;
 504
 505     if (sort_info->num_entries == j)
 506         --j;
 507     else
 508         j = (sort_info->num_entries)++;
 509     new_entry = sort_info->entries[j];
 510     while (j != i)
 511     {
 512         sort_info->entries[j] = sort_info->entries[j-1];
 513         --j;
 514     }
 515     sort_info->entries[i] = new_entry;
 516     assert (new_entry);
 517     for (i = 0; i<num_criteria; i++)
 518         memcpy (new_entry->buf[i], this_entry.buf[i], SORT_IDX_ENTRYSIZE);
 519     new_entry->sysno = sysno;
 520     new_entry->score = -1;
 521 }
 522
 523 void resultSetInsertRank (ZebraHandle zh, struct zset_sort_info *sort_info,
 524                           zint sysno, int score, int relation)
 525 {
 526     struct zset_sort_entry *new_entry = NULL;
 527     int i, j;
 528     assert(zh); /* compiler shut up about unused arg */
 529
 530     i = sort_info->num_entries;
 531     while (--i >= 0)
 532     {
 533         int rel = 0;
 534
 535         rel = score - sort_info->entries[i]->score;
 536
 537         if (relation == 'D')
 538         {
 539             if (rel >= 0)
 540                 break;
 541         }
 542         else if (relation == 'A')
 543         {
 544             if (rel <= 0)
 545                 break;
 546         }
 547     }
 548     ++i;
 549     j = sort_info->max_entries;
 550     if (i == j)
 551         return;
 552
 553     if (sort_info->num_entries == j)
 554         --j;
 555     else
 556         j = (sort_info->num_entries)++;
 557
 558     new_entry = sort_info->entries[j];
 559     while (j != i)
 560     {
 561         sort_info->entries[j] = sort_info->entries[j-1];
 562         --j;
 563     }
 564     sort_info->entries[i] = new_entry;
 565     assert (new_entry);
 566     new_entry->sysno = sysno;
 567     new_entry->score = score;
 568 }
 569
 570 void resultSetSort (ZebraHandle zh, NMEM nmem,
 571                     int num_input_setnames, const char **input_setnames,
 572                     const char *output_setname,
 573                     Z_SortKeySpecList *sort_sequence, int *sort_status)
 574 {
 575     ZebraSet sset;
 576     RSET rset;
 577
 578     if (num_input_setnames == 0)
 579     {
 580         zh->errCode = 208;
 581         return ;
 582     }
 583     if (num_input_setnames > 1)
 584     {
 585         zh->errCode = 230;
 586         return;
 587     }
 588     if (!log_level_set)
 589         loglevels();
 590     yaz_log(log_level_sorting, "result set sort input=%s output=%s",
 591           *input_setnames, output_setname);
 592     sset = resultSetGet (zh, input_setnames[0]);
 593     if (!sset)
 594     {
 595         zh->errCode = 30;
 596         zh->errString = nmem_strdup (nmem, input_setnames[0]);
 597         return;
 598     }
 599     if (!(rset = sset->rset))
 600     {
 601         zh->errCode = 30;
 602         zh->errString = nmem_strdup (nmem, input_setnames[0]);
 603         return;
 604     }
 605     if (strcmp (output_setname, input_setnames[0]))
 606     {
 607         rset = rset_dup (rset);
 608         sset = resultSetAdd (zh, output_setname, 1);
 609         sset->rset = rset;
 610     }
 611     resultSetSortSingle (zh, nmem, sset, rset, sort_sequence, sort_status);
 612 }
 613
 614 void resultSetSortSingle (ZebraHandle zh, NMEM nmem,
 615                           ZebraSet sset, RSET rset,
 616                           Z_SortKeySpecList *sort_sequence, int *sort_status)
 617 {
 618     int i;
 619     int n = 0;
 620     zint kno = 0;
 621     zint psysno = 0;
 622     struct it_key key;
 623     struct sortKeyInfo sort_criteria[3];
 624     int num_criteria;
 625     RSFD rfd;
 626     TERMID termid;
 627     TERMID *terms;
 628     int numTerms = 0;
 629
 630     assert(nmem); /* compiler shut up about unused param */
 631     sset->sort_info->num_entries = 0;
 632
 633     rset_getterms(rset, 0, 0, &n);
 634     terms = (TERMID *) nmem_malloc(nmem, sizeof(*terms)*n);
 635     rset_getterms(rset, terms, n, &numTerms);
 636
 637     sset->hits = 0;
 638     num_criteria = sort_sequence->num_specs;
 639     if (num_criteria > 3)
 640         num_criteria = 3;
 641     for (i = 0; i < num_criteria; i++)
 642     {
 643         Z_SortKeySpec *sks = sort_sequence->specs[i];
 644         Z_SortKey *sk;
 645
 646         if (*sks->sortRelation == Z_SortKeySpec_ascending)
 647             sort_criteria[i].relation = 'A';
 648         else if (*sks->sortRelation == Z_SortKeySpec_descending)
 649             sort_criteria[i].relation = 'D';
 650         else
 651         {
 652             zh->errCode = 214;
 653             return;
 654         }
 655         if (sks->sortElement->which == Z_SortElement_databaseSpecific)
 656         {
 657             zh->errCode = 210;
 658             return;
 659         }
 660         else if (sks->sortElement->which != Z_SortElement_generic)
 661         {
 662             zh->errCode = 237;
 663             return;
 664         }
 665         sk = sks->sortElement->u.generic;
 666         switch (sk->which)
 667         {
 668         case Z_SortKey_sortField:
 669             yaz_log(log_level_sorting, "Sort: key %d is of type sortField", i+1);
 670             zh->errCode = 207;
 671             return;
 672         case Z_SortKey_elementSpec:
 673             yaz_log(log_level_sorting, "Sort: key %d is of type elementSpec", i+1);
 674             zh->errCode = 207;
 675             return;
 676         case Z_SortKey_sortAttributes:
 677             yaz_log(log_level_sorting, "Sort: key %d is of type sortAttributes", i+1);
 678             sort_criteria[i].attrUse =
 679                 zebra_maps_sort (zh->reg->zebra_maps,
 680                                  sk->u.sortAttributes,
 681                                  &sort_criteria[i].numerical);
 682             yaz_log(log_level_sorting, "use value = %d", sort_criteria[i].attrUse);
 683             if (sort_criteria[i].attrUse == -1)
 684             {
 685                 zh->errCode = 116;
 686                 return;
 687             }
 688             if (sortIdx_type (zh->reg->sortIdx, sort_criteria[i].attrUse))
 689             {
 690                 zh->errCode = 207;
 691                 return;
 692             }
 693             break;
 694         }
 695     }
 696     rfd = rset_open (rset, RSETF_READ);
 697     while (rset_read (rfd, &key, &termid))
 698       /* FIXME - pass a TERMID *, and use it for something below !! */
 699     {
 700         zint this_sys = key.mem[0];
 701         kno++;
 702         if (this_sys != psysno)
 703         {
 704             (sset->hits)++;
 705             psysno = this_sys;
 706             resultSetInsertSort (zh, sset,
 707                                  sort_criteria, num_criteria, psysno);
 708         }
 709     }
 710     rset_close (rfd);
 711     yaz_log(log_level_sorting, ZINT_FORMAT " keys, " ZINT_FORMAT " sysnos, sort",
 712                     kno, sset->hits);
 713     for (i = 0; i < numTerms; i++)
 714         yaz_log(log_level_sorting, "term=\"%s\" type=%s count=" ZINT_FORMAT,
 715                  terms[i]->name, terms[i]->flags, rset_count(terms[i]->rset));
 716     *sort_status = Z_SortResponse_success;
 717 }
 718
 719 RSET resultSetRef (ZebraHandle zh, const char *resultSetId)
 720 {
 721     ZebraSet s;
 722
 723     if ((s = resultSetGet (zh, resultSetId)))
 724         return s->rset;
 725     return NULL;
 726 }
 727
 728 void resultSetRank (ZebraHandle zh, ZebraSet zebraSet, RSET rset, NMEM nmem)
 729 {
 730     zint kno = 0;
 731     struct it_key key;
 732     RSFD rfd;
 733     TERMID termid;
 734     TERMID *terms;
 735     int numTerms = 0;
 736     int n = 0;
 737     int i;
 738     ZebraRankClass rank_class;
 739     struct rank_control *rc;
 740     struct zset_sort_info *sort_info;
 741     const char *rank_handler_name = res_get_def(zh->res, "rank", "rank-1");
 742     double cur,tot;
 743     zint est=-2; /* -2 not done, -1 can't do, >0 actual estimate*/
 744     zint esthits;
 745     double ratio;
 746
 747     if (!log_level_set)
 748         loglevels();
 749     sort_info = zebraSet->sort_info;
 750     sort_info->num_entries = 0;
 751     zebraSet->hits = 0;
 752     rset_getterms(rset, 0, 0, &n);
 753     terms = (TERMID *) nmem_malloc(nmem, sizeof(*terms)*n);
 754     rset_getterms(rset, terms, n, &numTerms);
 755
 756     rfd = rset_open (rset, RSETF_READ);
 757
 758     rank_class = zebraRankLookup (zh, rank_handler_name);
 759     if (!rank_class)
 760     {
 761         yaz_log(YLOG_WARN, "No such rank handler: %s", rank_handler_name);
 762         return;
 763     }
 764     rc = rank_class->control;
 765
 766     if (rset_read (rfd, &key, &termid))
 767     {
 768         zint psysno = key.mem[0];
 769         int score;
 770         void *handle =
 771             (*rc->begin) (zh->reg, rank_class->class_handle, rset, nmem,
 772                           terms, numTerms);
 773         (zebraSet->hits)++;
 774         esthits = atoi(res_get_def(zh->res, "estimatehits","0"));
 775         if (!esthits)
 776             est = -1; /* can not do */
 777         do
 778         {
 779             zint this_sys = key.mem[0]; /* FIXME - assumes scope==2 */
 780             zint seqno = key.mem[key.len-1]; /* FIXME - assumes scope==2 */
 781             kno++;
 782             key_logdump_txt(log_level_searchhits,&key," Got hit");
 783             if (this_sys != psysno)
 784             {
 785                 score = (*rc->calc) (handle, psysno);
 786
 787                 resultSetInsertRank (zh, sort_info, psysno, score, 'A');
 788                 (zebraSet->hits)++;
 789                 psysno = this_sys;
 790             }
 791             (*rc->add) (handle, seqno, termid);
 792
 793             if ((est==-2) && (zebraSet->hits==esthits))
 794             { /* time to estimate the hits */
 795                 rset_pos(rfd,&cur,&tot);
 796                 if (tot>0) {
 797                     ratio = cur/tot;
 798                     est = (zint)(0.5+zebraSet->hits/ratio);
 799                     yaz_log(log_level_searchhits, "Estimating hits (%s) "
 800                                   "%0.1f->" ZINT_FORMAT
 801                                   "; %0.1f->" ZINT_FORMAT,
 802                                   rset->control->desc,
 803                                   cur, zebraSet->hits,
 804                                   tot, est);
 805                     i = 0; /* round to 3 significant digits */
 806                     while (est>1000) {
 807                         est /= 10;
 808                         i++;
 809                     }
 810                     while (i--)
 811                         est *= 10;
 812                     zebraSet->hits = est;
 813                 }
 814             }
 815         }
 816         while (rset_read (rfd, &key,&termid) && (est<0) );
 817         score = (*rc->calc)(handle, psysno);
 818         resultSetInsertRank(zh, sort_info, psysno, score, 'A');
 819         (*rc->end) (zh->reg, handle);
 820     }
 821     rset_close (rfd);
 822
 823     yaz_log(log_level_searchterms, ZINT_FORMAT " keys, " ZINT_FORMAT " sysnos, rank",
 824             kno, zebraSet->hits);
 825     for (i = 0; i < numTerms; i++)
 826     {
 827         yaz_log(log_level_searchterms, "term=\"%s\" type=%s count=" ZINT_FORMAT,
 828                  terms[i]->name, terms[i]->flags, rset_count(terms[i]->rset));
 829     }
 830 }
 831
 832 ZebraRankClass zebraRankLookup (ZebraHandle zh, const char *name)
 833 {
 834     ZebraRankClass p = zh->reg->rank_classes;
 835     while (p && strcmp (p->control->name, name))
 836         p = p->next;
 837     if (p && !p->init_flag)
 838     {
 839         if (p->control->create)
 840             p->class_handle = (*p->control->create)(zh);
 841         p->init_flag = 1;
 842     }
 843     return p;
 844 }
 845
 846 void zebraRankInstall (struct zebra_register *reg, struct rank_control *ctrl)
 847 {
 848     ZebraRankClass p = (ZebraRankClass) xmalloc (sizeof(*p));
 849     p->control = (struct rank_control *) xmalloc (sizeof(*p->control));
 850     memcpy (p->control, ctrl, sizeof(*p->control));
 851     p->control->name = xstrdup (ctrl->name);
 852     p->init_flag = 0;
 853     p->next = reg->rank_classes;
 854     reg->rank_classes = p;
 855 }
 856
 857 void zebraRankDestroy (struct zebra_register *reg)
 858 {
 859     ZebraRankClass p = reg->rank_classes;
 860     while (p)
 861     {
 862         ZebraRankClass p_next = p->next;
 863         if (p->init_flag && p->control->destroy)
 864             (*p->control->destroy)(reg, p->class_handle);
 865         xfree(p->control->name);
 866         xfree(p->control);
 867         xfree(p);
 868         p = p_next;
 869     }
 870     reg->rank_classes = NULL;
 871 }