index/zsets.c

   1 /*
   2  * Copyright (C) 1994-1995, Index Data I/S
   3  * All rights reserved.
   4  * Sebastian Hammer, Adam Dickmeiss
   5  *
   6  * $Log: zsets.c,v $
   7  * Revision 1.6  1995-09-28 09:19:49  adam
   8  * xfree/xmalloc used everywhere.
   9  * Extract/retrieve method seems to work for text records.
  10  *
  11  * Revision 1.5  1995/09/27  16:17:32  adam
  12  * More work on retrieve.
  13  *
  14  * Revision 1.4  1995/09/07  13:58:36  adam
  15  * New parameter: result-set file descriptor (RSFD) to support multiple
  16  * positions within the same result-set.
  17  * Boolean operators: and, or, not implemented.
  18  * Result-set references.
  19  *
  20  * Revision 1.3  1995/09/06  16:11:19  adam
  21  * Option: only one word key per file.
  22  *
  23  * Revision 1.2  1995/09/06  10:33:04  adam
  24  * More work on present. Some log messages removed.
  25  *
  26  * Revision 1.1  1995/09/05  15:28:40  adam
  27  * More work on search engine.
  28  *
  29  */
  30 #include <stdio.h>
  31 #include <assert.h>
  32 #include <unistd.h>
  33
  34 #include "zserver.h"
  35 #include <rstemp.h>
  36
  37 ZServerSet *resultSetAdd (ZServerInfo *zi, const char *name, int ov, RSET rset)
  38 {
  39     ZServerSet *s;
  40
  41     for (s = zi->sets; s; s = s->next)
  42         if (!strcmp (s->name, name))
  43         {
  44             if (!ov)
  45                 return NULL;
  46             rset_delete (s->rset);
  47             s->rset = rset;
  48             return s;
  49         }
  50     s = xmalloc (sizeof(*s));
  51     s->next = zi->sets;
  52     zi->sets = s;
  53     s->name = xmalloc (strlen(name)+1);
  54     strcpy (s->name, name);
  55     s->rset = rset;
  56     return s;
  57 }
  58
  59 ZServerSet *resultSetGet (ZServerInfo *zi, const char *name)
  60 {
  61     ZServerSet *s;
  62
  63     for (s = zi->sets; s; s = s->next)
  64         if (!strcmp (s->name, name))
  65             return s;
  66     return NULL;
  67 }
  68
  69 ZServerSetSysno *resultSetSysnoGet  (ZServerInfo *zi, const char *name,
  70                                      int num, int *positions)
  71 {
  72     ZServerSet *sset;
  73     ZServerSetSysno *sr;
  74     RSET rset;
  75     int num_i = 0;
  76     int position = 0;
  77     int psysno = 0;
  78     struct it_key key;
  79     RSFD rfd;
  80
  81     if (!(sset = resultSetGet (zi, name)))
  82         return NULL;
  83     if (!(rset = sset->rset))
  84         return NULL;
  85     logf (LOG_DEBUG, "resultSetRecordGet");
  86     sr = xmalloc (sizeof(*sr) * num);
  87     rfd = rset_open (rset, 0);
  88     while (rset_read (rset, rfd, &key))
  89     {
  90         if (key.sysno != psysno)
  91         {
  92             psysno = key.sysno;
  93             position++;
  94             if (position == positions[num_i])
  95             {
  96                 sr[num_i].sysno = psysno;
  97                 num_i++;
  98                 if (++num_i == num)
  99                     break;
 100             }
 101         }
 102     }
 103     rset_close (rset, rfd);
 104     while (num_i < num)
 105     {
 106         sr[num_i].sysno = 0;
 107         num_i++;
 108     }
 109     return sr;
 110 }
 111
 112 void resultSetRecordDel (ZServerInfo *zi, ZServerRecord *records, int num)
 113 {
 114     int i;
 115
 116     for (i = 0; i<num; i++)
 117         xfree (records[i].buf);
 118     xfree (records);
 119 }
 120
 121
 122 #if 0
 123 ZServerSetSysno *resultSetSysno  (ZServerInfo *zi, const char *name,
 124                                   int num, int *positions)
 125 {
 126     ZServerSet *sset;
 127     ZServerRecord *sr;
 128     RSET rset;
 129     int num_i = 0;
 130     int position = 0;
 131     int psysno = 0;
 132     struct it_key key;
 133     RSFD rfd;
 134
 135     if (!(sset = resultSetGet (zi, name)))
 136         return NULL;
 137     if (!(rset = sset->rset))
 138         return NULL;
 139     logf (LOG_DEBUG, "resultSetRecordGet");
 140     sr = xmalloc (sizeof(*sr) * num);
 141     rfd = rset_open (rset, 0);
 142     while (rset_read (rset, rfd, &key))
 143     {
 144         if (key.sysno != psysno)
 145         {
 146             psysno = key.sysno;
 147             position++;
 148             if (position == positions[num_i])
 149             {
 150                 FILE *inf;
 151                 char fname[SYS_IDX_ENTRY_LEN];
 152
 153                 sr[num_i].buf = NULL;
 154                 if (lseek (zi->sys_idx_fd, psysno * SYS_IDX_ENTRY_LEN,
 155                            SEEK_SET) == -1)
 156                 {
 157                     logf (LOG_FATAL|LOG_ERRNO, "lseek of sys_idx");
 158                     exit (1);
 159                 }
 160                 if (read (zi->sys_idx_fd, fname, SYS_IDX_ENTRY_LEN) == -1)
 161                 {
 162                     logf (LOG_FATAL|LOG_ERRNO, "read of sys_idx");
 163                     exit (1);
 164                 }
 165                 if (!(inf = fopen (fname, "r")))
 166                     logf (LOG_WARN, "fopen: %s", fname);
 167                 else
 168                 {
 169                     long size;
 170
 171                     fseek (inf, 0L, SEEK_END);
 172                     size = ftell (inf);
 173                     fseek (inf, 0L, SEEK_SET);
 174                     logf (LOG_DEBUG, "get sysno=%d, fname=%s, size=%ld",
 175                           psysno, fname, (long) size);
 176                     sr[num_i].buf = xmalloc (size+1);
 177                     sr[num_i].size = size;
 178                     sr[num_i].buf[size] = '\0';
 179                     if (fread (sr[num_i].buf, size, 1, inf) != 1)
 180                     {
 181                         logf (LOG_FATAL|LOG_ERRNO, "fread %s", fname);
 182                         exit (1);
 183                     }
 184                     fclose (inf);
 185                 }
 186                 num_i++;
 187                 if (num_i == num)
 188                     break;
 189             }
 190         }
 191     }
 192     rset_close (rset, rfd);
 193     while (num_i < num)
 194     {
 195         sr[num_i].buf = NULL;
 196         sr[num_i].size = 0;
 197         num_i++;
 198     }
 199     return sr;
 200 }
 201 #endif