index/zsets.c

   1 /* $Id: zsets.c,v 1.106 2006-06-06 21:01:30 adam Exp $
   2    Copyright (C) 1995-2006
   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 "rank.h"
  34 #include <yaz/diagbib1.h>
  35 #include <rset.h>
  36
  37 #define SORT_IDX_ENTRYSIZE 64
  38 #define ZSET_SORT_MAX_LEVEL 3
  39
  40 struct zebra_set_term_entry {
  41     int reg_type;
  42     char *db;
  43     char *index_name;
  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, const char *index_name,
 185                       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].index_name = nmem_strdup(s->nmem, index_name);
 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->sortSpec = 0;
 271     s->cache_position = 0;
 272     s->cache_rfd = 0;
 273     s->approx_limit = zh->approx_limit;
 274     return s;
 275 }
 276
 277 ZebraSet resultSetGet(ZebraHandle zh, const char *name)
 278 {
 279     ZebraSet s;
 280
 281     for (s = zh->sets; s; s = s->next)
 282         if (!strcmp (s->name, name))
 283         {
 284             if (!s->term_entries && !s->rset && s->rpn)
 285             {
 286                 NMEM nmem = nmem_create ();
 287                 yaz_log(log_level_resultsets, "research %s", name);
 288                 if (!s->rset_nmem)
 289                     s->rset_nmem=nmem_create();
 290                 resultSetSearch(zh, nmem, s->rset_nmem, s->rpn, s);
 291                 if (s->rset && s->sortSpec)
 292                 {
 293                     int sort_status;
 294                     yaz_log(log_level_resultsets, "resort %s", name);
 295                     resultSetSortSingle (zh, nmem, s, s->rset, s->sortSpec,
 296                                          &sort_status);
 297                 }
 298                 nmem_destroy (nmem);
 299             }
 300             return s;
 301         }
 302     return NULL;
 303 }
 304
 305 void resultSetInvalidate (ZebraHandle zh)
 306 {
 307     ZebraSet s = zh->sets;
 308
 309     yaz_log(log_level_resultsets, "invalidating result sets");
 310     for (; s; s = s->next)
 311     {
 312         if (s->rset)
 313         {
 314             if (s->cache_rfd)
 315                 rset_close(s->cache_rfd);
 316             rset_delete (s->rset);
 317         }
 318         s->rset = 0;
 319         s->cache_rfd = 0;
 320         s->cache_position = 0;
 321         if (s->rset_nmem)
 322             nmem_destroy(s->rset_nmem);
 323         s->rset_nmem=0;
 324     }
 325 }
 326
 327 void resultSetDestroy(ZebraHandle zh, int num, char **names,int *statuses)
 328 {
 329     ZebraSet * ss = &zh->sets;
 330     int i;
 331
 332     if (statuses)
 333         for (i = 0; i<num; i++)
 334             statuses[i] = Z_DeleteStatus_resultSetDidNotExist;
 335     while (*ss)
 336     {
 337         int i = -1;
 338         ZebraSet s = *ss;
 339         if (num >= 0)
 340         {
 341             for (i = 0; i<num; i++)
 342                 if (!strcmp (s->name, names[i]))
 343                 {
 344                     if (statuses)
 345                         statuses[i] = Z_DeleteStatus_success;
 346                     i = -1;
 347                     break;
 348                 }
 349         }
 350         if (i < 0)
 351         {
 352             *ss = s->next;
 353
 354             xfree (s->sort_info->all_entries);
 355             xfree (s->sort_info->entries);
 356             xfree (s->sort_info);
 357
 358             if (s->nmem)
 359                 nmem_destroy (s->nmem);
 360             if (s->rset)
 361             {
 362                 if (s->cache_rfd)
 363                     rset_close(s->cache_rfd);
 364                 rset_delete (s->rset);
 365             }
 366             if (s->rset_nmem)
 367                 nmem_destroy(s->rset_nmem);
 368             xfree (s->name);
 369             xfree (s);
 370         }
 371         else
 372             ss = &s->next;
 373     }
 374 }
 375
 376 ZebraMetaRecord *zebra_meta_records_create_range(ZebraHandle zh,
 377                                                  const char *name,
 378                                                  zint start, int num)
 379 {
 380     zint pos_small[10];
 381     zint *pos = pos_small;
 382     ZebraMetaRecord *mr;
 383     int i;
 384
 385     if (num > 10000 || num <= 0)
 386         return 0;
 387
 388     if (num > 10)
 389         pos = xmalloc(sizeof(*pos) * num);
 390
 391     for (i = 0; i<num; i++)
 392         pos[i] = start+i;
 393
 394     mr = zebra_meta_records_create(zh, name, num, pos);
 395
 396     if (num > 10)
 397         xfree(pos);
 398     return mr;
 399 }
 400
 401 ZebraMetaRecord *zebra_meta_records_create(ZebraHandle zh, const char *name,
 402                                            int num, zint *positions)
 403 {
 404     ZebraSet sset;
 405     ZebraMetaRecord *sr = 0;
 406     RSET rset;
 407     int i;
 408     struct zset_sort_info *sort_info;
 409     size_t sysno_mem_index = 0;
 410
 411     if (zh->m_staticrank)
 412         sysno_mem_index = 1;
 413
 414     if (!log_level_set)
 415         loglevels();
 416     if (!(sset = resultSetGet (zh, name)))
 417         return NULL;
 418     if (!(rset = sset->rset))
 419     {
 420         if (!sset->term_entries)
 421             return 0;
 422         sr = (ZebraMetaRecord *) xmalloc (sizeof(*sr) * num);
 423         for (i = 0; i<num; i++)
 424         {
 425             sr[i].sysno = 0;
 426             sr[i].score = -1;
 427             sr[i].term = 0;
 428             sr[i].db = 0;
 429
 430             if (positions[i] <= sset->term_entries_max)
 431             {
 432                 sr[i].term = sset->term_entries[positions[i]-1].term;
 433                 sr[i].db = sset->term_entries[positions[i]-1].db;
 434             }
 435         }
 436     }
 437     else
 438     {
 439         sr = (ZebraMetaRecord *) xmalloc (sizeof(*sr) * num);
 440         for (i = 0; i<num; i++)
 441         {
 442             sr[i].sysno = 0;
 443             sr[i].score = -1;
 444             sr[i].term = 0;
 445             sr[i].db = 0;
 446         }
 447         sort_info = sset->sort_info;
 448         if (sort_info)
 449         {
 450             zint position;
 451
 452             for (i = 0; i<num; i++)
 453             {
 454                 position = positions[i];
 455                 if (position > 0 && position <= sort_info->num_entries)
 456                 {
 457                     yaz_log(log_level_sort, "got pos=" ZINT_FORMAT
 458                             " (sorted)", position);
 459                     sr[i].sysno = sort_info->entries[position-1]->sysno;
 460                     sr[i].score = sort_info->entries[position-1]->score;
 461                 }
 462             }
 463         }
 464         /* did we really get all entries using sort ? */
 465         for (i = 0; i<num; i++)
 466         {
 467             if (!sr[i].sysno)
 468                 break;
 469         }
 470         if (i < num) /* nope, get the rest, unsorted - sorry */
 471         {
 472             zint position = 0;
 473             int num_i = 0;
 474             zint psysno = 0;
 475             RSFD rfd;
 476             struct it_key key;
 477
 478             if (sort_info)
 479                 position = sort_info->num_entries;
 480             while (num_i < num && positions[num_i] <= position)
 481                 num_i++;
 482
 483             if (sset->cache_rfd &&
 484                 num_i < num && positions[num_i] > sset->cache_position)
 485             {
 486                 position = sset->cache_position;
 487                 rfd = sset->cache_rfd;
 488                 psysno = sset->cache_psysno;
 489             }
 490             else
 491             {
 492                 if (sset->cache_rfd)
 493                     rset_close(sset->cache_rfd);
 494                 rfd = rset_open (rset, RSETF_READ);
 495             }
 496             while (num_i < num && rset_read (rfd, &key, 0))
 497             {
 498                 zint this_sys = key.mem[sysno_mem_index];
 499                 if (this_sys != psysno)
 500                 {
 501                     psysno = this_sys;
 502                     if (sort_info)
 503                     {
 504                         /* determine we alreay have this in our set */
 505                         for (i = sort_info->num_entries; --i >= 0; )
 506                             if (psysno == sort_info->entries[i]->sysno)
 507                                 break;
 508                         if (i >= 0)
 509                             continue;
 510                     }
 511                     position++;
 512                     assert (num_i < num);
 513                     if (position == positions[num_i])
 514                     {
 515                         sr[num_i].sysno = psysno;
 516                         yaz_log(log_level_sort, "got pos=" ZINT_FORMAT " (unsorted)", position);
 517                         sr[num_i].score = -1;
 518                         num_i++;
 519                     }
 520                 }
 521             }
 522             sset->cache_position = position;
 523             sset->cache_psysno = psysno;
 524             sset->cache_rfd = rfd;
 525         }
 526     }
 527     return sr;
 528 }
 529
 530 void zebra_meta_records_destroy (ZebraHandle zh, ZebraMetaRecord *records,
 531                                  int num)
 532 {
 533     assert(zh); /* compiler shut up about unused arg */
 534     xfree (records);
 535 }
 536
 537 struct sortKeyInfo {
 538     int relation;
 539 #if 0
 540     int attrUse;
 541 #else
 542     int ord;
 543 #endif
 544     int numerical;
 545 };
 546
 547 void resultSetInsertSort (ZebraHandle zh, ZebraSet sset,
 548                           struct sortKeyInfo *criteria, int num_criteria,
 549                           zint sysno)
 550 {
 551     struct zset_sort_entry this_entry;
 552     struct zset_sort_entry *new_entry = NULL;
 553     struct zset_sort_info *sort_info = sset->sort_info;
 554     int i, j;
 555
 556     sortIdx_sysno (zh->reg->sortIdx, sysno);
 557     for (i = 0; i<num_criteria; i++)
 558     {
 559         memset(this_entry.buf[i], '\0', SORT_IDX_ENTRYSIZE);
 560         if (criteria[i].ord != -1)
 561         {
 562             sortIdx_type (zh->reg->sortIdx, criteria[i].ord);
 563             sortIdx_read (zh->reg->sortIdx, this_entry.buf[i]);
 564         }
 565     }
 566     i = sort_info->num_entries;
 567     while (--i >= 0)
 568     {
 569         int rel = 0;
 570         for (j = 0; j<num_criteria; j++)
 571         {
 572             if (criteria[j].numerical)
 573             {
 574                 double diff = atof(this_entry.buf[j]) -
 575                               atof(sort_info->entries[i]->buf[j]);
 576                 rel = 0;
 577                 if (diff > 0.0)
 578                     rel = 1;
 579                 else if (diff < 0.0)
 580                     rel = -1;
 581             }
 582             else
 583             {
 584                 rel = memcmp (this_entry.buf[j], sort_info->entries[i]->buf[j],
 585                               SORT_IDX_ENTRYSIZE);
 586             }
 587             if (rel)
 588                 break;
 589         }
 590         if (!rel)
 591             break;
 592         if (criteria[j].relation == 'A')
 593         {
 594             if (rel > 0)
 595                 break;
 596         }
 597         else if (criteria[j].relation == 'D')
 598         {
 599             if (rel < 0)
 600                 break;
 601         }
 602     }
 603     ++i;
 604     j = sort_info->max_entries;
 605     if (i == j)
 606         return;
 607
 608     if (sort_info->num_entries == j)
 609         --j;
 610     else
 611         j = (sort_info->num_entries)++;
 612     new_entry = sort_info->entries[j];
 613     while (j != i)
 614     {
 615         sort_info->entries[j] = sort_info->entries[j-1];
 616         --j;
 617     }
 618     sort_info->entries[i] = new_entry;
 619     assert (new_entry);
 620     for (i = 0; i<num_criteria; i++)
 621         memcpy (new_entry->buf[i], this_entry.buf[i], SORT_IDX_ENTRYSIZE);
 622     new_entry->sysno = sysno;
 623     new_entry->score = -1;
 624 }
 625
 626 void resultSetInsertRank (ZebraHandle zh, struct zset_sort_info *sort_info,
 627                           zint sysno, int score, int relation)
 628 {
 629     struct zset_sort_entry *new_entry = NULL;
 630     int i, j;
 631     assert(zh); /* compiler shut up about unused arg */
 632
 633     i = sort_info->num_entries;
 634     while (--i >= 0)
 635     {
 636         int rel = 0;
 637
 638         rel = score - sort_info->entries[i]->score;
 639
 640         if (relation == 'D')
 641         {
 642             if (rel >= 0)
 643                 break;
 644         }
 645         else if (relation == 'A')
 646         {
 647             if (rel <= 0)
 648                 break;
 649         }
 650     }
 651     ++i;
 652     j = sort_info->max_entries;
 653     if (i == j)
 654         return;
 655
 656     if (sort_info->num_entries == j)
 657         --j;
 658     else
 659         j = (sort_info->num_entries)++;
 660
 661     new_entry = sort_info->entries[j];
 662     while (j != i)
 663     {
 664         sort_info->entries[j] = sort_info->entries[j-1];
 665         --j;
 666     }
 667     sort_info->entries[i] = new_entry;
 668     assert (new_entry);
 669     new_entry->sysno = sysno;
 670     new_entry->score = score;
 671 }
 672
 673 static Z_RPNQuery *copy_RPNQuery(Z_RPNQuery *src, NMEM nmem)
 674 {
 675     Z_RPNQuery *dst = 0;
 676     ODR encode = odr_createmem(ODR_ENCODE);
 677     ODR decode = odr_createmem(ODR_DECODE);
 678
 679     if (z_RPNQuery(encode, &src, 0, 0))
 680     {
 681         int len;
 682         char *buf = odr_getbuf(encode, &len, 0);
 683
 684         if (buf)
 685         {
 686             odr_setbuf(decode, buf, len, 0);
 687             z_RPNQuery(decode, &dst, 0, 0);
 688         }
 689     }
 690     nmem_transfer(nmem, decode->mem);
 691     odr_destroy(encode);
 692     odr_destroy(decode);
 693     return dst;
 694 }
 695
 696 static Z_SortKeySpecList *copy_SortKeySpecList(Z_SortKeySpecList *src, NMEM nmem)
 697 {
 698     Z_SortKeySpecList *dst = 0;
 699     ODR encode = odr_createmem(ODR_ENCODE);
 700     ODR decode = odr_createmem(ODR_DECODE);
 701
 702     if (z_SortKeySpecList(encode, &src, 0, 0))
 703     {
 704         int len;
 705         char *buf = odr_getbuf(encode, &len, 0);
 706
 707         if (buf)
 708         {
 709             odr_setbuf(decode, buf, len, 0);
 710             z_SortKeySpecList(decode, &dst, 0, 0);
 711         }
 712     }
 713     nmem_transfer(nmem, decode->mem);
 714     odr_destroy(encode);
 715     odr_destroy(decode);
 716     return dst;
 717 }
 718
 719 ZebraSet resultSetClone(ZebraHandle zh, const char *setname,
 720                         ZebraSet rset)
 721 {
 722     ZebraSet nset;
 723     int i;
 724
 725     nset = resultSetAdd(zh, setname, 1);
 726     if (!nset)
 727         return 0;
 728
 729     nset->nmem = nmem_create();
 730
 731     nset->num_bases = rset->num_bases;
 732     nset->basenames =
 733         nmem_malloc (nset->nmem, nset->num_bases * sizeof(*rset->basenames));
 734     for (i = 0; i<rset->num_bases; i++)
 735         nset->basenames[i] = nmem_strdup(nset->nmem, rset->basenames[i]);
 736
 737     if (rset->rset)
 738         nset->rset = rset_dup(rset->rset);
 739     if (rset->rpn)
 740         nset->rpn = copy_RPNQuery(rset->rpn, nset->nmem);
 741     return nset;
 742 }
 743
 744 ZEBRA_RES resultSetSort(ZebraHandle zh, NMEM nmem,
 745                         int num_input_setnames, const char **input_setnames,
 746                         const char *output_setname,
 747                         Z_SortKeySpecList *sort_sequence, int *sort_status)
 748 {
 749     ZebraSet sset;
 750     RSET rset;
 751
 752     if (num_input_setnames == 0)
 753     {
 754         zebra_setError(zh, YAZ_BIB1_NO_RESULT_SET_NAME_SUPPLIED_ON_SORT, 0);
 755         return ZEBRA_FAIL;
 756     }
 757     if (num_input_setnames > 1)
 758     {
 759         zebra_setError(zh, YAZ_BIB1_SORT_TOO_MANY_INPUT_RESULTS, 0);
 760         return ZEBRA_FAIL;
 761     }
 762     if (!log_level_set)
 763         loglevels();
 764     yaz_log(log_level_sort, "result set sort input=%s output=%s",
 765           *input_setnames, output_setname);
 766     sset = resultSetGet (zh, input_setnames[0]);
 767     if (!sset)
 768     {
 769         zebra_setError(zh, YAZ_BIB1_SPECIFIED_RESULT_SET_DOES_NOT_EXIST,
 770                        input_setnames[0]);
 771         return ZEBRA_FAIL;
 772     }
 773     if (!(rset = sset->rset))
 774     {
 775         zebra_setError(zh, YAZ_BIB1_SPECIFIED_RESULT_SET_DOES_NOT_EXIST,
 776                        input_setnames[0]);
 777         return ZEBRA_FAIL;
 778     }
 779     if (strcmp (output_setname, input_setnames[0]))
 780         sset = resultSetClone(zh, output_setname, sset);
 781     sset->sortSpec = copy_SortKeySpecList(sort_sequence, sset->nmem);
 782     return resultSetSortSingle (zh, nmem, sset, rset, sort_sequence,
 783                                 sort_status);
 784 }
 785
 786 ZEBRA_RES resultSetSortSingle(ZebraHandle zh, NMEM nmem,
 787                               ZebraSet sset, RSET rset,
 788                               Z_SortKeySpecList *sort_sequence,
 789                               int *sort_status)
 790 {
 791     int i;
 792     int n = 0;
 793     zint kno = 0;
 794     zint psysno = 0;
 795     struct it_key key;
 796     struct sortKeyInfo sort_criteria[3];
 797     int num_criteria;
 798     RSFD rfd;
 799     TERMID termid;
 800     TERMID *terms;
 801     int numTerms = 0;
 802     size_t sysno_mem_index = 0;
 803
 804     if (zh->m_staticrank)
 805         sysno_mem_index = 1;
 806
 807     assert(nmem); /* compiler shut up about unused param */
 808     sset->sort_info->num_entries = 0;
 809
 810     rset_getterms(rset, 0, 0, &n);
 811     terms = (TERMID *) nmem_malloc(nmem, sizeof(*terms)*n);
 812     rset_getterms(rset, terms, n, &numTerms);
 813
 814     sset->hits = 0;
 815     num_criteria = sort_sequence->num_specs;
 816     if (num_criteria > 3)
 817         num_criteria = 3;
 818     for (i = 0; i < num_criteria; i++)
 819     {
 820         Z_SortKeySpec *sks = sort_sequence->specs[i];
 821         Z_SortKey *sk;
 822         ZEBRA_RES res;
 823
 824         sort_criteria[i].ord = -1;
 825         sort_criteria[i].numerical = 0;
 826
 827         if (sks->which == Z_SortKeySpec_missingValueData)
 828         {
 829             zebra_setError(zh, YAZ_BIB1_UNSUPP_MISSING_DATA_ACTION, 0);
 830             return ZEBRA_FAIL;
 831         }
 832         if (*sks->sortRelation == Z_SortKeySpec_ascending)
 833             sort_criteria[i].relation = 'A';
 834         else if (*sks->sortRelation == Z_SortKeySpec_descending)
 835             sort_criteria[i].relation = 'D';
 836         else
 837         {
 838             zebra_setError(zh, YAZ_BIB1_ILLEGAL_SORT_RELATION, 0);
 839             return ZEBRA_FAIL;
 840         }
 841         if (sks->sortElement->which == Z_SortElement_databaseSpecific)
 842         {
 843             zebra_setError(zh, YAZ_BIB1_DATABASE_SPECIFIC_SORT_UNSUPP, 0);
 844             return ZEBRA_FAIL;
 845         }
 846         else if (sks->sortElement->which != Z_SortElement_generic)
 847         {
 848             zebra_setError(zh, YAZ_BIB1_SORT_ILLEGAL_SORT, 0);
 849             return ZEBRA_FAIL;
 850         }
 851         sk = sks->sortElement->u.generic;
 852         switch (sk->which)
 853         {
 854         case Z_SortKey_sortField:
 855             yaz_log(log_level_sort, "key %d is of type sortField",
 856                     i+1);
 857             sort_criteria[i].numerical = 0;
 858             sort_criteria[i].ord =
 859                 zebraExplain_lookup_attr_str(zh->reg->zei, 's',
 860                                              sk->u.sortField);
 861             if (sks->which != Z_SortKeySpec_null
 862                 && sort_criteria[i].ord == -1)
 863             {
 864                 zebra_setError(zh,
 865                                YAZ_BIB1_CANNOT_SORT_ACCORDING_TO_SEQUENCE, 0);
 866                 return ZEBRA_FAIL;
 867             }
 868             break;
 869         case Z_SortKey_elementSpec:
 870             yaz_log(log_level_sort, "key %d is of type elementSpec",
 871                     i+1);
 872             zebra_setError(zh, YAZ_BIB1_CANNOT_SORT_ACCORDING_TO_SEQUENCE, 0);
 873             return ZEBRA_FAIL;
 874         case Z_SortKey_sortAttributes:
 875             yaz_log(log_level_sort, "key %d is of type sortAttributes", i+1);
 876             res = zebra_sort_get_ord(zh, sk->u.sortAttributes,
 877                                      &sort_criteria[i].ord,
 878                                      &sort_criteria[i].numerical);
 879             if (sks->which != Z_SortKeySpec_null && res != ZEBRA_OK)
 880                 return ZEBRA_FAIL;
 881             break;
 882         }
 883     }
 884     rfd = rset_open (rset, RSETF_READ);
 885     while (rset_read (rfd, &key, &termid))
 886     {
 887         zint this_sys = key.mem[sysno_mem_index];
 888         if (log_level_searchhits)
 889             key_logdump_txt(log_level_searchhits, &key, termid->name);
 890         kno++;
 891         if (this_sys != psysno)
 892         {
 893             (sset->hits)++;
 894             psysno = this_sys;
 895             resultSetInsertSort (zh, sset,
 896                                  sort_criteria, num_criteria, psysno);
 897         }
 898     }
 899     rset_close (rfd);
 900     yaz_log(log_level_sort, ZINT_FORMAT " keys, " ZINT_FORMAT " sysnos, sort",
 901             kno, sset->hits);
 902     for (i = 0; i < numTerms; i++)
 903         yaz_log(log_level_sort, "term=\"%s\" type=%s count=" ZINT_FORMAT,
 904                  terms[i]->name, terms[i]->flags, terms[i]->rset->hits_count);
 905     *sort_status = Z_SortResponse_success;
 906     return ZEBRA_OK;
 907 }
 908
 909 RSET resultSetRef(ZebraHandle zh, const char *resultSetId)
 910 {
 911     ZebraSet s;
 912
 913     if ((s = resultSetGet (zh, resultSetId)))
 914         return s->rset;
 915     return NULL;
 916 }
 917
 918 ZEBRA_RES resultSetRank(ZebraHandle zh, ZebraSet zebraSet,
 919                         RSET rset, NMEM nmem)
 920 {
 921     struct it_key key;
 922     TERMID termid;
 923     TERMID *terms;
 924     zint kno = 0;
 925     int numTerms = 0;
 926     int n = 0;
 927     int i;
 928     ZebraRankClass rank_class;
 929     struct zset_sort_info *sort_info;
 930     const char *rank_handler_name = res_get_def(zh->res, "rank", "rank-1");
 931     size_t sysno_mem_index = 0;
 932
 933     if (zh->m_staticrank)
 934         sysno_mem_index = 1;
 935
 936     if (!log_level_set)
 937         loglevels();
 938     sort_info = zebraSet->sort_info;
 939     sort_info->num_entries = 0;
 940     zebraSet->hits = 0;
 941     rset_getterms(rset, 0, 0, &n);
 942     terms = (TERMID *) nmem_malloc(nmem, sizeof(*terms)*n);
 943     rset_getterms(rset, terms, n, &numTerms);
 944
 945
 946     rank_class = zebraRankLookup(zh, rank_handler_name);
 947     if (!rank_class)
 948     {
 949         yaz_log(YLOG_WARN, "No such rank handler: %s", rank_handler_name);
 950         zebra_setError(zh, YAZ_BIB1_UNSUPP_SEARCH, "Cannot find rank handler");
 951         return ZEBRA_FAIL;
 952     }
 953     else
 954     {
 955         RSFD rfd = rset_open(rset, RSETF_READ);
 956         struct rank_control *rc = rank_class->control;
 957         double score;
 958         zint count = 0;
 959
 960         void *handle =
 961             (*rc->begin) (zh->reg, rank_class->class_handle, rset, nmem,
 962                           terms, numTerms);
 963         zint psysno = 0;  /* previous doc id / sys no */
 964         zint pstaticrank = 0; /* previous static rank */
 965         int stop_flag = 0;
 966         while (rset_read(rfd, &key, &termid))
 967         {
 968             zint this_sys = key.mem[sysno_mem_index];
 969
 970             zint seqno = key.mem[key.len-1];
 971             kno++;
 972             if (log_level_searchhits)
 973                 key_logdump_txt(log_level_searchhits, &key, termid->name);
 974             if (this_sys != psysno)
 975             {   /* new record .. */
 976                 if (rfd->counted_items > rset->hits_limit)
 977                     break;
 978                 if (psysno)
 979                 {   /* only if we did have a previous record */
 980                     score = (*rc->calc) (handle, psysno, pstaticrank,
 981                                          &stop_flag);
 982                     /* insert the hit. A=Ascending */
 983                     resultSetInsertRank (zh, sort_info, psysno, score, 'A');
 984                     count++;
 985                     if (stop_flag)
 986                         break;
 987                 }
 988                 psysno = this_sys;
 989                 if (zh->m_staticrank)
 990                     pstaticrank = key.mem[0];
 991             }
 992             (*rc->add) (handle, CAST_ZINT_TO_INT(seqno), termid);
 993         }
 994         /* no more items */
 995         if (psysno)
 996         {   /* we had - at least - one record */
 997             score = (*rc->calc)(handle, psysno, pstaticrank, &stop_flag);
 998             /* insert the hit. A=Ascending */
 999             resultSetInsertRank(zh, sort_info, psysno, score, 'A');
1000             count++;
1001         }
1002         (*rc->end) (zh->reg, handle);
1003         rset_close (rfd);
1004     }
1005     zebraSet->hits = rset->hits_count;
1006
1007     yaz_log(log_level_searchterms, ZINT_FORMAT " keys, "
1008             ZINT_FORMAT " sysnos, rank",  kno, zebraSet->hits);
1009     for (i = 0; i < numTerms; i++)
1010     {
1011         yaz_log(log_level_searchterms, "term=\"%s\" type=%s count="
1012                 ZINT_FORMAT,
1013                 terms[i]->name, terms[i]->flags, terms[i]->rset->hits_count);
1014     }
1015     return ZEBRA_OK;
1016 }
1017
1018 ZebraRankClass zebraRankLookup(ZebraHandle zh, const char *name)
1019 {
1020     ZebraRankClass p = zh->reg->rank_classes;
1021     while (p && strcmp (p->control->name, name))
1022         p = p->next;
1023     if (p && !p->init_flag)
1024     {
1025         if (p->control->create)
1026             p->class_handle = (*p->control->create)(zh);
1027         p->init_flag = 1;
1028     }
1029     return p;
1030 }
1031
1032 void zebraRankInstall(struct zebra_register *reg, struct rank_control *ctrl)
1033 {
1034     ZebraRankClass p = (ZebraRankClass) xmalloc (sizeof(*p));
1035     p->control = (struct rank_control *) xmalloc (sizeof(*p->control));
1036     memcpy (p->control, ctrl, sizeof(*p->control));
1037     p->control->name = xstrdup (ctrl->name);
1038     p->init_flag = 0;
1039     p->next = reg->rank_classes;
1040     reg->rank_classes = p;
1041 }
1042
1043 void zebraRankDestroy(struct zebra_register *reg)
1044 {
1045     ZebraRankClass p = reg->rank_classes;
1046     while (p)
1047     {
1048         ZebraRankClass p_next = p->next;
1049         if (p->init_flag && p->control->destroy)
1050             (*p->control->destroy)(reg, p->class_handle);
1051         xfree(p->control->name);
1052         xfree(p->control);
1053         xfree(p);
1054         p = p_next;
1055     }
1056     reg->rank_classes = NULL;
1057 }
1058
1059 static int trav_rset_for_termids(RSET rset, TERMID *termid_array,
1060                                  zint *hits_array, int *approx_array)
1061 {
1062     int no = 0;
1063     int i;
1064     for (i = 0; i<rset->no_children; i++)
1065         no += trav_rset_for_termids(rset->children[i],
1066                                     (termid_array ? termid_array + no : 0),
1067                                     (hits_array ? hits_array + no : 0),
1068                                     (approx_array ? approx_array + no : 0));
1069     if (rset->term)
1070     {
1071         if (termid_array)
1072             termid_array[no] = rset->term;
1073         if (hits_array)
1074             hits_array[no] = rset->hits_count;
1075         if (approx_array)
1076             approx_array[no] = rset->hits_approx;
1077 #if 0
1078         yaz_log(YLOG_LOG, "rset=%p term=%s limit=" ZINT_FORMAT
1079                 " count=" ZINT_FORMAT,
1080                 rset, rset->term->name, rset->hits_limit, rset->hits_count);
1081 #endif
1082         no++;
1083     }
1084     return no;
1085 }
1086
1087 ZEBRA_RES zebra_result_set_term_no(ZebraHandle zh, const char *setname,
1088                                    int *num_terms)
1089 {
1090     ZebraSet sset = resultSetGet(zh, setname);
1091     *num_terms = 0;
1092     if (sset)
1093     {
1094         *num_terms = trav_rset_for_termids(sset->rset, 0, 0, 0);
1095         return ZEBRA_OK;
1096     }
1097     return ZEBRA_FAIL;
1098 }
1099
1100 ZEBRA_RES zebra_result_set_term_info(ZebraHandle zh, const char *setname,
1101                                      int no, zint *count, int *approx,
1102                                      char *termbuf, size_t *termlen,
1103                                      const char **term_ref_id)
1104 {
1105     ZebraSet sset = resultSetGet(zh, setname);
1106     if (sset)
1107     {
1108         int num_terms = trav_rset_for_termids(sset->rset, 0, 0, 0);
1109         if (no >= 0 && no < num_terms)
1110         {
1111             TERMID *term_array = xmalloc(num_terms * sizeof(*term_array));
1112             zint *hits_array = xmalloc(num_terms * sizeof(*hits_array));
1113             int *approx_array = xmalloc(num_terms * sizeof(*approx_array));
1114
1115             trav_rset_for_termids(sset->rset, term_array,
1116                                   hits_array, approx_array);
1117
1118             if (count)
1119                 *count = hits_array[no];
1120             if (approx)
1121                 *approx = approx_array[no];
1122             if (termbuf)
1123             {
1124                 char *inbuf = term_array[no]->name;
1125                 size_t inleft = strlen(inbuf);
1126                 size_t outleft = *termlen - 1;
1127
1128                 if (zh->iconv_from_utf8 != 0)
1129                 {
1130                     char *outbuf = termbuf;
1131                     size_t ret;
1132
1133                     ret = yaz_iconv(zh->iconv_from_utf8, &inbuf, &inleft,
1134                                     &outbuf, &outleft);
1135                     if (ret == (size_t)(-1))
1136                         *termlen = 0;
1137                     else
1138                         *termlen = outbuf - termbuf;
1139                 }
1140                 else
1141                 {
1142                     if (inleft > outleft)
1143                         inleft = outleft;
1144                     *termlen = inleft;
1145                     memcpy(termbuf, inbuf, *termlen);
1146                 }
1147                 termbuf[*termlen] = '\0';
1148             }
1149             if (term_ref_id)
1150                 *term_ref_id = term_array[no]->ref_id;
1151
1152             xfree(term_array);
1153             xfree(hits_array);
1154             xfree(approx_array);
1155             return ZEBRA_OK;
1156         }
1157     }
1158     return ZEBRA_FAIL;
1159 }
1160
1161 ZEBRA_RES zebra_snippets_hit_vector(ZebraHandle zh, const char *setname,
1162                                     zint sysno, zebra_snippets *snippets)
1163 {
1164     ZebraSet sset = resultSetGet(zh, setname);
1165     yaz_log(YLOG_DEBUG, "zebra_get_hit_vector setname=%s zysno=" ZINT_FORMAT,
1166             setname, sysno);
1167     if (!sset)
1168         return ZEBRA_FAIL;
1169     else
1170     {
1171         struct rset_key_control *kc = zebra_key_control_create(zh);
1172         NMEM nmem = nmem_create();
1173         struct it_key key;
1174         RSET rsets[2], rset_comb;
1175         RSET rset_temp = rset_create_temp(nmem, kc, kc->scope,
1176                                           res_get (zh->res, "setTmpDir"),0 );
1177
1178         TERMID termid;
1179         RSFD rsfd = rset_open(rset_temp, RSETF_WRITE);
1180
1181         key.mem[0] = sysno;
1182         key.mem[1] = 0;
1183         key.mem[2] = 0;
1184         key.mem[3] = 0;
1185         key.len = 2;
1186         rset_write (rsfd, &key);
1187         rset_close (rsfd);
1188
1189         rsets[0] = rset_temp;
1190         rsets[1] = rset_dup(sset->rset);
1191
1192         rset_comb = rset_create_and(nmem, kc, kc->scope, 2, rsets);
1193
1194         rsfd = rset_open(rset_comb, RSETF_READ);
1195
1196         while (rset_read(rsfd, &key, &termid))
1197         {
1198             if (termid)
1199             {
1200                 struct ord_list *ol;
1201                 for (ol = termid->ol; ol; ol = ol->next)
1202                 {
1203                     zebra_snippets_append(snippets, key.mem[key.len-1],
1204                                           ol->ord, termid->name);
1205                 }
1206             }
1207         }
1208         rset_close(rsfd);
1209
1210         rset_delete(rset_comb);
1211         nmem_destroy(nmem);
1212         kc->dec(kc);
1213     }
1214     return ZEBRA_OK;
1215 }
1216
1217 /*
1218  * Local variables:
1219  * c-basic-offset: 4
1220  * indent-tabs-mode: nil
1221  * End:
1222  * vim: shiftwidth=4 tabstop=8 expandtab
1223  */
1224