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