index/zsets.c

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