index/zsets.c

   1 /* $Id: zsets.c,v 1.97 2006-01-12 13:21:45 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 static Z_RPNQuery *copy_RPNQuery(Z_RPNQuery *src_rpn, NMEM dst)
 658 {
 659     Z_RPNQuery *dst_rpn = 0;
 660     ODR encode = odr_createmem(ODR_ENCODE);
 661     ODR decode = odr_createmem(ODR_DECODE);
 662
 663     if (z_RPNQuery(encode, &src_rpn, 0, 0))
 664     {
 665         int len;
 666         char *buf = odr_getbuf(encode, &len, 0);
 667
 668         if (buf)
 669         {
 670             odr_setbuf(decode, buf, len, 0);
 671             z_RPNQuery(decode, &dst_rpn, 0, 0);
 672         }
 673     }
 674     nmem_transfer(dst, decode->mem);
 675     odr_destroy(encode);
 676     odr_destroy(decode);
 677     return dst_rpn;
 678 }
 679
 680 ZebraSet resultSetClone(ZebraHandle zh, const char *setname,
 681                         ZebraSet rset)
 682 {
 683     ZebraSet nset;
 684     int i;
 685
 686     nset = resultSetAdd(zh, setname, 1);
 687     if (!nset)
 688         return 0;
 689
 690     nset->nmem = nmem_create();
 691
 692     nset->num_bases = rset->num_bases;
 693     nset->basenames =
 694         nmem_malloc (nset->nmem, nset->num_bases * sizeof(*rset->basenames));
 695     for (i = 0; i<rset->num_bases; i++)
 696         nset->basenames[i] = nmem_strdup(nset->nmem, rset->basenames[i]);
 697
 698     if (rset->rset)
 699         nset->rset = rset_dup(rset->rset);
 700     if (rset->rpn)
 701         nset->rpn = copy_RPNQuery(rset->rpn, nset->nmem);
 702     return nset;
 703 }
 704
 705 ZEBRA_RES resultSetSort(ZebraHandle zh, NMEM nmem,
 706                         int num_input_setnames, const char **input_setnames,
 707                         const char *output_setname,
 708                         Z_SortKeySpecList *sort_sequence, int *sort_status)
 709 {
 710     ZebraSet sset;
 711     RSET rset;
 712
 713     if (num_input_setnames == 0)
 714     {
 715         zebra_setError(zh, YAZ_BIB1_NO_RESULT_SET_NAME_SUPPLIED_ON_SORT, 0);
 716         return ZEBRA_FAIL;
 717     }
 718     if (num_input_setnames > 1)
 719     {
 720         zebra_setError(zh, YAZ_BIB1_SORT_TOO_MANY_INPUT_RESULTS, 0);
 721         return ZEBRA_FAIL;
 722     }
 723     if (!log_level_set)
 724         loglevels();
 725     yaz_log(log_level_sort, "result set sort input=%s output=%s",
 726           *input_setnames, output_setname);
 727     sset = resultSetGet (zh, input_setnames[0]);
 728     if (!sset)
 729     {
 730         zebra_setError(zh, YAZ_BIB1_SPECIFIED_RESULT_SET_DOES_NOT_EXIST,
 731                        input_setnames[0]);
 732         return ZEBRA_FAIL;
 733     }
 734     if (!(rset = sset->rset))
 735     {
 736         zebra_setError(zh, YAZ_BIB1_SPECIFIED_RESULT_SET_DOES_NOT_EXIST,
 737                        input_setnames[0]);
 738         return ZEBRA_FAIL;
 739     }
 740     if (strcmp (output_setname, input_setnames[0]))
 741         sset = resultSetClone(zh, output_setname, sset);
 742     return resultSetSortSingle (zh, nmem, sset, rset, sort_sequence,
 743                                 sort_status);
 744 }
 745
 746 ZEBRA_RES resultSetSortSingle(ZebraHandle zh, NMEM nmem,
 747                               ZebraSet sset, RSET rset,
 748                               Z_SortKeySpecList *sort_sequence,
 749                               int *sort_status)
 750 {
 751     int i;
 752     int n = 0;
 753     zint kno = 0;
 754     zint psysno = 0;
 755     struct it_key key;
 756     struct sortKeyInfo sort_criteria[3];
 757     int num_criteria;
 758     RSFD rfd;
 759     TERMID termid;
 760     TERMID *terms;
 761     int numTerms = 0;
 762     size_t sysno_mem_index = 0;
 763
 764     if (zh->m_staticrank)
 765         sysno_mem_index = 1;
 766
 767
 768     assert(nmem); /* compiler shut up about unused param */
 769     sset->sort_info->num_entries = 0;
 770
 771     rset_getterms(rset, 0, 0, &n);
 772     terms = (TERMID *) nmem_malloc(nmem, sizeof(*terms)*n);
 773     rset_getterms(rset, terms, n, &numTerms);
 774
 775     sset->hits = 0;
 776     num_criteria = sort_sequence->num_specs;
 777     if (num_criteria > 3)
 778         num_criteria = 3;
 779     for (i = 0; i < num_criteria; i++)
 780     {
 781         Z_SortKeySpec *sks = sort_sequence->specs[i];
 782         Z_SortKey *sk;
 783
 784         if (*sks->sortRelation == Z_SortKeySpec_ascending)
 785             sort_criteria[i].relation = 'A';
 786         else if (*sks->sortRelation == Z_SortKeySpec_descending)
 787             sort_criteria[i].relation = 'D';
 788         else
 789         {
 790             zebra_setError(zh, YAZ_BIB1_ILLEGAL_SORT_RELATION, 0);
 791             return ZEBRA_FAIL;
 792         }
 793         if (sks->sortElement->which == Z_SortElement_databaseSpecific)
 794         {
 795             zebra_setError(zh, YAZ_BIB1_DATABASE_SPECIFIC_SORT_UNSUPP, 0);
 796             return ZEBRA_FAIL;
 797         }
 798         else if (sks->sortElement->which != Z_SortElement_generic)
 799         {
 800             zebra_setError(zh, YAZ_BIB1_SORT_ILLEGAL_SORT, 0);
 801             return ZEBRA_FAIL;
 802         }
 803         sk = sks->sortElement->u.generic;
 804         switch (sk->which)
 805         {
 806         case Z_SortKey_sortField:
 807             yaz_log(log_level_sort, "key %d is of type sortField",
 808                     i+1);
 809             zebra_setError(zh, YAZ_BIB1_CANNOT_SORT_ACCORDING_TO_SEQUENCE, 0);
 810             return ZEBRA_FAIL;
 811         case Z_SortKey_elementSpec:
 812             yaz_log(log_level_sort, "key %d is of type elementSpec",
 813                     i+1);
 814             zebra_setError(zh, YAZ_BIB1_CANNOT_SORT_ACCORDING_TO_SEQUENCE, 0);
 815             return ZEBRA_FAIL;
 816         case Z_SortKey_sortAttributes:
 817             yaz_log(log_level_sort, "key %d is of type sortAttributes", i+1);
 818             sort_criteria[i].attrUse =
 819                 zebra_maps_sort (zh->reg->zebra_maps,
 820                                  sk->u.sortAttributes,
 821                                  &sort_criteria[i].numerical);
 822             yaz_log(log_level_sort, "use value = %d", sort_criteria[i].attrUse);
 823             if (sort_criteria[i].attrUse == -1)
 824             {
 825                 zebra_setError(
 826                     zh, YAZ_BIB1_USE_ATTRIBUTE_REQUIRED_BUT_NOT_SUPPLIED, 0);
 827                 return ZEBRA_FAIL;
 828             }
 829             if (sortIdx_type (zh->reg->sortIdx, sort_criteria[i].attrUse))
 830             {
 831                 zebra_setError(
 832                     zh, YAZ_BIB1_CANNOT_SORT_ACCORDING_TO_SEQUENCE, 0);
 833                 return ZEBRA_FAIL;
 834             }
 835             break;
 836         }
 837     }
 838     rfd = rset_open (rset, RSETF_READ);
 839     while (rset_read (rfd, &key, &termid))
 840     {
 841         zint this_sys = key.mem[sysno_mem_index];
 842         if (log_level_searchhits)
 843             key_logdump_txt(log_level_searchhits, &key, termid->name);
 844         kno++;
 845         if (this_sys != psysno)
 846         {
 847             (sset->hits)++;
 848             psysno = this_sys;
 849             resultSetInsertSort (zh, sset,
 850                                  sort_criteria, num_criteria, psysno);
 851         }
 852     }
 853     rset_close (rfd);
 854     yaz_log(log_level_sort, ZINT_FORMAT " keys, " ZINT_FORMAT " sysnos, sort",
 855             kno, sset->hits);
 856     for (i = 0; i < numTerms; i++)
 857         yaz_log(log_level_sort, "term=\"%s\" type=%s count=" ZINT_FORMAT,
 858                  terms[i]->name, terms[i]->flags, terms[i]->rset->hits_count);
 859     *sort_status = Z_SortResponse_success;
 860     return ZEBRA_OK;
 861 }
 862
 863 RSET resultSetRef(ZebraHandle zh, const char *resultSetId)
 864 {
 865     ZebraSet s;
 866
 867     if ((s = resultSetGet (zh, resultSetId)))
 868         return s->rset;
 869     return NULL;
 870 }
 871
 872 ZEBRA_RES resultSetRank(ZebraHandle zh, ZebraSet zebraSet,
 873                         RSET rset, NMEM nmem)
 874 {
 875     struct it_key key;
 876     TERMID termid;
 877     TERMID *terms;
 878     zint kno = 0;
 879     int numTerms = 0;
 880     int n = 0;
 881     int i;
 882     ZebraRankClass rank_class;
 883     struct zset_sort_info *sort_info;
 884     const char *rank_handler_name = res_get_def(zh->res, "rank", "rank-1");
 885     size_t sysno_mem_index = 0;
 886
 887     if (zh->m_staticrank)
 888         sysno_mem_index = 1;
 889
 890     if (!log_level_set)
 891         loglevels();
 892     sort_info = zebraSet->sort_info;
 893     sort_info->num_entries = 0;
 894     zebraSet->hits = 0;
 895     rset_getterms(rset, 0, 0, &n);
 896     terms = (TERMID *) nmem_malloc(nmem, sizeof(*terms)*n);
 897     rset_getterms(rset, terms, n, &numTerms);
 898
 899
 900     rank_class = zebraRankLookup(zh, rank_handler_name);
 901     if (!rank_class)
 902     {
 903         yaz_log(YLOG_WARN, "No such rank handler: %s", rank_handler_name);
 904         zebra_setError(zh, YAZ_BIB1_UNSUPP_SEARCH, "Cannot find rank handler");
 905         return ZEBRA_FAIL;
 906     }
 907     else
 908     {
 909         RSFD rfd = rset_open(rset, RSETF_READ);
 910         struct rank_control *rc = rank_class->control;
 911         double score;
 912         zint count = 0;
 913
 914         void *handle =
 915             (*rc->begin) (zh->reg, rank_class->class_handle, rset, nmem,
 916                           terms, numTerms);
 917         zint psysno = 0;  /* previous doc id / sys no */
 918         zint pstaticrank = 0; /* previous static rank */
 919         int stop_flag = 0;
 920         while (rset_read(rfd, &key, &termid))
 921         {
 922             zint this_sys = key.mem[sysno_mem_index];
 923
 924             zint seqno = key.mem[key.len-1];
 925             kno++;
 926             if (log_level_searchhits)
 927                 key_logdump_txt(log_level_searchhits, &key, termid->name);
 928             if (this_sys != psysno)
 929             {   /* new record .. */
 930                 if (rfd->counted_items > rset->hits_limit)
 931                     break;
 932                 if (psysno)
 933                 {   /* only if we did have a previous record */
 934                     score = (*rc->calc) (handle, psysno, pstaticrank,
 935                                          &stop_flag);
 936                     /* insert the hit. A=Ascending */
 937                     resultSetInsertRank (zh, sort_info, psysno, score, 'A');
 938                     count++;
 939                     if (stop_flag)
 940                         break;
 941                 }
 942                 psysno = this_sys;
 943                 if (zh->m_staticrank)
 944                     pstaticrank = key.mem[0];
 945             }
 946             (*rc->add) (handle, CAST_ZINT_TO_INT(seqno), termid);
 947         }
 948         /* no more items */
 949         if (psysno)
 950         {   /* we had - at least - one record */
 951             score = (*rc->calc)(handle, psysno, pstaticrank, &stop_flag);
 952             /* insert the hit. A=Ascending */
 953             resultSetInsertRank(zh, sort_info, psysno, score, 'A');
 954             count++;
 955         }
 956         (*rc->end) (zh->reg, handle);
 957         rset_close (rfd);
 958     }
 959     zebraSet->hits = rset->hits_count;
 960
 961     yaz_log(log_level_searchterms, ZINT_FORMAT " keys, "
 962             ZINT_FORMAT " sysnos, rank",  kno, zebraSet->hits);
 963     for (i = 0; i < numTerms; i++)
 964     {
 965         yaz_log(log_level_searchterms, "term=\"%s\" type=%s count="
 966                 ZINT_FORMAT,
 967                 terms[i]->name, terms[i]->flags, terms[i]->rset->hits_count);
 968     }
 969     return ZEBRA_OK;
 970 }
 971
 972 ZebraRankClass zebraRankLookup(ZebraHandle zh, const char *name)
 973 {
 974     ZebraRankClass p = zh->reg->rank_classes;
 975     while (p && strcmp (p->control->name, name))
 976         p = p->next;
 977     if (p && !p->init_flag)
 978     {
 979         if (p->control->create)
 980             p->class_handle = (*p->control->create)(zh);
 981         p->init_flag = 1;
 982     }
 983     return p;
 984 }
 985
 986 void zebraRankInstall(struct zebra_register *reg, struct rank_control *ctrl)
 987 {
 988     ZebraRankClass p = (ZebraRankClass) xmalloc (sizeof(*p));
 989     p->control = (struct rank_control *) xmalloc (sizeof(*p->control));
 990     memcpy (p->control, ctrl, sizeof(*p->control));
 991     p->control->name = xstrdup (ctrl->name);
 992     p->init_flag = 0;
 993     p->next = reg->rank_classes;
 994     reg->rank_classes = p;
 995 }
 996
 997 void zebraRankDestroy(struct zebra_register *reg)
 998 {
 999     ZebraRankClass p = reg->rank_classes;
1000     while (p)
1001     {
1002         ZebraRankClass p_next = p->next;
1003         if (p->init_flag && p->control->destroy)
1004             (*p->control->destroy)(reg, p->class_handle);
1005         xfree(p->control->name);
1006         xfree(p->control);
1007         xfree(p);
1008         p = p_next;
1009     }
1010     reg->rank_classes = NULL;
1011 }
1012
1013 static int trav_rset_for_termids(RSET rset, TERMID *termid_array,
1014                                  zint *hits_array, int *approx_array)
1015 {
1016     int no = 0;
1017     int i;
1018     for (i = 0; i<rset->no_children; i++)
1019         no += trav_rset_for_termids(rset->children[i],
1020                                     (termid_array ? termid_array + no : 0),
1021                                     (hits_array ? hits_array + no : 0),
1022                                     (approx_array ? approx_array + no : 0));
1023     if (rset->term)
1024     {
1025         if (termid_array)
1026             termid_array[no] = rset->term;
1027         if (hits_array)
1028             hits_array[no] = rset->hits_count;
1029         if (approx_array)
1030             approx_array[no] = rset->hits_approx;
1031 #if 0
1032         yaz_log(YLOG_LOG, "rset=%p term=%s limit=" ZINT_FORMAT
1033                 " count=" ZINT_FORMAT,
1034                 rset, rset->term->name, rset->hits_limit, rset->hits_count);
1035 #endif
1036         no++;
1037     }
1038     return no;
1039 }
1040
1041 ZEBRA_RES zebra_result_set_term_no(ZebraHandle zh, const char *setname,
1042                                    int *num_terms)
1043 {
1044     ZebraSet sset = resultSetGet(zh, setname);
1045     *num_terms = 0;
1046     if (sset)
1047     {
1048         *num_terms = trav_rset_for_termids(sset->rset, 0, 0, 0);
1049         return ZEBRA_OK;
1050     }
1051     return ZEBRA_FAIL;
1052 }
1053
1054 ZEBRA_RES zebra_result_set_term_info(ZebraHandle zh, const char *setname,
1055                                      int no, zint *count, int *approx,
1056                                      char *termbuf, size_t *termlen,
1057                                      const char **term_ref_id)
1058 {
1059     ZebraSet sset = resultSetGet(zh, setname);
1060     if (sset)
1061     {
1062         int num_terms = trav_rset_for_termids(sset->rset, 0, 0, 0);
1063         if (no >= 0 && no < num_terms)
1064         {
1065             TERMID *term_array = xmalloc(num_terms * sizeof(*term_array));
1066             zint *hits_array = xmalloc(num_terms * sizeof(*hits_array));
1067             int *approx_array = xmalloc(num_terms * sizeof(*approx_array));
1068
1069             trav_rset_for_termids(sset->rset, term_array,
1070                                   hits_array, approx_array);
1071
1072             if (count)
1073                 *count = hits_array[no];
1074             if (approx)
1075                 *approx = approx_array[no];
1076             if (termbuf)
1077             {
1078                 char *inbuf = term_array[no]->name;
1079                 size_t inleft = strlen(inbuf);
1080                 size_t outleft = *termlen - 1;
1081
1082                 if (zh->iconv_from_utf8 != 0)
1083                 {
1084                     char *outbuf = termbuf;
1085                     size_t ret;
1086
1087                     ret = yaz_iconv(zh->iconv_from_utf8, &inbuf, &inleft,
1088                                     &outbuf, &outleft);
1089                     if (ret == (size_t)(-1))
1090                         *termlen = 0;
1091                     else
1092                         *termlen = outbuf - termbuf;
1093                 }
1094                 else
1095                 {
1096                     if (inleft > outleft)
1097                         inleft = outleft;
1098                     *termlen = inleft;
1099                     memcpy(termbuf, inbuf, *termlen);
1100                 }
1101                 termbuf[*termlen] = '\0';
1102             }
1103             if (term_ref_id)
1104                 *term_ref_id = term_array[no]->ref_id;
1105
1106             xfree(term_array);
1107             xfree(hits_array);
1108             xfree(approx_array);
1109             return ZEBRA_OK;
1110         }
1111     }
1112     return ZEBRA_FAIL;
1113 }
1114
1115 ZEBRA_RES zebra_snippets_hit_vector(ZebraHandle zh, const char *setname,
1116                                     zint sysno, zebra_snippets *snippets)
1117 {
1118     ZebraSet sset = resultSetGet(zh, setname);
1119     yaz_log(YLOG_DEBUG, "zebra_get_hit_vector setname=%s zysno=" ZINT_FORMAT,
1120             setname, sysno);
1121     if (!sset)
1122         return ZEBRA_FAIL;
1123     else
1124     {
1125         struct rset_key_control *kc = zebra_key_control_create(zh);
1126         NMEM nmem = nmem_create();
1127         struct it_key key;
1128         RSET rsets[2], rset_comb;
1129         RSET rset_temp = rstemp_create(nmem, kc, kc->scope,
1130                                        res_get (zh->res, "setTmpDir"),0 );
1131
1132         TERMID termid;
1133         RSFD rsfd = rset_open(rset_temp, RSETF_WRITE);
1134
1135         key.mem[0] = sysno;
1136         key.mem[1] = 0;
1137         key.mem[2] = 0;
1138         key.mem[3] = 0;
1139         key.len = 2;
1140         rset_write (rsfd, &key);
1141         rset_close (rsfd);
1142
1143         rsets[0] = rset_temp;
1144         rsets[1] = rset_dup(sset->rset);
1145
1146         rset_comb = rsmulti_and_create(nmem, kc, kc->scope, 2, rsets);
1147
1148         rsfd = rset_open(rset_comb, RSETF_READ);
1149
1150         while (rset_read(rsfd, &key, &termid))
1151         {
1152             if (termid)
1153             {
1154                 struct ord_list *ol;
1155                 for (ol = termid->ol; ol; ol = ol->next)
1156                 {
1157                     zebra_snippets_append(snippets, key.mem[key.len-1],
1158                                           ol->ord, termid->name);
1159                 }
1160             }
1161         }
1162         rset_close(rsfd);
1163
1164         rset_delete(rset_comb);
1165         nmem_destroy(nmem);
1166         kc->dec(kc);
1167     }
1168     return ZEBRA_OK;
1169 }
1170