index/zsets.c

   1 /* $Id: zsets.c,v 1.96 2005-10-28 07:25:30 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     size_t sysno_mem_index = 0;
 842
 843     if (zh->m_staticrank)
 844         sysno_mem_index = 1;
 845
 846     if (!log_level_set)
 847         loglevels();
 848     sort_info = zebraSet->sort_info;
 849     sort_info->num_entries = 0;
 850     zebraSet->hits = 0;
 851     rset_getterms(rset, 0, 0, &n);
 852     terms = (TERMID *) nmem_malloc(nmem, sizeof(*terms)*n);
 853     rset_getterms(rset, terms, n, &numTerms);
 854
 855
 856     rank_class = zebraRankLookup(zh, rank_handler_name);
 857     if (!rank_class)
 858     {
 859         yaz_log(YLOG_WARN, "No such rank handler: %s", rank_handler_name);
 860         zebra_setError(zh, YAZ_BIB1_UNSUPP_SEARCH, "Cannot find rank handler");
 861         return ZEBRA_FAIL;
 862     }
 863     else
 864     {
 865         RSFD rfd = rset_open(rset, RSETF_READ);
 866         struct rank_control *rc = rank_class->control;
 867         double score;
 868         zint count = 0;
 869
 870         void *handle =
 871             (*rc->begin) (zh->reg, rank_class->class_handle, rset, nmem,
 872                           terms, numTerms);
 873         zint psysno = 0;  /* previous doc id / sys no */
 874         zint pstaticrank = 0; /* previous static rank */
 875         int stop_flag = 0;
 876         while (rset_read(rfd, &key, &termid))
 877         {
 878             zint this_sys = key.mem[sysno_mem_index];
 879
 880             zint seqno = key.mem[key.len-1];
 881             kno++;
 882             if (log_level_searchhits)
 883                 key_logdump_txt(log_level_searchhits, &key, termid->name);
 884             if (this_sys != psysno)
 885             {   /* new record .. */
 886                 if (rfd->counted_items > rset->hits_limit)
 887                     break;
 888                 if (psysno)
 889                 {   /* only if we did have a previous record */
 890                     score = (*rc->calc) (handle, psysno, pstaticrank,
 891                                          &stop_flag);
 892                     /* insert the hit. A=Ascending */
 893                     resultSetInsertRank (zh, sort_info, psysno, score, 'A');
 894                     count++;
 895                     if (stop_flag)
 896                         break;
 897                 }
 898                 psysno = this_sys;
 899                 if (zh->m_staticrank)
 900                     pstaticrank = key.mem[0];
 901             }
 902             (*rc->add) (handle, CAST_ZINT_TO_INT(seqno), termid);
 903         }
 904         /* no more items */
 905         if (psysno)
 906         {   /* we had - at least - one record */
 907             score = (*rc->calc)(handle, psysno, pstaticrank, &stop_flag);
 908             /* insert the hit. A=Ascending */
 909             resultSetInsertRank(zh, sort_info, psysno, score, 'A');
 910             count++;
 911         }
 912         (*rc->end) (zh->reg, handle);
 913         rset_close (rfd);
 914     }
 915     zebraSet->hits = rset->hits_count;
 916
 917     yaz_log(log_level_searchterms, ZINT_FORMAT " keys, "
 918             ZINT_FORMAT " sysnos, rank",  kno, zebraSet->hits);
 919     for (i = 0; i < numTerms; i++)
 920     {
 921         yaz_log(log_level_searchterms, "term=\"%s\" type=%s count="
 922                 ZINT_FORMAT,
 923                 terms[i]->name, terms[i]->flags, terms[i]->rset->hits_count);
 924     }
 925     return ZEBRA_OK;
 926 }
 927
 928 ZebraRankClass zebraRankLookup(ZebraHandle zh, const char *name)
 929 {
 930     ZebraRankClass p = zh->reg->rank_classes;
 931     while (p && strcmp (p->control->name, name))
 932         p = p->next;
 933     if (p && !p->init_flag)
 934     {
 935         if (p->control->create)
 936             p->class_handle = (*p->control->create)(zh);
 937         p->init_flag = 1;
 938     }
 939     return p;
 940 }
 941
 942 void zebraRankInstall(struct zebra_register *reg, struct rank_control *ctrl)
 943 {
 944     ZebraRankClass p = (ZebraRankClass) xmalloc (sizeof(*p));
 945     p->control = (struct rank_control *) xmalloc (sizeof(*p->control));
 946     memcpy (p->control, ctrl, sizeof(*p->control));
 947     p->control->name = xstrdup (ctrl->name);
 948     p->init_flag = 0;
 949     p->next = reg->rank_classes;
 950     reg->rank_classes = p;
 951 }
 952
 953 void zebraRankDestroy(struct zebra_register *reg)
 954 {
 955     ZebraRankClass p = reg->rank_classes;
 956     while (p)
 957     {
 958         ZebraRankClass p_next = p->next;
 959         if (p->init_flag && p->control->destroy)
 960             (*p->control->destroy)(reg, p->class_handle);
 961         xfree(p->control->name);
 962         xfree(p->control);
 963         xfree(p);
 964         p = p_next;
 965     }
 966     reg->rank_classes = NULL;
 967 }
 968
 969 static int trav_rset_for_termids(RSET rset, TERMID *termid_array,
 970                                  zint *hits_array, int *approx_array)
 971 {
 972     int no = 0;
 973     int i;
 974     for (i = 0; i<rset->no_children; i++)
 975         no += trav_rset_for_termids(rset->children[i],
 976                                     (termid_array ? termid_array + no : 0),
 977                                     (hits_array ? hits_array + no : 0),
 978                                     (approx_array ? approx_array + no : 0));
 979     if (rset->term)
 980     {
 981         if (termid_array)
 982             termid_array[no] = rset->term;
 983         if (hits_array)
 984             hits_array[no] = rset->hits_count;
 985         if (approx_array)
 986             approx_array[no] = rset->hits_approx;
 987 #if 0
 988         yaz_log(YLOG_LOG, "rset=%p term=%s limit=" ZINT_FORMAT
 989                 " count=" ZINT_FORMAT,
 990                 rset, rset->term->name, rset->hits_limit, rset->hits_count);
 991 #endif
 992         no++;
 993     }
 994     return no;
 995 }
 996
 997 ZEBRA_RES zebra_result_set_term_no(ZebraHandle zh, const char *setname,
 998                                    int *num_terms)
 999 {
1000     ZebraSet sset = resultSetGet(zh, setname);
1001     *num_terms = 0;
1002     if (sset)
1003     {
1004         *num_terms = trav_rset_for_termids(sset->rset, 0, 0, 0);
1005         return ZEBRA_OK;
1006     }
1007     return ZEBRA_FAIL;
1008 }
1009
1010 ZEBRA_RES zebra_result_set_term_info(ZebraHandle zh, const char *setname,
1011                                      int no, zint *count, int *approx,
1012                                      char *termbuf, size_t *termlen,
1013                                      const char **term_ref_id)
1014 {
1015     ZebraSet sset = resultSetGet(zh, setname);
1016     if (sset)
1017     {
1018         int num_terms = trav_rset_for_termids(sset->rset, 0, 0, 0);
1019         if (no >= 0 && no < num_terms)
1020         {
1021             TERMID *term_array = xmalloc(num_terms * sizeof(*term_array));
1022             zint *hits_array = xmalloc(num_terms * sizeof(*hits_array));
1023             int *approx_array = xmalloc(num_terms * sizeof(*approx_array));
1024
1025             trav_rset_for_termids(sset->rset, term_array,
1026                                   hits_array, approx_array);
1027
1028             if (count)
1029                 *count = hits_array[no];
1030             if (approx)
1031                 *approx = approx_array[no];
1032             if (termbuf)
1033             {
1034                 char *inbuf = term_array[no]->name;
1035                 size_t inleft = strlen(inbuf);
1036                 size_t outleft = *termlen - 1;
1037
1038                 if (zh->iconv_from_utf8 != 0)
1039                 {
1040                     char *outbuf = termbuf;
1041                     size_t ret;
1042
1043                     ret = yaz_iconv(zh->iconv_from_utf8, &inbuf, &inleft,
1044                                     &outbuf, &outleft);
1045                     if (ret == (size_t)(-1))
1046                         *termlen = 0;
1047                     else
1048                         *termlen = outbuf - termbuf;
1049                 }
1050                 else
1051                 {
1052                     if (inleft > outleft)
1053                         inleft = outleft;
1054                     *termlen = inleft;
1055                     memcpy(termbuf, inbuf, *termlen);
1056                 }
1057                 termbuf[*termlen] = '\0';
1058             }
1059             if (term_ref_id)
1060                 *term_ref_id = term_array[no]->ref_id;
1061
1062             xfree(term_array);
1063             xfree(hits_array);
1064             xfree(approx_array);
1065             return ZEBRA_OK;
1066         }
1067     }
1068     return ZEBRA_FAIL;
1069 }
1070
1071 ZEBRA_RES zebra_snippets_hit_vector(ZebraHandle zh, const char *setname,
1072                                     zint sysno, zebra_snippets *snippets)
1073 {
1074     ZebraSet sset = resultSetGet(zh, setname);
1075     yaz_log(YLOG_DEBUG, "zebra_get_hit_vector setname=%s zysno=" ZINT_FORMAT,
1076             setname, sysno);
1077     if (!sset)
1078         return ZEBRA_FAIL;
1079     else
1080     {
1081         struct rset_key_control *kc = zebra_key_control_create(zh);
1082         NMEM nmem = nmem_create();
1083         struct it_key key;
1084         RSET rsets[2], rset_comb;
1085         RSET rset_temp = rstemp_create(nmem, kc, kc->scope,
1086                                        res_get (zh->res, "setTmpDir"),0 );
1087
1088         TERMID termid;
1089         RSFD rsfd = rset_open(rset_temp, RSETF_WRITE);
1090
1091         key.mem[0] = sysno;
1092         key.mem[1] = 0;
1093         key.mem[2] = 0;
1094         key.mem[3] = 0;
1095         key.len = 2;
1096         rset_write (rsfd, &key);
1097         rset_close (rsfd);
1098
1099         rsets[0] = rset_temp;
1100         rsets[1] = rset_dup(sset->rset);
1101
1102         rset_comb = rsmulti_and_create(nmem, kc, kc->scope, 2, rsets);
1103
1104         rsfd = rset_open(rset_comb, RSETF_READ);
1105
1106         while (rset_read(rsfd, &key, &termid))
1107         {
1108             if (termid)
1109             {
1110                 struct ord_list *ol;
1111                 for (ol = termid->ol; ol; ol = ol->next)
1112                 {
1113                     zebra_snippets_append(snippets, key.mem[key.len-1],
1114                                           ol->ord, termid->name);
1115                 }
1116             }
1117         }
1118         rset_close(rsfd);
1119
1120         rset_delete(rset_comb);
1121         nmem_destroy(nmem);
1122         kc->dec(kc);
1123     }
1124     return ZEBRA_OK;
1125 }
1126