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