index/zsets.c

   1 /* $Id: zsets.c,v 1.99 2006-01-26 22:17:16 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     Z_SortKeySpecList *sortSpec;
  57     struct zset_sort_info *sort_info;
  58     struct zebra_set_term_entry *term_entries;
  59     int term_entries_max;
  60     struct zebra_set *next;
  61     int locked;
  62
  63     zint cache_position;  /* last position */
  64     RSFD cache_rfd;       /* rfd (NULL if not existing) */
  65     zint cache_psysno;    /* sysno for last position */
  66     zint approx_limit;    /* limit before we do approx */
  67 };
  68
  69 struct zset_sort_entry {
  70     zint sysno;
  71     int score;
  72     char buf[ZSET_SORT_MAX_LEVEL][SORT_IDX_ENTRYSIZE];
  73 };
  74
  75 struct zset_sort_info {
  76     int max_entries;
  77     int num_entries;
  78     struct zset_sort_entry *all_entries;
  79     struct zset_sort_entry **entries;
  80 };
  81
  82 static int log_level_set=0;
  83 static int log_level_sort=0;
  84 static int log_level_searchhits=0;
  85 static int log_level_searchterms=0;
  86 static int log_level_resultsets=0;
  87
  88 static void loglevels()
  89 {
  90     if (log_level_set)
  91         return;
  92     log_level_sort = yaz_log_module_level("sorting");
  93     log_level_searchhits = yaz_log_module_level("searchhits");
  94     log_level_searchterms = yaz_log_module_level("searchterms");
  95     log_level_resultsets = yaz_log_module_level("resultsets");
  96     log_level_set = 1;
  97 }
  98
  99 ZEBRA_RES resultSetSearch(ZebraHandle zh, NMEM nmem, NMEM rset_nmem,
 100                           Z_RPNQuery *rpn, ZebraSet sset)
 101 {
 102     RSET rset = 0;
 103     oident *attrset;
 104     Z_SortKeySpecList *sort_sequence;
 105     int sort_status, i;
 106     ZEBRA_RES res = ZEBRA_OK;
 107
 108     zh->hits = 0;
 109
 110     sort_sequence = (Z_SortKeySpecList *)
 111         nmem_malloc(nmem, sizeof(*sort_sequence));
 112     sort_sequence->num_specs = 10; /* FIXME - Hard-coded number */
 113     sort_sequence->specs = (Z_SortKeySpec **)
 114         nmem_malloc(nmem, sort_sequence->num_specs *
 115                      sizeof(*sort_sequence->specs));
 116     for (i = 0; i<sort_sequence->num_specs; i++)
 117         sort_sequence->specs[i] = 0;
 118
 119     attrset = oid_getentbyoid (rpn->attributeSetId);
 120     res = rpn_search_top(zh, rpn->RPNStructure, attrset->value,
 121                          nmem, rset_nmem,
 122                          sort_sequence,
 123                          sset->num_bases, sset->basenames,
 124                          &rset);
 125     if (res != ZEBRA_OK)
 126     {
 127         sset->rset = 0;
 128         return res;
 129     }
 130     for (i = 0; sort_sequence->specs[i]; i++)
 131         ;
 132     sort_sequence->num_specs = i;
 133     rset->hits_limit = sset->approx_limit;
 134     if (!i)
 135     {
 136         res = resultSetRank (zh, sset, rset, rset_nmem);
 137     }
 138     else
 139     {
 140         res = resultSetSortSingle (zh, nmem, sset, rset,
 141                                    sort_sequence, &sort_status);
 142     }
 143     sset->rset = rset;
 144     return res;
 145 }
 146
 147
 148 ZEBRA_RES resultSetAddRPN (ZebraHandle zh, NMEM m, Z_RPNQuery *rpn,
 149                            int num_bases, char **basenames,
 150                            const char *setname)
 151 {
 152     ZebraSet zebraSet;
 153     int i;
 154     ZEBRA_RES res;
 155
 156     zh->hits = 0;
 157
 158     zebraSet = resultSetAdd(zh, setname, 1);
 159     if (!zebraSet)
 160         return ZEBRA_FAIL;
 161     zebraSet->locked = 1;
 162     zebraSet->rpn = 0;
 163     zebraSet->nmem = m;
 164     zebraSet->rset_nmem = nmem_create();
 165
 166     zebraSet->num_bases = num_bases;
 167     zebraSet->basenames =
 168         nmem_malloc (zebraSet->nmem, num_bases * sizeof(*zebraSet->basenames));
 169     for (i = 0; i<num_bases; i++)
 170         zebraSet->basenames[i] = nmem_strdup(zebraSet->nmem, basenames[i]);
 171
 172     res = resultSetSearch(zh, zebraSet->nmem, zebraSet->rset_nmem,
 173                           rpn, zebraSet);
 174     zh->hits = zebraSet->hits;
 175     if (zebraSet->rset)
 176         zebraSet->rpn = rpn;
 177     zebraSet->locked = 0;
 178     if (!zebraSet->rset)
 179         return ZEBRA_FAIL;
 180     return res;
 181 }
 182
 183 void resultSetAddTerm (ZebraHandle zh, ZebraSet s, int reg_type,
 184                        const char *db, int set,
 185                        int use, const char *term)
 186 {
 187     assert(zh); /* compiler shut up */
 188     if (!s->nmem)
 189         s->nmem = nmem_create ();
 190     if (!s->term_entries)
 191     {
 192         int i;
 193         s->term_entries_max = 1000;
 194         s->term_entries =
 195             nmem_malloc (s->nmem, s->term_entries_max *
 196                          sizeof(*s->term_entries));
 197         for (i = 0; i < s->term_entries_max; i++)
 198             s->term_entries[i].term = 0;
 199     }
 200     if (s->hits < s->term_entries_max)
 201     {
 202         s->term_entries[s->hits].reg_type = reg_type;
 203         s->term_entries[s->hits].db = nmem_strdup (s->nmem, db);
 204         s->term_entries[s->hits].set = set;
 205         s->term_entries[s->hits].use = use;
 206         s->term_entries[s->hits].term = nmem_strdup (s->nmem, term);
 207     }
 208     (s->hits)++;
 209 }
 210
 211 ZebraSet resultSetAdd(ZebraHandle zh, const char *name, int ov)
 212 {
 213     ZebraSet s;
 214     int i;
 215
 216     for (s = zh->sets; s; s = s->next)
 217         if (!strcmp (s->name, name))
 218             break;
 219
 220     if (!log_level_set)
 221         loglevels();
 222     if (s)
 223     {
 224         yaz_log(log_level_resultsets, "updating result set %s", name);
 225         if (!ov || s->locked)
 226             return NULL;
 227         if (s->rset)
 228         {
 229             if (s->cache_rfd)
 230                 rset_close(s->cache_rfd);
 231             rset_delete (s->rset);
 232         }
 233         if (s->rset_nmem)
 234             nmem_destroy (s->rset_nmem);
 235         if (s->nmem)
 236             nmem_destroy (s->nmem);
 237     }
 238     else
 239     {
 240         const char *sort_max_str = zebra_get_resource(zh, "sortmax", "1000");
 241
 242         yaz_log(log_level_resultsets, "adding result set %s", name);
 243         s = (ZebraSet) xmalloc (sizeof(*s));
 244         s->next = zh->sets;
 245         zh->sets = s;
 246         s->name = (char *) xmalloc (strlen(name)+1);
 247         strcpy (s->name, name);
 248
 249         s->sort_info = (struct zset_sort_info *)
 250             xmalloc (sizeof(*s->sort_info));
 251         s->sort_info->max_entries = atoi(sort_max_str);
 252         if (s->sort_info->max_entries < 2)
 253             s->sort_info->max_entries = 2;
 254
 255         s->sort_info->entries = (struct zset_sort_entry **)
 256             xmalloc (sizeof(*s->sort_info->entries) *
 257                      s->sort_info->max_entries);
 258         s->sort_info->all_entries = (struct zset_sort_entry *)
 259             xmalloc (sizeof(*s->sort_info->all_entries) *
 260                      s->sort_info->max_entries);
 261         for (i = 0; i < s->sort_info->max_entries; i++)
 262             s->sort_info->entries[i] = s->sort_info->all_entries + i;
 263     }
 264     s->locked = 0;
 265     s->term_entries = 0;
 266     s->hits = 0;
 267     s->rset = 0;
 268     s->rset_nmem = 0;
 269     s->nmem = 0;
 270     s->rpn = 0;
 271     s->sortSpec = 0;
 272     s->cache_position = 0;
 273     s->cache_rfd = 0;
 274     s->approx_limit = zh->approx_limit;
 275     return s;
 276 }
 277
 278 ZebraSet resultSetGet(ZebraHandle zh, const char *name)
 279 {
 280     ZebraSet s;
 281
 282     for (s = zh->sets; s; s = s->next)
 283         if (!strcmp (s->name, name))
 284         {
 285             if (!s->term_entries && !s->rset && s->rpn)
 286             {
 287                 NMEM nmem = nmem_create ();
 288                 yaz_log(log_level_resultsets, "research %s", name);
 289                 if (!s->rset_nmem)
 290                     s->rset_nmem=nmem_create();
 291                 resultSetSearch(zh, nmem, s->rset_nmem, s->rpn, s);
 292                 if (s->rset && s->sortSpec)
 293                 {
 294                     int sort_status;
 295                     yaz_log(log_level_resultsets, "resort %s", name);
 296                     resultSetSortSingle (zh, nmem, s, s->rset, s->sortSpec,
 297                                          &sort_status);
 298                 }
 299                 nmem_destroy (nmem);
 300             }
 301             return s;
 302         }
 303     return NULL;
 304 }
 305
 306 void resultSetInvalidate (ZebraHandle zh)
 307 {
 308     ZebraSet s = zh->sets;
 309
 310     yaz_log(log_level_resultsets, "invalidating result sets");
 311     for (; s; s = s->next)
 312     {
 313         if (s->rset)
 314         {
 315             if (s->cache_rfd)
 316                 rset_close(s->cache_rfd);
 317             rset_delete (s->rset);
 318         }
 319         s->rset = 0;
 320         s->cache_rfd = 0;
 321         s->cache_position = 0;
 322         if (s->rset_nmem)
 323             nmem_destroy(s->rset_nmem);
 324         s->rset_nmem=0;
 325     }
 326 }
 327
 328 void resultSetDestroy(ZebraHandle zh, int num, char **names,int *statuses)
 329 {
 330     ZebraSet * ss = &zh->sets;
 331     int i;
 332
 333     if (statuses)
 334         for (i = 0; i<num; i++)
 335             statuses[i] = Z_DeleteStatus_resultSetDidNotExist;
 336     while (*ss)
 337     {
 338         int i = -1;
 339         ZebraSet s = *ss;
 340         if (num >= 0)
 341         {
 342             for (i = 0; i<num; i++)
 343                 if (!strcmp (s->name, names[i]))
 344                 {
 345                     if (statuses)
 346                         statuses[i] = Z_DeleteStatus_success;
 347                     i = -1;
 348                     break;
 349                 }
 350         }
 351         if (i < 0)
 352         {
 353             *ss = s->next;
 354
 355             xfree (s->sort_info->all_entries);
 356             xfree (s->sort_info->entries);
 357             xfree (s->sort_info);
 358
 359             if (s->nmem)
 360                 nmem_destroy (s->nmem);
 361             if (s->rset)
 362             {
 363                 if (s->cache_rfd)
 364                     rset_close(s->cache_rfd);
 365                 rset_delete (s->rset);
 366             }
 367             if (s->rset_nmem)
 368                 nmem_destroy(s->rset_nmem);
 369             xfree (s->name);
 370             xfree (s);
 371         }
 372         else
 373             ss = &s->next;
 374     }
 375 }
 376
 377 ZebraMetaRecord *zebra_meta_records_create_range(ZebraHandle zh,
 378                                                  const char *name,
 379                                                  zint start, int num)
 380 {
 381     zint pos_small[10];
 382     zint *pos = pos_small;
 383     ZebraMetaRecord *mr;
 384     int i;
 385
 386     if (num > 10000 || num <= 0)
 387         return 0;
 388
 389     if (num > 10)
 390         pos = xmalloc(sizeof(*pos) * num);
 391
 392     for (i = 0; i<num; i++)
 393         pos[i] = start+i;
 394
 395     mr = zebra_meta_records_create(zh, name, num, pos);
 396
 397     if (num > 10)
 398         xfree(pos);
 399     return mr;
 400 }
 401
 402 ZebraMetaRecord *zebra_meta_records_create(ZebraHandle zh, const char *name,
 403                                            int num, zint *positions)
 404 {
 405     ZebraSet sset;
 406     ZebraMetaRecord *sr = 0;
 407     RSET rset;
 408     int i;
 409     struct zset_sort_info *sort_info;
 410     size_t sysno_mem_index = 0;
 411
 412     if (zh->m_staticrank)
 413         sysno_mem_index = 1;
 414
 415     if (!log_level_set)
 416         loglevels();
 417     if (!(sset = resultSetGet (zh, name)))
 418         return NULL;
 419     if (!(rset = sset->rset))
 420     {
 421         if (!sset->term_entries)
 422             return 0;
 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             if (positions[i] <= sset->term_entries_max)
 432             {
 433                 sr[i].term = sset->term_entries[positions[i]-1].term;
 434                 sr[i].db = sset->term_entries[positions[i]-1].db;
 435             }
 436         }
 437     }
 438     else
 439     {
 440         sr = (ZebraMetaRecord *) xmalloc (sizeof(*sr) * num);
 441         for (i = 0; i<num; i++)
 442         {
 443             sr[i].sysno = 0;
 444             sr[i].score = -1;
 445             sr[i].term = 0;
 446             sr[i].db = 0;
 447         }
 448         sort_info = sset->sort_info;
 449         if (sort_info)
 450         {
 451             zint position;
 452
 453             for (i = 0; i<num; i++)
 454             {
 455                 position = positions[i];
 456                 if (position > 0 && position <= sort_info->num_entries)
 457                 {
 458                     yaz_log(log_level_sort, "got pos=" ZINT_FORMAT
 459                             " (sorted)", position);
 460                     sr[i].sysno = sort_info->entries[position-1]->sysno;
 461                     sr[i].score = sort_info->entries[position-1]->score;
 462                 }
 463             }
 464         }
 465         /* did we really get all entries using sort ? */
 466         for (i = 0; i<num; i++)
 467         {
 468             if (!sr[i].sysno)
 469                 break;
 470         }
 471         if (i < num) /* nope, get the rest, unsorted - sorry */
 472         {
 473             zint position = 0;
 474             int num_i = 0;
 475             zint psysno = 0;
 476             RSFD rfd;
 477             struct it_key key;
 478
 479             if (sort_info)
 480                 position = sort_info->num_entries;
 481             while (num_i < num && positions[num_i] <= position)
 482                 num_i++;
 483
 484             if (sset->cache_rfd &&
 485                 num_i < num && positions[num_i] > sset->cache_position)
 486             {
 487                 position = sset->cache_position;
 488                 rfd = sset->cache_rfd;
 489                 psysno = sset->cache_psysno;
 490             }
 491             else
 492             {
 493                 if (sset->cache_rfd)
 494                     rset_close(sset->cache_rfd);
 495                 rfd = rset_open (rset, RSETF_READ);
 496             }
 497             while (num_i < num && rset_read (rfd, &key, 0))
 498             {
 499                 zint this_sys = key.mem[sysno_mem_index];
 500                 if (this_sys != psysno)
 501                 {
 502                     psysno = this_sys;
 503                     if (sort_info)
 504                     {
 505                         /* determine we alreay have this in our set */
 506                         for (i = sort_info->num_entries; --i >= 0; )
 507                             if (psysno == sort_info->entries[i]->sysno)
 508                                 break;
 509                         if (i >= 0)
 510                             continue;
 511                     }
 512                     position++;
 513                     assert (num_i < num);
 514                     if (position == positions[num_i])
 515                     {
 516                         sr[num_i].sysno = psysno;
 517                         yaz_log(log_level_sort, "got pos=" ZINT_FORMAT " (unsorted)", position);
 518                         sr[num_i].score = -1;
 519                         num_i++;
 520                     }
 521                 }
 522             }
 523             sset->cache_position = position;
 524             sset->cache_psysno = psysno;
 525             sset->cache_rfd = rfd;
 526         }
 527     }
 528     return sr;
 529 }
 530
 531 void zebra_meta_records_destroy (ZebraHandle zh, ZebraMetaRecord *records,
 532                                  int num)
 533 {
 534     assert(zh); /* compiler shut up about unused arg */
 535     xfree (records);
 536 }
 537
 538 struct sortKeyInfo {
 539     int relation;
 540     int attrUse;
 541     int numerical;
 542 };
 543
 544 void resultSetInsertSort (ZebraHandle zh, ZebraSet sset,
 545                           struct sortKeyInfo *criteria, int num_criteria,
 546                           zint sysno)
 547 {
 548     struct zset_sort_entry this_entry;
 549     struct zset_sort_entry *new_entry = NULL;
 550     struct zset_sort_info *sort_info = sset->sort_info;
 551     int i, j;
 552
 553     sortIdx_sysno (zh->reg->sortIdx, sysno);
 554     for (i = 0; i<num_criteria; i++)
 555     {
 556         sortIdx_type (zh->reg->sortIdx, criteria[i].attrUse);
 557         sortIdx_read (zh->reg->sortIdx, this_entry.buf[i]);
 558     }
 559     i = sort_info->num_entries;
 560     while (--i >= 0)
 561     {
 562         int rel = 0;
 563         for (j = 0; j<num_criteria; j++)
 564         {
 565             if (criteria[j].numerical)
 566             {
 567                 double diff = atof(this_entry.buf[j]) -
 568                               atof(sort_info->entries[i]->buf[j]);
 569                 rel = 0;
 570                 if (diff > 0.0)
 571                     rel = 1;
 572                 else if (diff < 0.0)
 573                     rel = -1;
 574             }
 575             else
 576             {
 577                 rel = memcmp (this_entry.buf[j], sort_info->entries[i]->buf[j],
 578                           SORT_IDX_ENTRYSIZE);
 579             }
 580             if (rel)
 581                 break;
 582         }
 583         if (!rel)
 584             break;
 585         if (criteria[j].relation == 'A')
 586         {
 587             if (rel > 0)
 588                 break;
 589         }
 590         else if (criteria[j].relation == 'D')
 591         {
 592             if (rel < 0)
 593                 break;
 594         }
 595     }
 596     ++i;
 597     j = sort_info->max_entries;
 598     if (i == j)
 599         return;
 600
 601     if (sort_info->num_entries == j)
 602         --j;
 603     else
 604         j = (sort_info->num_entries)++;
 605     new_entry = sort_info->entries[j];
 606     while (j != i)
 607     {
 608         sort_info->entries[j] = sort_info->entries[j-1];
 609         --j;
 610     }
 611     sort_info->entries[i] = new_entry;
 612     assert (new_entry);
 613     for (i = 0; i<num_criteria; i++)
 614         memcpy (new_entry->buf[i], this_entry.buf[i], SORT_IDX_ENTRYSIZE);
 615     new_entry->sysno = sysno;
 616     new_entry->score = -1;
 617 }
 618
 619 void resultSetInsertRank (ZebraHandle zh, struct zset_sort_info *sort_info,
 620                           zint sysno, int score, int relation)
 621 {
 622     struct zset_sort_entry *new_entry = NULL;
 623     int i, j;
 624     assert(zh); /* compiler shut up about unused arg */
 625
 626     i = sort_info->num_entries;
 627     while (--i >= 0)
 628     {
 629         int rel = 0;
 630
 631         rel = score - sort_info->entries[i]->score;
 632
 633         if (relation == 'D')
 634         {
 635             if (rel >= 0)
 636                 break;
 637         }
 638         else if (relation == 'A')
 639         {
 640             if (rel <= 0)
 641                 break;
 642         }
 643     }
 644     ++i;
 645     j = sort_info->max_entries;
 646     if (i == j)
 647         return;
 648
 649     if (sort_info->num_entries == j)
 650         --j;
 651     else
 652         j = (sort_info->num_entries)++;
 653
 654     new_entry = sort_info->entries[j];
 655     while (j != i)
 656     {
 657         sort_info->entries[j] = sort_info->entries[j-1];
 658         --j;
 659     }
 660     sort_info->entries[i] = new_entry;
 661     assert (new_entry);
 662     new_entry->sysno = sysno;
 663     new_entry->score = score;
 664 }
 665
 666 static Z_RPNQuery *copy_RPNQuery(Z_RPNQuery *src, NMEM nmem)
 667 {
 668     Z_RPNQuery *dst = 0;
 669     ODR encode = odr_createmem(ODR_ENCODE);
 670     ODR decode = odr_createmem(ODR_DECODE);
 671
 672     if (z_RPNQuery(encode, &src, 0, 0))
 673     {
 674         int len;
 675         char *buf = odr_getbuf(encode, &len, 0);
 676
 677         if (buf)
 678         {
 679             odr_setbuf(decode, buf, len, 0);
 680             z_RPNQuery(decode, &dst, 0, 0);
 681         }
 682     }
 683     nmem_transfer(nmem, decode->mem);
 684     odr_destroy(encode);
 685     odr_destroy(decode);
 686     return dst;
 687 }
 688
 689 static Z_SortKeySpecList *copy_SortKeySpecList(Z_SortKeySpecList *src, NMEM nmem)
 690 {
 691     Z_SortKeySpecList *dst = 0;
 692     ODR encode = odr_createmem(ODR_ENCODE);
 693     ODR decode = odr_createmem(ODR_DECODE);
 694
 695     if (z_SortKeySpecList(encode, &src, 0, 0))
 696     {
 697         int len;
 698         char *buf = odr_getbuf(encode, &len, 0);
 699
 700         if (buf)
 701         {
 702             odr_setbuf(decode, buf, len, 0);
 703             z_SortKeySpecList(decode, &dst, 0, 0);
 704         }
 705     }
 706     nmem_transfer(nmem, decode->mem);
 707     odr_destroy(encode);
 708     odr_destroy(decode);
 709     return dst;
 710 }
 711
 712 ZebraSet resultSetClone(ZebraHandle zh, const char *setname,
 713                         ZebraSet rset)
 714 {
 715     ZebraSet nset;
 716     int i;
 717
 718     nset = resultSetAdd(zh, setname, 1);
 719     if (!nset)
 720         return 0;
 721
 722     nset->nmem = nmem_create();
 723
 724     nset->num_bases = rset->num_bases;
 725     nset->basenames =
 726         nmem_malloc (nset->nmem, nset->num_bases * sizeof(*rset->basenames));
 727     for (i = 0; i<rset->num_bases; i++)
 728         nset->basenames[i] = nmem_strdup(nset->nmem, rset->basenames[i]);
 729
 730     if (rset->rset)
 731         nset->rset = rset_dup(rset->rset);
 732     if (rset->rpn)
 733         nset->rpn = copy_RPNQuery(rset->rpn, nset->nmem);
 734     return nset;
 735 }
 736
 737 ZEBRA_RES resultSetSort(ZebraHandle zh, NMEM nmem,
 738                         int num_input_setnames, const char **input_setnames,
 739                         const char *output_setname,
 740                         Z_SortKeySpecList *sort_sequence, int *sort_status)
 741 {
 742     ZebraSet sset;
 743     RSET rset;
 744
 745     if (num_input_setnames == 0)
 746     {
 747         zebra_setError(zh, YAZ_BIB1_NO_RESULT_SET_NAME_SUPPLIED_ON_SORT, 0);
 748         return ZEBRA_FAIL;
 749     }
 750     if (num_input_setnames > 1)
 751     {
 752         zebra_setError(zh, YAZ_BIB1_SORT_TOO_MANY_INPUT_RESULTS, 0);
 753         return ZEBRA_FAIL;
 754     }
 755     if (!log_level_set)
 756         loglevels();
 757     yaz_log(log_level_sort, "result set sort input=%s output=%s",
 758           *input_setnames, output_setname);
 759     sset = resultSetGet (zh, input_setnames[0]);
 760     if (!sset)
 761     {
 762         zebra_setError(zh, YAZ_BIB1_SPECIFIED_RESULT_SET_DOES_NOT_EXIST,
 763                        input_setnames[0]);
 764         return ZEBRA_FAIL;
 765     }
 766     if (!(rset = sset->rset))
 767     {
 768         zebra_setError(zh, YAZ_BIB1_SPECIFIED_RESULT_SET_DOES_NOT_EXIST,
 769                        input_setnames[0]);
 770         return ZEBRA_FAIL;
 771     }
 772     if (strcmp (output_setname, input_setnames[0]))
 773         sset = resultSetClone(zh, output_setname, sset);
 774     sset->sortSpec = copy_SortKeySpecList(sort_sequence, sset->nmem);
 775     return resultSetSortSingle (zh, nmem, sset, rset, sort_sequence,
 776                                 sort_status);
 777 }
 778
 779 ZEBRA_RES resultSetSortSingle(ZebraHandle zh, NMEM nmem,
 780                               ZebraSet sset, RSET rset,
 781                               Z_SortKeySpecList *sort_sequence,
 782                               int *sort_status)
 783 {
 784     int i;
 785     int n = 0;
 786     zint kno = 0;
 787     zint psysno = 0;
 788     struct it_key key;
 789     struct sortKeyInfo sort_criteria[3];
 790     int num_criteria;
 791     RSFD rfd;
 792     TERMID termid;
 793     TERMID *terms;
 794     int numTerms = 0;
 795     size_t sysno_mem_index = 0;
 796
 797     if (zh->m_staticrank)
 798         sysno_mem_index = 1;
 799
 800
 801     assert(nmem); /* compiler shut up about unused param */
 802     sset->sort_info->num_entries = 0;
 803
 804     rset_getterms(rset, 0, 0, &n);
 805     terms = (TERMID *) nmem_malloc(nmem, sizeof(*terms)*n);
 806     rset_getterms(rset, terms, n, &numTerms);
 807
 808     sset->hits = 0;
 809     num_criteria = sort_sequence->num_specs;
 810     if (num_criteria > 3)
 811         num_criteria = 3;
 812     for (i = 0; i < num_criteria; i++)
 813     {
 814         Z_SortKeySpec *sks = sort_sequence->specs[i];
 815         Z_SortKey *sk;
 816
 817         if (*sks->sortRelation == Z_SortKeySpec_ascending)
 818             sort_criteria[i].relation = 'A';
 819         else if (*sks->sortRelation == Z_SortKeySpec_descending)
 820             sort_criteria[i].relation = 'D';
 821         else
 822         {
 823             zebra_setError(zh, YAZ_BIB1_ILLEGAL_SORT_RELATION, 0);
 824             return ZEBRA_FAIL;
 825         }
 826         if (sks->sortElement->which == Z_SortElement_databaseSpecific)
 827         {
 828             zebra_setError(zh, YAZ_BIB1_DATABASE_SPECIFIC_SORT_UNSUPP, 0);
 829             return ZEBRA_FAIL;
 830         }
 831         else if (sks->sortElement->which != Z_SortElement_generic)
 832         {
 833             zebra_setError(zh, YAZ_BIB1_SORT_ILLEGAL_SORT, 0);
 834             return ZEBRA_FAIL;
 835         }
 836         sk = sks->sortElement->u.generic;
 837         switch (sk->which)
 838         {
 839         case Z_SortKey_sortField:
 840             yaz_log(log_level_sort, "key %d is of type sortField",
 841                     i+1);
 842             zebra_setError(zh, YAZ_BIB1_CANNOT_SORT_ACCORDING_TO_SEQUENCE, 0);
 843             return ZEBRA_FAIL;
 844         case Z_SortKey_elementSpec:
 845             yaz_log(log_level_sort, "key %d is of type elementSpec",
 846                     i+1);
 847             zebra_setError(zh, YAZ_BIB1_CANNOT_SORT_ACCORDING_TO_SEQUENCE, 0);
 848             return ZEBRA_FAIL;
 849         case Z_SortKey_sortAttributes:
 850             yaz_log(log_level_sort, "key %d is of type sortAttributes", i+1);
 851             sort_criteria[i].attrUse =
 852                 zebra_maps_sort (zh->reg->zebra_maps,
 853                                  sk->u.sortAttributes,
 854                                  &sort_criteria[i].numerical);
 855             yaz_log(log_level_sort, "use value = %d", sort_criteria[i].attrUse);
 856             if (sort_criteria[i].attrUse == -1)
 857             {
 858                 zebra_setError(
 859                     zh, YAZ_BIB1_USE_ATTRIBUTE_REQUIRED_BUT_NOT_SUPPLIED, 0);
 860                 return ZEBRA_FAIL;
 861             }
 862             if (sortIdx_type (zh->reg->sortIdx, sort_criteria[i].attrUse))
 863             {
 864                 zebra_setError(
 865                     zh, YAZ_BIB1_CANNOT_SORT_ACCORDING_TO_SEQUENCE, 0);
 866                 return ZEBRA_FAIL;
 867             }
 868             break;
 869         }
 870     }
 871     rfd = rset_open (rset, RSETF_READ);
 872     while (rset_read (rfd, &key, &termid))
 873     {
 874         zint this_sys = key.mem[sysno_mem_index];
 875         if (log_level_searchhits)
 876             key_logdump_txt(log_level_searchhits, &key, termid->name);
 877         kno++;
 878         if (this_sys != psysno)
 879         {
 880             (sset->hits)++;
 881             psysno = this_sys;
 882             resultSetInsertSort (zh, sset,
 883                                  sort_criteria, num_criteria, psysno);
 884         }
 885     }
 886     rset_close (rfd);
 887     yaz_log(log_level_sort, ZINT_FORMAT " keys, " ZINT_FORMAT " sysnos, sort",
 888             kno, sset->hits);
 889     for (i = 0; i < numTerms; i++)
 890         yaz_log(log_level_sort, "term=\"%s\" type=%s count=" ZINT_FORMAT,
 891                  terms[i]->name, terms[i]->flags, terms[i]->rset->hits_count);
 892     *sort_status = Z_SortResponse_success;
 893     return ZEBRA_OK;
 894 }
 895
 896 RSET resultSetRef(ZebraHandle zh, const char *resultSetId)
 897 {
 898     ZebraSet s;
 899
 900     if ((s = resultSetGet (zh, resultSetId)))
 901         return s->rset;
 902     return NULL;
 903 }
 904
 905 ZEBRA_RES resultSetRank(ZebraHandle zh, ZebraSet zebraSet,
 906                         RSET rset, NMEM nmem)
 907 {
 908     struct it_key key;
 909     TERMID termid;
 910     TERMID *terms;
 911     zint kno = 0;
 912     int numTerms = 0;
 913     int n = 0;
 914     int i;
 915     ZebraRankClass rank_class;
 916     struct zset_sort_info *sort_info;
 917     const char *rank_handler_name = res_get_def(zh->res, "rank", "rank-1");
 918     size_t sysno_mem_index = 0;
 919
 920     if (zh->m_staticrank)
 921         sysno_mem_index = 1;
 922
 923     if (!log_level_set)
 924         loglevels();
 925     sort_info = zebraSet->sort_info;
 926     sort_info->num_entries = 0;
 927     zebraSet->hits = 0;
 928     rset_getterms(rset, 0, 0, &n);
 929     terms = (TERMID *) nmem_malloc(nmem, sizeof(*terms)*n);
 930     rset_getterms(rset, terms, n, &numTerms);
 931
 932
 933     rank_class = zebraRankLookup(zh, rank_handler_name);
 934     if (!rank_class)
 935     {
 936         yaz_log(YLOG_WARN, "No such rank handler: %s", rank_handler_name);
 937         zebra_setError(zh, YAZ_BIB1_UNSUPP_SEARCH, "Cannot find rank handler");
 938         return ZEBRA_FAIL;
 939     }
 940     else
 941     {
 942         RSFD rfd = rset_open(rset, RSETF_READ);
 943         struct rank_control *rc = rank_class->control;
 944         double score;
 945         zint count = 0;
 946
 947         void *handle =
 948             (*rc->begin) (zh->reg, rank_class->class_handle, rset, nmem,
 949                           terms, numTerms);
 950         zint psysno = 0;  /* previous doc id / sys no */
 951         zint pstaticrank = 0; /* previous static rank */
 952         int stop_flag = 0;
 953         while (rset_read(rfd, &key, &termid))
 954         {
 955             zint this_sys = key.mem[sysno_mem_index];
 956
 957             zint seqno = key.mem[key.len-1];
 958             kno++;
 959             if (log_level_searchhits)
 960                 key_logdump_txt(log_level_searchhits, &key, termid->name);
 961             if (this_sys != psysno)
 962             {   /* new record .. */
 963                 if (rfd->counted_items > rset->hits_limit)
 964                     break;
 965                 if (psysno)
 966                 {   /* only if we did have a previous record */
 967                     score = (*rc->calc) (handle, psysno, pstaticrank,
 968                                          &stop_flag);
 969                     /* insert the hit. A=Ascending */
 970                     resultSetInsertRank (zh, sort_info, psysno, score, 'A');
 971                     count++;
 972                     if (stop_flag)
 973                         break;
 974                 }
 975                 psysno = this_sys;
 976                 if (zh->m_staticrank)
 977                     pstaticrank = key.mem[0];
 978             }
 979             (*rc->add) (handle, CAST_ZINT_TO_INT(seqno), termid);
 980         }
 981         /* no more items */
 982         if (psysno)
 983         {   /* we had - at least - one record */
 984             score = (*rc->calc)(handle, psysno, pstaticrank, &stop_flag);
 985             /* insert the hit. A=Ascending */
 986             resultSetInsertRank(zh, sort_info, psysno, score, 'A');
 987             count++;
 988         }
 989         (*rc->end) (zh->reg, handle);
 990         rset_close (rfd);
 991     }
 992     zebraSet->hits = rset->hits_count;
 993
 994     yaz_log(log_level_searchterms, ZINT_FORMAT " keys, "
 995             ZINT_FORMAT " sysnos, rank",  kno, zebraSet->hits);
 996     for (i = 0; i < numTerms; i++)
 997     {
 998         yaz_log(log_level_searchterms, "term=\"%s\" type=%s count="
 999                 ZINT_FORMAT,
1000                 terms[i]->name, terms[i]->flags, terms[i]->rset->hits_count);
1001     }
1002     return ZEBRA_OK;
1003 }
1004
1005 ZebraRankClass zebraRankLookup(ZebraHandle zh, const char *name)
1006 {
1007     ZebraRankClass p = zh->reg->rank_classes;
1008     while (p && strcmp (p->control->name, name))
1009         p = p->next;
1010     if (p && !p->init_flag)
1011     {
1012         if (p->control->create)
1013             p->class_handle = (*p->control->create)(zh);
1014         p->init_flag = 1;
1015     }
1016     return p;
1017 }
1018
1019 void zebraRankInstall(struct zebra_register *reg, struct rank_control *ctrl)
1020 {
1021     ZebraRankClass p = (ZebraRankClass) xmalloc (sizeof(*p));
1022     p->control = (struct rank_control *) xmalloc (sizeof(*p->control));
1023     memcpy (p->control, ctrl, sizeof(*p->control));
1024     p->control->name = xstrdup (ctrl->name);
1025     p->init_flag = 0;
1026     p->next = reg->rank_classes;
1027     reg->rank_classes = p;
1028 }
1029
1030 void zebraRankDestroy(struct zebra_register *reg)
1031 {
1032     ZebraRankClass p = reg->rank_classes;
1033     while (p)
1034     {
1035         ZebraRankClass p_next = p->next;
1036         if (p->init_flag && p->control->destroy)
1037             (*p->control->destroy)(reg, p->class_handle);
1038         xfree(p->control->name);
1039         xfree(p->control);
1040         xfree(p);
1041         p = p_next;
1042     }
1043     reg->rank_classes = NULL;
1044 }
1045
1046 static int trav_rset_for_termids(RSET rset, TERMID *termid_array,
1047                                  zint *hits_array, int *approx_array)
1048 {
1049     int no = 0;
1050     int i;
1051     for (i = 0; i<rset->no_children; i++)
1052         no += trav_rset_for_termids(rset->children[i],
1053                                     (termid_array ? termid_array + no : 0),
1054                                     (hits_array ? hits_array + no : 0),
1055                                     (approx_array ? approx_array + no : 0));
1056     if (rset->term)
1057     {
1058         if (termid_array)
1059             termid_array[no] = rset->term;
1060         if (hits_array)
1061             hits_array[no] = rset->hits_count;
1062         if (approx_array)
1063             approx_array[no] = rset->hits_approx;
1064 #if 0
1065         yaz_log(YLOG_LOG, "rset=%p term=%s limit=" ZINT_FORMAT
1066                 " count=" ZINT_FORMAT,
1067                 rset, rset->term->name, rset->hits_limit, rset->hits_count);
1068 #endif
1069         no++;
1070     }
1071     return no;
1072 }
1073
1074 ZEBRA_RES zebra_result_set_term_no(ZebraHandle zh, const char *setname,
1075                                    int *num_terms)
1076 {
1077     ZebraSet sset = resultSetGet(zh, setname);
1078     *num_terms = 0;
1079     if (sset)
1080     {
1081         *num_terms = trav_rset_for_termids(sset->rset, 0, 0, 0);
1082         return ZEBRA_OK;
1083     }
1084     return ZEBRA_FAIL;
1085 }
1086
1087 ZEBRA_RES zebra_result_set_term_info(ZebraHandle zh, const char *setname,
1088                                      int no, zint *count, int *approx,
1089                                      char *termbuf, size_t *termlen,
1090                                      const char **term_ref_id)
1091 {
1092     ZebraSet sset = resultSetGet(zh, setname);
1093     if (sset)
1094     {
1095         int num_terms = trav_rset_for_termids(sset->rset, 0, 0, 0);
1096         if (no >= 0 && no < num_terms)
1097         {
1098             TERMID *term_array = xmalloc(num_terms * sizeof(*term_array));
1099             zint *hits_array = xmalloc(num_terms * sizeof(*hits_array));
1100             int *approx_array = xmalloc(num_terms * sizeof(*approx_array));
1101
1102             trav_rset_for_termids(sset->rset, term_array,
1103                                   hits_array, approx_array);
1104
1105             if (count)
1106                 *count = hits_array[no];
1107             if (approx)
1108                 *approx = approx_array[no];
1109             if (termbuf)
1110             {
1111                 char *inbuf = term_array[no]->name;
1112                 size_t inleft = strlen(inbuf);
1113                 size_t outleft = *termlen - 1;
1114
1115                 if (zh->iconv_from_utf8 != 0)
1116                 {
1117                     char *outbuf = termbuf;
1118                     size_t ret;
1119
1120                     ret = yaz_iconv(zh->iconv_from_utf8, &inbuf, &inleft,
1121                                     &outbuf, &outleft);
1122                     if (ret == (size_t)(-1))
1123                         *termlen = 0;
1124                     else
1125                         *termlen = outbuf - termbuf;
1126                 }
1127                 else
1128                 {
1129                     if (inleft > outleft)
1130                         inleft = outleft;
1131                     *termlen = inleft;
1132                     memcpy(termbuf, inbuf, *termlen);
1133                 }
1134                 termbuf[*termlen] = '\0';
1135             }
1136             if (term_ref_id)
1137                 *term_ref_id = term_array[no]->ref_id;
1138
1139             xfree(term_array);
1140             xfree(hits_array);
1141             xfree(approx_array);
1142             return ZEBRA_OK;
1143         }
1144     }
1145     return ZEBRA_FAIL;
1146 }
1147
1148 ZEBRA_RES zebra_snippets_hit_vector(ZebraHandle zh, const char *setname,
1149                                     zint sysno, zebra_snippets *snippets)
1150 {
1151     ZebraSet sset = resultSetGet(zh, setname);
1152     yaz_log(YLOG_DEBUG, "zebra_get_hit_vector setname=%s zysno=" ZINT_FORMAT,
1153             setname, sysno);
1154     if (!sset)
1155         return ZEBRA_FAIL;
1156     else
1157     {
1158         struct rset_key_control *kc = zebra_key_control_create(zh);
1159         NMEM nmem = nmem_create();
1160         struct it_key key;
1161         RSET rsets[2], rset_comb;
1162         RSET rset_temp = rstemp_create(nmem, kc, kc->scope,
1163                                        res_get (zh->res, "setTmpDir"),0 );
1164
1165         TERMID termid;
1166         RSFD rsfd = rset_open(rset_temp, RSETF_WRITE);
1167
1168         key.mem[0] = sysno;
1169         key.mem[1] = 0;
1170         key.mem[2] = 0;
1171         key.mem[3] = 0;
1172         key.len = 2;
1173         rset_write (rsfd, &key);
1174         rset_close (rsfd);
1175
1176         rsets[0] = rset_temp;
1177         rsets[1] = rset_dup(sset->rset);
1178
1179         rset_comb = rsmulti_and_create(nmem, kc, kc->scope, 2, rsets);
1180
1181         rsfd = rset_open(rset_comb, RSETF_READ);
1182
1183         while (rset_read(rsfd, &key, &termid))
1184         {
1185             if (termid)
1186             {
1187                 struct ord_list *ol;
1188                 for (ol = termid->ol; ol; ol = ol->next)
1189                 {
1190                     zebra_snippets_append(snippets, key.mem[key.len-1],
1191                                           ol->ord, termid->name);
1192                 }
1193             }
1194         }
1195         rset_close(rsfd);
1196
1197         rset_delete(rset_comb);
1198         nmem_destroy(nmem);
1199         kc->dec(kc);
1200     }
1201     return ZEBRA_OK;
1202 }
1203