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.2  1995-09-04 12:33:43  adam
   8  * Various cleanup. YAZ util used instead.
   9  *
  10  * Revision 1.1  1995/09/04  09:10:40  adam
  11  * More work on index add/del/update.
  12  * Merge sort implemented.
  13  * Initial work on z39 server.
  14  *
  15  */
  16 #include <stdio.h>
  17 #include <assert.h>
  18 #include <unistd.h>
  19
  20 #include <alexutil.h>
  21 #include <dict.h>
  22 #include <isam.h>
  23 #include <rsisam.h>
  24 #include <rstemp.h>
  25
  26 #include <proto.h>
  27
  28 #include "index.h"
  29
  30 static Dict dict;
  31 static ISAM isam;
  32
  33 static RSET rpn_search_APT (Z_AttributesPlusTerm *zapt)
  34 {
  35     struct rset_isam_parms parms;
  36     const char *info;
  37     Z_Term *term = zapt->term;
  38
  39     if (term->which != Z_Term_general)
  40         return NULL;
  41     if (!(info = dict_lookup (dict, term->u.general->buf)))
  42         return NULL;
  43     assert (*info == sizeof(parms.pos));
  44     memcpy (&parms.pos, info+1, sizeof(parms.pos));
  45     parms.is = isam;
  46     return rset_create (rset_kind_isam, &parms);
  47 }
  48
  49 static RSET rpn_search_and (RSET r_l, RSET r_r)
  50 {
  51     struct it_key k1, k2;
  52     RSET r_dst;
  53     int i1, i2;
  54     rset_open (r_l, 0);
  55     rset_open (r_r, 0);
  56     r_dst = rset_create (rset_kind_temp, NULL);
  57     rset_open (r_dst, 1);
  58
  59     i1 = rset_read (r_l, &k1);
  60     i2 = rset_read (r_r, &k2);
  61     while (i1 && i2)
  62     {
  63         if (k1.sysno > k2.sysno)
  64             i2 = rset_read (r_r, &k2);
  65         else if (k1.sysno < k2.sysno)
  66             i1 = rset_read (r_l, &k1);
  67         else if (!(i1 = key_compare_x (&k1, &k2)))
  68         {
  69             rset_write (r_dst, &k1);
  70             i1 = rset_read (r_l, &k1);
  71             i2 = rset_read (r_r, &k2);
  72         }
  73         else if (i1 > 0)
  74         {
  75             rset_write (r_dst, &k2);
  76             i2 = rset_read (r_r, &k2);
  77         }
  78         else
  79         {
  80             rset_write (r_dst, &k1);
  81             i1 = rset_read (r_l, &k1);
  82         }
  83     }
  84     rset_close (r_dst);
  85     return r_dst;
  86 }
  87
  88 static RSET rpn_search_or (RSET r_l, RSET r_r)
  89 {
  90     return r_l;
  91 }
  92
  93 static RSET rpn_search_not (RSET r_l, RSET r_r)
  94 {
  95     return r_l;
  96 }
  97
  98 static RSET rpn_search_ref (Z_ResultSetId *resultSetId)
  99 {
 100     return NULL;
 101 }
 102
 103 static RSET rpn_search_structure (Z_RPNStructure *zs)
 104 {
 105     RSET r;
 106     if (zs->which == Z_RPNStructure_complex)
 107     {
 108         RSET r_l, r_r;
 109
 110         r_l = rpn_search_structure (zs->u.complex->s1);
 111         r_r = rpn_search_structure (zs->u.complex->s2);
 112
 113         switch (zs->u.complex->operator->which)
 114         {
 115         case Z_Operator_and:
 116             r = rpn_search_and (r_l, r_r);
 117             break;
 118         case Z_Operator_or:
 119             r = rpn_search_or (r_l, r_r);
 120             break;
 121         case Z_Operator_and_not:
 122             r = rpn_search_not (r_l, r_r);
 123             break;
 124         default:
 125             assert (0);
 126         }
 127         rset_delete (r_l);
 128         rset_delete (r_r);
 129     }
 130     else if (zs->which == Z_RPNStructure_simple)
 131     {
 132         if (zs->u.simple->which == Z_Operand_APT)
 133             r = rpn_search_APT (zs->u.simple->u.attributesPlusTerm);
 134         else if (zs->u.simple->which == Z_Operand_resultSetId)
 135             r = rpn_search_ref (zs->u.simple->u.resultSetId);
 136         else
 137         {
 138             assert (0);
 139         }
 140     }
 141     else
 142     {
 143         assert (0);
 144     }
 145     return r;
 146 }