index/rank1.c

   1 /*
   2  * Copyright (C) 1998-1999, Index Data
   3  * All rights reserved.
   4  * Sebastian Hammer, Adam Dickmeiss
   5  *
   6  * $Log: rank1.c,v $
   7  * Revision 1.7  2001-11-14 22:06:27  adam
   8  * Rank-weight may be controlled via query.
   9  *
  10  * Revision 1.6  2000/03/15 15:00:30  adam
  11  * First work on threaded version.
  12  *
  13  * Revision 1.5  1999/05/26 07:49:13  adam
  14  * C++ compilation.
  15  *
  16  * Revision 1.4  1999/02/02 14:51:01  adam
  17  * Updated WIN32 code specific sections. Changed header.
  18  *
  19  * Revision 1.3  1998/06/12 12:21:53  adam
  20  * Fixed memory-leak.
  21  *
  22  * Revision 1.2  1998/03/05 13:03:29  adam
  23  * Improved ranking.
  24  *
  25  * Revision 1.1  1998/03/05 08:45:12  adam
  26  * New result set model and modular ranking system. Moved towards
  27  * descent server API. System information stored as "SGML" records.
  28  *
  29  */
  30
  31 #include <stdio.h>
  32 #include <assert.h>
  33 #ifdef WIN32
  34 #include <io.h>
  35 #else
  36 #include <unistd.h>
  37 #endif
  38
  39 #include "zserver.h"
  40
  41 struct rank_class_info {
  42     int dummy;
  43 };
  44
  45 struct rank_term_info {
  46     int local_occur;
  47     int global_occur;
  48     int global_inv;
  49     int rank_flag;
  50     int rank_weight;
  51 };
  52
  53 struct rank_set_info {
  54     int last_pos;
  55     int no_entries;
  56     int no_rank_entries;
  57     struct rank_term_info *entries;
  58 };
  59
  60 static int log2_int (unsigned g)
  61 {
  62     int n = 0;
  63     while ((g = g>>1))
  64         n++;
  65     return n;
  66 }
  67
  68 /*
  69  * create: Creates/Initialises this rank handler. This routine is
  70  *  called exactly once. The routine returns the class_handle.
  71  */
  72 static void *create (ZebraService zh)
  73 {
  74     struct rank_class_info *ci = (struct rank_class_info *)
  75         xmalloc (sizeof(*ci));
  76
  77     logf (LOG_DEBUG, "rank-1 create");
  78     return ci;
  79 }
  80
  81 /*
  82  * destroy: Destroys this rank handler. This routine is called
  83  *  when the handler is no longer needed - i.e. when the server
  84  *  dies. The class_handle was previously returned by create.
  85  */
  86 static void destroy (ZebraService zh, void *class_handle)
  87 {
  88     struct rank_class_info *ci = (struct rank_class_info *) class_handle;
  89
  90     logf (LOG_DEBUG, "rank-1 destroy");
  91     xfree (ci);
  92 }
  93
  94
  95 /*
  96  * begin: Prepares beginning of "real" ranking. Called once for
  97  *  each result set. The returned handle is a "set handle" and
  98  *  will be used in each of the handlers below.
  99  */
 100 static void *begin (ZebraHandle zh, void *class_handle, RSET rset)
 101 {
 102     struct rank_set_info *si = (struct rank_set_info *) xmalloc (sizeof(*si));
 103     int i;
 104
 105     logf (LOG_DEBUG, "rank-1 begin");
 106     si->no_entries = rset->no_rset_terms;
 107     si->no_rank_entries = 0;
 108     si->entries = (struct rank_term_info *)
 109         xmalloc (sizeof(*si->entries)*si->no_entries);
 110     for (i = 0; i < si->no_entries; i++)
 111     {
 112         int g = rset->rset_terms[i]->nn;
 113         if (!strncmp (rset->rset_terms[i]->flags, "rank,", 5))
 114         {
 115             yaz_log (LOG_LOG, "%s", rset->rset_terms[i]->flags);
 116             si->entries[i].rank_flag = 1;
 117             si->entries[i].rank_weight = atoi (rset->rset_terms[i]->flags+5);
 118             yaz_log (LOG_LOG, "i=%d weight=%d", i, si->entries[i].rank_weight);
 119             (si->no_rank_entries)++;
 120         }
 121         else
 122             si->entries[i].rank_flag = 0;
 123         si->entries[i].local_occur = 0;
 124         si->entries[i].global_occur = g;
 125         si->entries[i].global_inv = 32 - log2_int (g);
 126         logf (LOG_DEBUG, "-------- %d ------", 32 - log2_int (g));
 127     }
 128     return si;
 129 }
 130
 131 /*
 132  * end: Terminates ranking process. Called after a result set
 133  *  has been ranked.
 134  */
 135 static void end (ZebraHandle zh, void *set_handle)
 136 {
 137     struct rank_set_info *si = (struct rank_set_info *) set_handle;
 138     logf (LOG_DEBUG, "rank-1 end");
 139     xfree (si->entries);
 140     xfree (si);
 141 }
 142
 143 /*
 144  * add: Called for each word occurence in a result set. This routine
 145  *  should be as fast as possible. This routine should "incrementally"
 146  *  update the score.
 147  */
 148 static void add (void *set_handle, int seqno, int term_index)
 149 {
 150     struct rank_set_info *si = (struct rank_set_info *) set_handle;
 151     logf (LOG_DEBUG, "rank-1 add seqno=%d term_index=%d", seqno, term_index);
 152     si->last_pos = seqno;
 153     si->entries[term_index].local_occur++;
 154 }
 155
 156 /*
 157  * calc: Called for each document in a result. This handler should
 158  *  produce a score based on previous call(s) to the add handler. The
 159  *  score should be between 0 and 1000. If score cannot be obtained
 160  *  -1 should be returned.
 161  */
 162 static int calc (void *set_handle, int sysno)
 163 {
 164     int i, lo, divisor, score = 0;
 165     struct rank_set_info *si = (struct rank_set_info *) set_handle;
 166
 167     logf (LOG_DEBUG, "rank-1 calc sysno=%d", sysno);
 168
 169     if (!si->no_rank_entries)
 170         return -1;
 171     for (i = 0; i < si->no_entries; i++)
 172         if (si->entries[i].rank_flag && (lo = si->entries[i].local_occur))
 173             score += (8+log2_int (lo)) * si->entries[i].global_inv *
 174                 si->entries[i].rank_weight;
 175     divisor = si->no_rank_entries * (8+log2_int (si->last_pos/si->no_entries));
 176     score = score / divisor;
 177     yaz_log (LOG_LOG, "score=%d", score);
 178     if (score > 1000)
 179         score = 1000;
 180     for (i = 0; i < si->no_entries; i++)
 181         si->entries[i].local_occur = 0;
 182     return score;
 183 }
 184
 185 /*
 186  * Pseudo-meta code with sequence of calls as they occur in a
 187  * server. Handlers are prefixed by --:
 188  *
 189  *     server init
 190  *     -- create
 191  *     foreach search
 192  *        rank result set
 193  *        -- begin
 194  *        foreach record
 195  *           foreach word
 196  *              -- add
 197  *           -- calc
 198  *        -- end
 199  *     -- destroy
 200  *     server close
 201  */
 202
 203 static struct rank_control rank_control = {
 204     "rank-1",
 205     create,
 206     destroy,
 207     begin,
 208     end,
 209     calc,
 210     add,
 211 };
 212
 213 struct rank_control *rank1_class = &rank_control;