index/zrpn.c

   1 /*
   2  * Copyright (C) 1995, Index Data I/S
   3  * All rights reserved.
   4  * Sebastian Hammer, Adam Dickmeiss
   5  *
   6  * $Log: zrpn.c,v $
   7  * Revision 1.5  1995-09-06 10:33:04  adam
   8  * More work on present. Some log messages removed.
   9  *
  10  * Revision 1.4  1995/09/05  15:28:40  adam
  11  * More work on search engine.
  12  *
  13  * Revision 1.3  1995/09/04  15:20:22  adam
  14  * Minor changes.
  15  *
  16  * Revision 1.2  1995/09/04  12:33:43  adam
  17  * Various cleanup. YAZ util used instead.
  18  *
  19  * Revision 1.1  1995/09/04  09:10:40  adam
  20  * More work on index add/del/update.
  21  * Merge sort implemented.
  22  * Initial work on z39 server.
  23  *
  24  */
  25 #include <stdio.h>
  26 #include <assert.h>
  27 #include <unistd.h>
  28
  29 #include "zserver.h"
  30
  31 #include <rsisam.h>
  32 #include <rstemp.h>
  33 #include <rsnull.h>
  34
  35 static RSET rpn_search_APT (ZServerInfo *zi, Z_AttributesPlusTerm *zapt)
  36 {
  37     char termz[256];
  38     size_t sizez;
  39     struct rset_isam_parms parms;
  40     const char *info;
  41     Z_Term *term = zapt->term;
  42
  43     if (term->which != Z_Term_general)
  44         return NULL;
  45     sizez = term->u.general->len;
  46     if (sizez > 255)
  47         sizez = 255;
  48     memcpy (termz, term->u.general->buf, sizez);
  49     termz[sizez] = '\0';
  50     logf (LOG_DEBUG, "dict_lookup: %s", termz);
  51     if (!(info = dict_lookup (zi->wordDict, termz)))
  52         return rset_create (rset_kind_null, NULL);
  53     assert (*info == sizeof(parms.pos));
  54     memcpy (&parms.pos, info+1, sizeof(parms.pos));
  55     parms.is = zi->wordIsam;
  56     logf (LOG_DEBUG, "rset_create isam");
  57     return rset_create (rset_kind_isam, &parms);
  58 }
  59
  60 static RSET rpn_search_and (ZServerInfo *zi, RSET r_l, RSET r_r)
  61 {
  62     struct it_key k1, k2;
  63     RSET r_dst;
  64     int i1, i2;
  65     rset_open (r_l, 0);
  66     rset_open (r_r, 0);
  67     r_dst = rset_create (rset_kind_temp, NULL);
  68     rset_open (r_dst, 1);
  69
  70     i1 = rset_read (r_l, &k1);
  71     i2 = rset_read (r_r, &k2);
  72     while (i1 && i2)
  73     {
  74         if (k1.sysno > k2.sysno)
  75             i2 = rset_read (r_r, &k2);
  76         else if (k1.sysno < k2.sysno)
  77             i1 = rset_read (r_l, &k1);
  78         else if (!(i1 = key_compare_x (&k1, &k2)))
  79         {
  80             rset_write (r_dst, &k1);
  81             i1 = rset_read (r_l, &k1);
  82             i2 = rset_read (r_r, &k2);
  83         }
  84         else if (i1 > 0)
  85         {
  86             rset_write (r_dst, &k2);
  87             i2 = rset_read (r_r, &k2);
  88         }
  89         else
  90         {
  91             rset_write (r_dst, &k1);
  92             i1 = rset_read (r_l, &k1);
  93         }
  94     }
  95     rset_close (r_dst);
  96     return r_dst;
  97 }
  98
  99 static RSET rpn_search_or (ZServerInfo *zi, RSET r_l, RSET r_r)
 100 {
 101     return r_l;
 102 }
 103
 104 static RSET rpn_search_not (ZServerInfo *zi, RSET r_l, RSET r_r)
 105 {
 106     return r_l;
 107 }
 108
 109 static RSET rpn_search_ref (ZServerInfo *zi, Z_ResultSetId *resultSetId)
 110 {
 111     return NULL;
 112 }
 113
 114 static RSET rpn_search_structure (ZServerInfo *zi, Z_RPNStructure *zs)
 115 {
 116     RSET r;
 117     if (zs->which == Z_RPNStructure_complex)
 118     {
 119         RSET r_l, r_r;
 120
 121         r_l = rpn_search_structure (zi, zs->u.complex->s1);
 122         r_r = rpn_search_structure (zi, zs->u.complex->s2);
 123
 124         switch (zs->u.complex->operator->which)
 125         {
 126         case Z_Operator_and:
 127             rset_delete (r_r);
 128             break;
 129         case Z_Operator_or:
 130             rset_delete (r_r);
 131             break;
 132         case Z_Operator_and_not:
 133             rset_delete (r_r);
 134             break;
 135         default:
 136             assert (0);
 137         }
 138         r = r_l;
 139     }
 140     else if (zs->which == Z_RPNStructure_simple)
 141     {
 142         if (zs->u.simple->which == Z_Operand_APT)
 143         {
 144             logf (LOG_DEBUG, "rpn_search_APT");
 145             r = rpn_search_APT (zi, zs->u.simple->u.attributesPlusTerm);
 146         }
 147         else if (zs->u.simple->which == Z_Operand_resultSetId)
 148         {
 149             logf (LOG_DEBUG, "rpn_search_ref");
 150             r = rpn_search_ref (zi, zs->u.simple->u.resultSetId);
 151         }
 152         else
 153         {
 154             assert (0);
 155         }
 156     }
 157     else
 158     {
 159         assert (0);
 160     }
 161     return r;
 162 }
 163
 164 static RSET rpn_save_set (RSET r, int *count)
 165 {
 166 #if 0
 167     RSET d;
 168     rset_temp_parms parms;
 169 #endif
 170     int psysno = 0;
 171     struct it_key key;
 172
 173     logf (LOG_DEBUG, "rpn_save_set");
 174     *count = 0;
 175 #if 0
 176     parms.key_size = sizeof(struct it_key);
 177     d = rset_create (rset_kind_temp, &parms);
 178     rset_open (d, 1);
 179 #endif
 180
 181     rset_open (r, 0);
 182     while (rset_read (r, &key))
 183     {
 184         if (key.sysno != psysno)
 185         {
 186             psysno = key.sysno;
 187             (*count)++;
 188         }
 189 #if 0
 190         rset_write (d, &key);
 191 #endif
 192     }
 193     rset_close (r);
 194 #if 0
 195     rset_close (d);
 196 #endif
 197     logf (LOG_DEBUG, "%d distinct sysnos", *count);
 198 #if 0
 199     return d;
 200 #endif
 201 }
 202
 203 int rpn_search (ZServerInfo *zi,
 204                 Z_RPNQuery *rpn, int num_bases, char **basenames,
 205                 const char *setname, int *hits)
 206 {
 207     RSET rset, result_rset;
 208
 209     rset = rpn_search_structure (zi, rpn->RPNStructure);
 210     if (!rset)
 211         return 0;
 212     result_rset = rpn_save_set (rset, hits);
 213 #if 0
 214     rset_delete (result_rset);
 215 #endif
 216
 217     resultSetAdd (zi, setname, 1, rset);
 218     return 0;
 219 }
 220