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