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