index/zrpn.c

   1 /*
   2  * Copyright (C) 1994-1995, Index Data I/S
   3  * All rights reserved.
   4  * Sebastian Hammer, Adam Dickmeiss
   5  *
   6  * $Log: zrpn.c,v $
   7  * Revision 1.9  1995-09-11 13:09:35  adam
   8  * More work on relevance feedback.
   9  *
  10  * Revision 1.8  1995/09/08  14:52:27  adam
  11  * Minor changes. Dictionary is lower case now.
  12  *
  13  * Revision 1.7  1995/09/07  13:58:36  adam
  14  * New parameter: result-set file descriptor (RSFD) to support multiple
  15  * positions within the same result-set.
  16  * Boolean operators: and, or, not implemented.
  17  * Result-set references.
  18  *
  19  * Revision 1.6  1995/09/06  16:11:18  adam
  20  * Option: only one word key per file.
  21  *
  22  * Revision 1.5  1995/09/06  10:33:04  adam
  23  * More work on present. Some log messages removed.
  24  *
  25  * Revision 1.4  1995/09/05  15:28:40  adam
  26  * More work on search engine.
  27  *
  28  * Revision 1.3  1995/09/04  15:20:22  adam
  29  * Minor changes.
  30  *
  31  * Revision 1.2  1995/09/04  12:33:43  adam
  32  * Various cleanup. YAZ util used instead.
  33  *
  34  * Revision 1.1  1995/09/04  09:10:40  adam
  35  * More work on index add/del/update.
  36  * Merge sort implemented.
  37  * Initial work on z39 server.
  38  *
  39  */
  40 #include <stdio.h>
  41 #include <assert.h>
  42 #include <unistd.h>
  43
  44 #include "zserver.h"
  45
  46 #include <rsisam.h>
  47 #include <rstemp.h>
  48 #include <rsnull.h>
  49 #include <rsbool.h>
  50 #include <rsrel.h>
  51
  52 int split_term (ZServerInfo *zi, Z_Term *term, ISAM_P **isam_ps, int *no)
  53 {
  54     static ISAM_P isam_p[16];
  55     int isam_p_indx = 0;
  56     char termz[IT_MAX_WORD+1];
  57     char term_sub[IT_MAX_WORD+1];
  58     int sizez, i;
  59     char *p0, *p1;
  60     const char *info;
  61
  62     if (term->which != Z_Term_general)
  63         return 0;
  64     sizez = term->u.general->len;
  65     if (sizez > IT_MAX_WORD)
  66         sizez = IT_MAX_WORD;
  67     for (i = 0; i<sizez; i++)
  68         termz[i] = index_char_cvt (term->u.general->buf[i]);
  69     termz[i] = '\0';
  70
  71     p0 = termz;
  72     while (1)
  73     {
  74         if ((p1 = strchr (p0, ' ')))
  75         {
  76             memcpy (term_sub, p0, p1-p0);
  77             term_sub[p1-p0] = '\0';
  78         }
  79         else
  80             strcpy (term_sub, p0);
  81         logf (LOG_DEBUG, "dict_lookup: %s", term_sub);
  82         if ((info = dict_lookup (zi->wordDict, term_sub)))
  83         {
  84             logf (LOG_DEBUG, " found");
  85             assert (*info == sizeof(*isam_p));
  86             memcpy (isam_p + isam_p_indx, info+1, sizeof(*isam_p));
  87             isam_p_indx++;
  88         }
  89         if (!p1)
  90             break;
  91         p0 = p1+1;
  92     }
  93     *isam_ps = isam_p;
  94     *no = isam_p_indx;
  95     logf (LOG_DEBUG, "%d positions", *no);
  96     return 1;
  97 }
  98
  99 static RSET rpn_search_APT_relevance (ZServerInfo *zi,
 100                                       Z_AttributesPlusTerm *zapt)
 101 {
 102     rset_relevance_parms parms;
 103
 104     parms.key_size = sizeof(struct it_key);
 105     parms.max_rec = 100;
 106     parms.cmp = key_compare;
 107     parms.is = zi->wordIsam;
 108     split_term (zi, zapt->term, &parms.isam_positions,
 109                 &parms.no_isam_positions);
 110     if (parms.no_isam_positions > 0)
 111         return rset_create (rset_kind_relevance, &parms);
 112     else
 113         return rset_create (rset_kind_null, NULL);
 114 }
 115
 116 static RSET rpn_search_APT (ZServerInfo *zi, Z_AttributesPlusTerm *zapt)
 117 {
 118 #if 0
 119     Z_Term *term = zapt->term;
 120     char termz[IT_MAX_WORD+1];
 121     size_t sizez;
 122     struct rset_isam_parms parms;
 123     const char *info;
 124     int i;
 125
 126     if (term->which != Z_Term_general)
 127         return NULL;
 128     sizez = term->u.general->len;
 129     if (sizez > IT_MAX_WORD)
 130         sizez = IT_MAX_WORD;
 131     for (i = 0; i<sizez; i++)
 132         termz[i] = index_char_cvt (term->u.general->buf[i]);
 133     termz[i] = '\0';
 134     logf (LOG_DEBUG, "dict_lookup: %s", termz);
 135     if (!(info = dict_lookup (zi->wordDict, termz)))
 136         return rset_create (rset_kind_null, NULL);
 137     assert (*info == sizeof(parms.pos));
 138     memcpy (&parms.pos, info+1, sizeof(parms.pos));
 139     parms.is = zi->wordIsam;
 140     logf (LOG_DEBUG, "rset_create isam");
 141     return rset_create (rset_kind_isam, &parms);
 142 #else
 143     return rpn_search_APT_relevance (zi, zapt);
 144 #endif
 145 }
 146
 147 static RSET rpn_search_ref (ZServerInfo *zi, Z_ResultSetId *resultSetId)
 148 {
 149     ZServerSet *s;
 150
 151     if (!(s = resultSetGet (zi, resultSetId)))
 152         return rset_create (rset_kind_null, NULL);
 153     return s->rset;
 154 }
 155
 156 static RSET rpn_search_structure (ZServerInfo *zi, Z_RPNStructure *zs)
 157 {
 158     RSET r = NULL;
 159     if (zs->which == Z_RPNStructure_complex)
 160     {
 161         rset_bool_parms bool_parms;
 162
 163         bool_parms.rset_l = rpn_search_structure (zi, zs->u.complex->s1);
 164         bool_parms.rset_r = rpn_search_structure (zi, zs->u.complex->s2);
 165         bool_parms.key_size = sizeof(struct it_key);
 166         bool_parms.cmp = key_compare;
 167
 168         switch (zs->u.complex->operator->which)
 169         {
 170         case Z_Operator_and:
 171             r = rset_create (rset_kind_and, &bool_parms);
 172             break;
 173         case Z_Operator_or:
 174             r = rset_create (rset_kind_or, &bool_parms);
 175             break;
 176         case Z_Operator_and_not:
 177             r = rset_create (rset_kind_not, &bool_parms);
 178             break;
 179         default:
 180             assert (0);
 181         }
 182     }
 183     else if (zs->which == Z_RPNStructure_simple)
 184     {
 185         if (zs->u.simple->which == Z_Operand_APT)
 186         {
 187             logf (LOG_DEBUG, "rpn_search_APT");
 188             r = rpn_search_APT (zi, zs->u.simple->u.attributesPlusTerm);
 189         }
 190         else if (zs->u.simple->which == Z_Operand_resultSetId)
 191         {
 192             logf (LOG_DEBUG, "rpn_search_ref");
 193             r = rpn_search_ref (zi, zs->u.simple->u.resultSetId);
 194         }
 195         else
 196         {
 197             assert (0);
 198         }
 199     }
 200     else
 201     {
 202         assert (0);
 203     }
 204     return r;
 205 }
 206
 207 static RSET rpn_save_set (RSET r, int *count)
 208 {
 209 #if 0
 210     RSET d;
 211     rset_temp_parms parms;
 212 #endif
 213     int psysno = 0;
 214     struct it_key key;
 215     RSFD rfd;
 216
 217     logf (LOG_DEBUG, "rpn_save_set");
 218     *count = 0;
 219 #if 0
 220     parms.key_size = sizeof(struct it_key);
 221     d = rset_create (rset_kind_temp, &parms);
 222     rset_open (d, 1);
 223 #endif
 224
 225     rfd = rset_open (r, 0);
 226     while (rset_read (r, rfd, &key))
 227     {
 228         if (key.sysno != psysno)
 229         {
 230             psysno = key.sysno;
 231             (*count)++;
 232         }
 233 #if 0
 234         rset_write (d, &key);
 235 #endif
 236     }
 237     rset_close (r, rfd);
 238 #if 0
 239     rset_close (d);
 240 #endif
 241     logf (LOG_DEBUG, "%d distinct sysnos", *count);
 242 #if 0
 243     return d;
 244 #endif
 245 }
 246
 247 int rpn_search (ZServerInfo *zi,
 248                 Z_RPNQuery *rpn, int num_bases, char **basenames,
 249                 const char *setname, int *hits)
 250 {
 251     RSET rset, result_rset;
 252
 253     rset = rpn_search_structure (zi, rpn->RPNStructure);
 254     if (!rset)
 255         return 0;
 256     result_rset = rpn_save_set (rset, hits);
 257 #if 0
 258     rset_delete (result_rset);
 259 #endif
 260
 261     resultSetAdd (zi, setname, 1, rset);
 262     return 0;
 263 }
 264