index/zsets.c

   1 /* $Id: zsets.c,v 1.91 2005-08-18 12:50:18 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     size_t sysno_mem_index = 0;
 402
 403     if (zh->m_staticrank)
 404         sysno_mem_index = 1;
 405
 406     if (!log_level_set)
 407         loglevels();
 408     if (!(sset = resultSetGet (zh, name)))
 409         return NULL;
 410     if (!(rset = sset->rset))
 411     {
 412         if (!sset->term_entries)
 413             return 0;
 414         sr = (ZebraMetaRecord *) xmalloc (sizeof(*sr) * num);
 415         for (i = 0; i<num; i++)
 416         {
 417             sr[i].sysno = 0;
 418             sr[i].score = -1;
 419             sr[i].term = 0;
 420             sr[i].db = 0;
 421
 422             if (positions[i] <= sset->term_entries_max)
 423             {
 424                 sr[i].term = sset->term_entries[positions[i]-1].term;
 425                 sr[i].db = sset->term_entries[positions[i]-1].db;
 426             }
 427         }
 428     }
 429     else
 430     {
 431         sr = (ZebraMetaRecord *) xmalloc (sizeof(*sr) * num);
 432         for (i = 0; i<num; i++)
 433         {
 434             sr[i].sysno = 0;
 435             sr[i].score = -1;
 436             sr[i].term = 0;
 437             sr[i].db = 0;
 438         }
 439         sort_info = sset->sort_info;
 440         if (sort_info)
 441         {
 442             zint position;
 443
 444             for (i = 0; i<num; i++)
 445             {
 446                 position = positions[i];
 447                 if (position > 0 && position <= sort_info->num_entries)
 448                 {
 449                     yaz_log(log_level_sort, "got pos=" ZINT_FORMAT
 450                             " (sorted)", position);
 451                     sr[i].sysno = sort_info->entries[position-1]->sysno;
 452                     sr[i].score = sort_info->entries[position-1]->score;
 453                 }
 454             }
 455         }
 456         /* did we really get all entries using sort ? */
 457         for (i = 0; i<num; i++)
 458         {
 459             if (!sr[i].sysno)
 460                 break;
 461         }
 462         if (i < num) /* nope, get the rest, unsorted - sorry */
 463         {
 464             zint position = 0;
 465             int num_i = 0;
 466             zint psysno = 0;
 467             RSFD rfd;
 468             struct it_key key;
 469
 470             if (sort_info)
 471                 position = sort_info->num_entries;
 472             while (num_i < num && positions[num_i] <= position)
 473                 num_i++;
 474
 475             if (sset->cache_rfd &&
 476                 num_i < num && positions[num_i] > sset->cache_position)
 477             {
 478                 position = sset->cache_position;
 479                 rfd = sset->cache_rfd;
 480                 psysno = sset->cache_psysno;
 481             }
 482             else
 483             {
 484                 if (sset->cache_rfd)
 485                     rset_close(sset->cache_rfd);
 486                 rfd = rset_open (rset, RSETF_READ);
 487             }
 488             while (num_i < num && rset_read (rfd, &key, 0))
 489             {
 490                 zint this_sys = key.mem[sysno_mem_index];
 491                 if (this_sys != psysno)
 492                 {
 493                     psysno = this_sys;
 494                     if (sort_info)
 495                     {
 496                         /* determine we alreay have this in our set */
 497                         for (i = sort_info->num_entries; --i >= 0; )
 498                             if (psysno == sort_info->entries[i]->sysno)
 499                                 break;
 500                         if (i >= 0)
 501                             continue;
 502                     }
 503                     position++;
 504                     assert (num_i < num);
 505                     if (position == positions[num_i])
 506                     {
 507                         sr[num_i].sysno = psysno;
 508                         yaz_log(log_level_sort, "got pos=" ZINT_FORMAT " (unsorted)", position);
 509                         sr[num_i].score = -1;
 510                         num_i++;
 511                     }
 512                 }
 513             }
 514             sset->cache_position = position;
 515             sset->cache_psysno = psysno;
 516             sset->cache_rfd = rfd;
 517         }
 518     }
 519     return sr;
 520 }
 521
 522 void zebra_meta_records_destroy (ZebraHandle zh, ZebraMetaRecord *records,
 523                                  int num)
 524 {
 525     assert(zh); /* compiler shut up about unused arg */
 526     xfree (records);
 527 }
 528
 529 struct sortKeyInfo {
 530     int relation;
 531     int attrUse;
 532     int numerical;
 533 };
 534
 535 void resultSetInsertSort (ZebraHandle zh, ZebraSet sset,
 536                           struct sortKeyInfo *criteria, int num_criteria,
 537                           zint sysno)
 538 {
 539     struct zset_sort_entry this_entry;
 540     struct zset_sort_entry *new_entry = NULL;
 541     struct zset_sort_info *sort_info = sset->sort_info;
 542     int i, j;
 543
 544     sortIdx_sysno (zh->reg->sortIdx, sysno);
 545     for (i = 0; i<num_criteria; i++)
 546     {
 547         sortIdx_type (zh->reg->sortIdx, criteria[i].attrUse);
 548         sortIdx_read (zh->reg->sortIdx, this_entry.buf[i]);
 549     }
 550     i = sort_info->num_entries;
 551     while (--i >= 0)
 552     {
 553         int rel = 0;
 554         for (j = 0; j<num_criteria; j++)
 555         {
 556             if (criteria[j].numerical)
 557             {
 558                 double diff = atof(this_entry.buf[j]) -
 559                               atof(sort_info->entries[i]->buf[j]);
 560                 rel = 0;
 561                 if (diff > 0.0)
 562                     rel = 1;
 563                 else if (diff < 0.0)
 564                     rel = -1;
 565             }
 566             else
 567             {
 568                 rel = memcmp (this_entry.buf[j], sort_info->entries[i]->buf[j],
 569                           SORT_IDX_ENTRYSIZE);
 570             }
 571             if (rel)
 572                 break;
 573         }
 574         if (!rel)
 575             break;
 576         if (criteria[j].relation == 'A')
 577         {
 578             if (rel > 0)
 579                 break;
 580         }
 581         else if (criteria[j].relation == 'D')
 582         {
 583             if (rel < 0)
 584                 break;
 585         }
 586     }
 587     ++i;
 588     j = sort_info->max_entries;
 589     if (i == j)
 590         return;
 591
 592     if (sort_info->num_entries == j)
 593         --j;
 594     else
 595         j = (sort_info->num_entries)++;
 596     new_entry = sort_info->entries[j];
 597     while (j != i)
 598     {
 599         sort_info->entries[j] = sort_info->entries[j-1];
 600         --j;
 601     }
 602     sort_info->entries[i] = new_entry;
 603     assert (new_entry);
 604     for (i = 0; i<num_criteria; i++)
 605         memcpy (new_entry->buf[i], this_entry.buf[i], SORT_IDX_ENTRYSIZE);
 606     new_entry->sysno = sysno;
 607     new_entry->score = -1;
 608 }
 609
 610 void resultSetInsertRank (ZebraHandle zh, struct zset_sort_info *sort_info,
 611                           zint sysno, int score, int relation)
 612 {
 613     struct zset_sort_entry *new_entry = NULL;
 614     int i, j;
 615     assert(zh); /* compiler shut up about unused arg */
 616
 617     i = sort_info->num_entries;
 618     while (--i >= 0)
 619     {
 620         int rel = 0;
 621
 622         rel = score - sort_info->entries[i]->score;
 623
 624         if (relation == 'D')
 625         {
 626             if (rel >= 0)
 627                 break;
 628         }
 629         else if (relation == 'A')
 630         {
 631             if (rel <= 0)
 632                 break;
 633         }
 634     }
 635     ++i;
 636     j = sort_info->max_entries;
 637     if (i == j)
 638         return;
 639
 640     if (sort_info->num_entries == j)
 641         --j;
 642     else
 643         j = (sort_info->num_entries)++;
 644
 645     new_entry = sort_info->entries[j];
 646     while (j != i)
 647     {
 648         sort_info->entries[j] = sort_info->entries[j-1];
 649         --j;
 650     }
 651     sort_info->entries[i] = new_entry;
 652     assert (new_entry);
 653     new_entry->sysno = sysno;
 654     new_entry->score = score;
 655 }
 656
 657 ZEBRA_RES resultSetSort(ZebraHandle zh, NMEM nmem,
 658                         int num_input_setnames, const char **input_setnames,
 659                         const char *output_setname,
 660                         Z_SortKeySpecList *sort_sequence, int *sort_status)
 661 {
 662     ZebraSet sset;
 663     RSET rset;
 664
 665     if (num_input_setnames == 0)
 666     {
 667         zebra_setError(zh, YAZ_BIB1_NO_RESULT_SET_NAME_SUPPLIED_ON_SORT, 0);
 668         return ZEBRA_FAIL;
 669     }
 670     if (num_input_setnames > 1)
 671     {
 672         zebra_setError(zh, YAZ_BIB1_SORT_TOO_MANY_INPUT_RESULTS, 0);
 673         return ZEBRA_FAIL;
 674     }
 675     if (!log_level_set)
 676         loglevels();
 677     yaz_log(log_level_sort, "result set sort input=%s output=%s",
 678           *input_setnames, output_setname);
 679     sset = resultSetGet (zh, input_setnames[0]);
 680     if (!sset)
 681     {
 682         zebra_setError(zh, YAZ_BIB1_SPECIFIED_RESULT_SET_DOES_NOT_EXIST,
 683                        input_setnames[0]);
 684         return ZEBRA_FAIL;
 685     }
 686     if (!(rset = sset->rset))
 687     {
 688         zebra_setError(zh, YAZ_BIB1_SPECIFIED_RESULT_SET_DOES_NOT_EXIST,
 689                        input_setnames[0]);
 690         return ZEBRA_FAIL;
 691     }
 692     if (strcmp (output_setname, input_setnames[0]))
 693     {
 694         rset = rset_dup (rset);
 695         sset = resultSetAdd (zh, output_setname, 1);
 696         sset->rset = rset;
 697     }
 698     return resultSetSortSingle (zh, nmem, sset, rset, sort_sequence,
 699                                 sort_status);
 700 }
 701
 702 ZEBRA_RES resultSetSortSingle(ZebraHandle zh, NMEM nmem,
 703                               ZebraSet sset, RSET rset,
 704                               Z_SortKeySpecList *sort_sequence,
 705                               int *sort_status)
 706 {
 707     int i;
 708     int n = 0;
 709     zint kno = 0;
 710     zint psysno = 0;
 711     struct it_key key;
 712     struct sortKeyInfo sort_criteria[3];
 713     int num_criteria;
 714     RSFD rfd;
 715     TERMID termid;
 716     TERMID *terms;
 717     int numTerms = 0;
 718     size_t sysno_mem_index = 0;
 719
 720     if (zh->m_staticrank)
 721         sysno_mem_index = 1;
 722
 723
 724     assert(nmem); /* compiler shut up about unused param */
 725     sset->sort_info->num_entries = 0;
 726
 727     rset_getterms(rset, 0, 0, &n);
 728     terms = (TERMID *) nmem_malloc(nmem, sizeof(*terms)*n);
 729     rset_getterms(rset, terms, n, &numTerms);
 730
 731     sset->hits = 0;
 732     num_criteria = sort_sequence->num_specs;
 733     if (num_criteria > 3)
 734         num_criteria = 3;
 735     for (i = 0; i < num_criteria; i++)
 736     {
 737         Z_SortKeySpec *sks = sort_sequence->specs[i];
 738         Z_SortKey *sk;
 739
 740         if (*sks->sortRelation == Z_SortKeySpec_ascending)
 741             sort_criteria[i].relation = 'A';
 742         else if (*sks->sortRelation == Z_SortKeySpec_descending)
 743             sort_criteria[i].relation = 'D';
 744         else
 745         {
 746             zebra_setError(zh, YAZ_BIB1_ILLEGAL_SORT_RELATION, 0);
 747             return ZEBRA_FAIL;
 748         }
 749         if (sks->sortElement->which == Z_SortElement_databaseSpecific)
 750         {
 751             zebra_setError(zh, YAZ_BIB1_DATABASE_SPECIFIC_SORT_UNSUPP, 0);
 752             return ZEBRA_FAIL;
 753         }
 754         else if (sks->sortElement->which != Z_SortElement_generic)
 755         {
 756             zebra_setError(zh, YAZ_BIB1_SORT_ILLEGAL_SORT, 0);
 757             return ZEBRA_FAIL;
 758         }
 759         sk = sks->sortElement->u.generic;
 760         switch (sk->which)
 761         {
 762         case Z_SortKey_sortField:
 763             yaz_log(log_level_sort, "key %d is of type sortField",
 764                     i+1);
 765             zebra_setError(zh, YAZ_BIB1_CANNOT_SORT_ACCORDING_TO_SEQUENCE, 0);
 766             return ZEBRA_FAIL;
 767         case Z_SortKey_elementSpec:
 768             yaz_log(log_level_sort, "key %d is of type elementSpec",
 769                     i+1);
 770             zebra_setError(zh, YAZ_BIB1_CANNOT_SORT_ACCORDING_TO_SEQUENCE, 0);
 771             return ZEBRA_FAIL;
 772         case Z_SortKey_sortAttributes:
 773             yaz_log(log_level_sort, "key %d is of type sortAttributes", i+1);
 774             sort_criteria[i].attrUse =
 775                 zebra_maps_sort (zh->reg->zebra_maps,
 776                                  sk->u.sortAttributes,
 777                                  &sort_criteria[i].numerical);
 778             yaz_log(log_level_sort, "use value = %d", sort_criteria[i].attrUse);
 779             if (sort_criteria[i].attrUse == -1)
 780             {
 781                 zebra_setError(
 782                     zh, YAZ_BIB1_USE_ATTRIBUTE_REQUIRED_BUT_NOT_SUPPLIED, 0);
 783                 return ZEBRA_FAIL;
 784             }
 785             if (sortIdx_type (zh->reg->sortIdx, sort_criteria[i].attrUse))
 786             {
 787                 zebra_setError(
 788                     zh, YAZ_BIB1_CANNOT_SORT_ACCORDING_TO_SEQUENCE, 0);
 789                 return ZEBRA_FAIL;
 790             }
 791             break;
 792         }
 793     }
 794     rfd = rset_open (rset, RSETF_READ);
 795     while (rset_read (rfd, &key, &termid))
 796     {
 797         zint this_sys = key.mem[sysno_mem_index];
 798         if (log_level_searchhits)
 799             key_logdump_txt(log_level_searchhits, &key, termid->name);
 800         kno++;
 801         if (this_sys != psysno)
 802         {
 803             (sset->hits)++;
 804             psysno = this_sys;
 805             resultSetInsertSort (zh, sset,
 806                                  sort_criteria, num_criteria, psysno);
 807         }
 808     }
 809     rset_close (rfd);
 810     yaz_log(log_level_sort, ZINT_FORMAT " keys, " ZINT_FORMAT " sysnos, sort",
 811             kno, sset->hits);
 812     for (i = 0; i < numTerms; i++)
 813         yaz_log(log_level_sort, "term=\"%s\" type=%s count=" ZINT_FORMAT,
 814                  terms[i]->name, terms[i]->flags, terms[i]->rset->hits_count);
 815     *sort_status = Z_SortResponse_success;
 816     return ZEBRA_OK;
 817 }
 818
 819 RSET resultSetRef(ZebraHandle zh, const char *resultSetId)
 820 {
 821     ZebraSet s;
 822
 823     if ((s = resultSetGet (zh, resultSetId)))
 824         return s->rset;
 825     return NULL;
 826 }
 827
 828 ZEBRA_RES resultSetRank(ZebraHandle zh, ZebraSet zebraSet,
 829                         RSET rset, NMEM nmem)
 830 {
 831     struct it_key key;
 832     TERMID termid;
 833     TERMID *terms;
 834     zint kno = 0;
 835     int numTerms = 0;
 836     int n = 0;
 837     int i;
 838     ZebraRankClass rank_class;
 839     struct zset_sort_info *sort_info;
 840     const char *rank_handler_name = res_get_def(zh->res, "rank", "rank-1");
 841
 842     if (!log_level_set)
 843         loglevels();
 844     sort_info = zebraSet->sort_info;
 845     sort_info->num_entries = 0;
 846     zebraSet->hits = 0;
 847     rset_getterms(rset, 0, 0, &n);
 848     terms = (TERMID *) nmem_malloc(nmem, sizeof(*terms)*n);
 849     rset_getterms(rset, terms, n, &numTerms);
 850     size_t sysno_mem_index = 0;
 851
 852     if (zh->m_staticrank)
 853         sysno_mem_index = 1;
 854
 855     rank_class = zebraRankLookup(zh, rank_handler_name);
 856     if (!rank_class)
 857     {
 858         yaz_log(YLOG_WARN, "No such rank handler: %s", rank_handler_name);
 859         zebra_setError(zh, YAZ_BIB1_UNSUPP_SEARCH, "Cannot find rank handler");
 860         return ZEBRA_FAIL;
 861     }
 862     else
 863     {
 864         RSFD rfd = rset_open(rset, RSETF_READ);
 865         struct rank_control *rc = rank_class->control;
 866         double score;
 867         zint count = 0;
 868
 869         void *handle =
 870             (*rc->begin) (zh->reg, rank_class->class_handle, rset, nmem,
 871                           terms, numTerms);
 872         zint psysno = 0;
 873         while (rset_read(rfd, &key, &termid))
 874         {
 875             zint this_sys = key.mem[sysno_mem_index];
 876             zint seqno = key.mem[key.len-1];
 877             kno++;
 878             if (log_level_searchhits)
 879                 key_logdump_txt(log_level_searchhits, &key, termid->name);
 880             if (this_sys != psysno)
 881             {
 882                 if (rfd->counted_items > rset->hits_limit)
 883                     break;
 884                 if (psysno)
 885                 {
 886                     score = (*rc->calc) (handle, psysno);
 887                     resultSetInsertRank (zh, sort_info, psysno, score, 'A');
 888                     count++;
 889                 }
 890                 psysno = this_sys;
 891             }
 892             (*rc->add) (handle, CAST_ZINT_TO_INT(seqno), termid);
 893         }
 894         if (psysno)
 895         {
 896             score = (*rc->calc)(handle, psysno);
 897             resultSetInsertRank(zh, sort_info, psysno, score, 'A');
 898             count++;
 899         }
 900         (*rc->end) (zh->reg, handle);
 901         rset_close (rfd);
 902     }
 903     zebraSet->hits = rset->hits_count;
 904
 905     yaz_log(log_level_searchterms, ZINT_FORMAT " keys, "
 906             ZINT_FORMAT " sysnos, rank",  kno, zebraSet->hits);
 907     for (i = 0; i < numTerms; i++)
 908     {
 909         yaz_log(log_level_searchterms, "term=\"%s\" type=%s count="
 910                 ZINT_FORMAT,
 911                 terms[i]->name, terms[i]->flags, terms[i]->rset->hits_count);
 912     }
 913     return ZEBRA_OK;
 914 }
 915
 916 ZebraRankClass zebraRankLookup(ZebraHandle zh, const char *name)
 917 {
 918     ZebraRankClass p = zh->reg->rank_classes;
 919     while (p && strcmp (p->control->name, name))
 920         p = p->next;
 921     if (p && !p->init_flag)
 922     {
 923         if (p->control->create)
 924             p->class_handle = (*p->control->create)(zh);
 925         p->init_flag = 1;
 926     }
 927     return p;
 928 }
 929
 930 void zebraRankInstall(struct zebra_register *reg, struct rank_control *ctrl)
 931 {
 932     ZebraRankClass p = (ZebraRankClass) xmalloc (sizeof(*p));
 933     p->control = (struct rank_control *) xmalloc (sizeof(*p->control));
 934     memcpy (p->control, ctrl, sizeof(*p->control));
 935     p->control->name = xstrdup (ctrl->name);
 936     p->init_flag = 0;
 937     p->next = reg->rank_classes;
 938     reg->rank_classes = p;
 939 }
 940
 941 void zebraRankDestroy(struct zebra_register *reg)
 942 {
 943     ZebraRankClass p = reg->rank_classes;
 944     while (p)
 945     {
 946         ZebraRankClass p_next = p->next;
 947         if (p->init_flag && p->control->destroy)
 948             (*p->control->destroy)(reg, p->class_handle);
 949         xfree(p->control->name);
 950         xfree(p->control);
 951         xfree(p);
 952         p = p_next;
 953     }
 954     reg->rank_classes = NULL;
 955 }
 956
 957 static int trav_rset_for_termids(RSET rset, TERMID *termid_array,
 958                                  zint *hits_array, int *approx_array)
 959 {
 960     int no = 0;
 961     int i;
 962     for (i = 0; i<rset->no_children; i++)
 963         no += trav_rset_for_termids(rset->children[i],
 964                                     (termid_array ? termid_array + no : 0),
 965                                     (hits_array ? hits_array + no : 0),
 966                                     (approx_array ? approx_array + no : 0));
 967     if (rset->term)
 968     {
 969         if (termid_array)
 970             termid_array[no] = rset->term;
 971         if (hits_array)
 972             hits_array[no] = rset->hits_count;
 973         if (approx_array)
 974             approx_array[no] = rset->hits_approx;
 975 #if 0
 976         yaz_log(YLOG_LOG, "rset=%p term=%s limit=" ZINT_FORMAT
 977                 " count=" ZINT_FORMAT,
 978                 rset, rset->term->name, rset->hits_limit, rset->hits_count);
 979 #endif
 980         no++;
 981     }
 982     return no;
 983 }
 984
 985 ZEBRA_RES zebra_result_set_term_no(ZebraHandle zh, const char *setname,
 986                                    int *num_terms)
 987 {
 988     ZebraSet sset = resultSetGet(zh, setname);
 989     *num_terms = 0;
 990     if (sset)
 991     {
 992         *num_terms = trav_rset_for_termids(sset->rset, 0, 0, 0);
 993         return ZEBRA_OK;
 994     }
 995     return ZEBRA_FAIL;
 996 }
 997
 998 ZEBRA_RES zebra_result_set_term_info(ZebraHandle zh, const char *setname,
 999                                      int no, zint *count, int *approx,
1000                                      char *termbuf, size_t *termlen,
1001                                      const char **term_ref_id)
1002 {
1003     ZebraSet sset = resultSetGet(zh, setname);
1004     if (sset)
1005     {
1006         int num_terms = trav_rset_for_termids(sset->rset, 0, 0, 0);
1007         if (no >= 0 && no < num_terms)
1008         {
1009             TERMID *term_array = xmalloc(num_terms * sizeof(*term_array));
1010             zint *hits_array = xmalloc(num_terms * sizeof(*hits_array));
1011             int *approx_array = xmalloc(num_terms * sizeof(*approx_array));
1012
1013             trav_rset_for_termids(sset->rset, term_array,
1014                                   hits_array, approx_array);
1015
1016             if (count)
1017                 *count = hits_array[no];
1018             if (approx)
1019                 *approx = approx_array[no];
1020             if (termbuf)
1021             {
1022                 char *inbuf = term_array[no]->name;
1023                 size_t inleft = strlen(inbuf);
1024                 size_t outleft = *termlen - 1;
1025
1026                 if (zh->iconv_from_utf8 != 0)
1027                 {
1028                     char *outbuf = termbuf;
1029                     size_t ret;
1030
1031                     ret = yaz_iconv(zh->iconv_from_utf8, &inbuf, &inleft,
1032                                     &outbuf, &outleft);
1033                     if (ret == (size_t)(-1))
1034                         *termlen = 0;
1035                     else
1036                         *termlen = outbuf - termbuf;
1037                 }
1038                 else
1039                 {
1040                     if (inleft > outleft)
1041                         inleft = outleft;
1042                     *termlen = inleft;
1043                     memcpy(termbuf, inbuf, *termlen);
1044                 }
1045                 termbuf[*termlen] = '\0';
1046             }
1047             if (term_ref_id)
1048                 *term_ref_id = term_array[no]->ref_id;
1049
1050             xfree(term_array);
1051             xfree(hits_array);
1052             xfree(approx_array);
1053             return ZEBRA_OK;
1054         }
1055     }
1056     return ZEBRA_FAIL;
1057 }
1058
1059 ZEBRA_RES zebra_snippets_hit_vector(ZebraHandle zh, const char *setname,
1060                                     zint sysno, zebra_snippets *snippets)
1061 {
1062     ZebraSet sset = resultSetGet(zh, setname);
1063     yaz_log(YLOG_LOG, "zebra_get_hit_vector setname=%s zysno=" ZINT_FORMAT,
1064             setname, sysno);
1065     if (!sset)
1066         return ZEBRA_FAIL;
1067     else
1068     {
1069         struct rset_key_control *kc = zebra_key_control_create(zh);
1070         NMEM nmem = nmem_create();
1071         struct it_key key;
1072         RSET rsets[2], rset_comb;
1073         RSET rset_temp = rstemp_create(nmem, kc, kc->scope,
1074                                        res_get (zh->res, "setTmpDir"),0 );
1075
1076         TERMID termid;
1077         RSFD rsfd = rset_open(rset_temp, RSETF_WRITE);
1078
1079         key.mem[0] = sysno;
1080         key.mem[1] = 0;
1081         key.mem[2] = 0;
1082         key.mem[3] = 0;
1083         key.len = 2;
1084         rset_write (rsfd, &key);
1085         rset_close (rsfd);
1086
1087         rsets[0] = rset_temp;
1088         rsets[1] = rset_dup(sset->rset);
1089
1090         rset_comb = rsmulti_and_create(nmem, kc, kc->scope, 2, rsets);
1091
1092         rsfd = rset_open(rset_comb, RSETF_READ);
1093
1094         while (rset_read(rsfd, &key, &termid))
1095         {
1096             if (termid)
1097             {
1098                 struct ord_list *ol;
1099                 for (ol = termid->ol; ol; ol = ol->next)
1100                 {
1101                     zebra_snippets_append(snippets, key.mem[key.len-1],
1102                                           termid->reg_type,
1103                                           ol->ord, termid->name);
1104                 }
1105             }
1106         }
1107         rset_close(rsfd);
1108
1109         rset_delete(rset_comb);
1110         nmem_destroy(nmem);
1111     }
1112     return ZEBRA_OK;
1113 }
1114