index/extract.c

   1 /*
   2  * Copyright (C) 1994-1995, Index Data I/S
   3  * All rights reserved.
   4  * Sebastian Hammer, Adam Dickmeiss
   5  *
   6  * $Log: extract.c,v $
   7  * Revision 1.21  1995-10-10 12:24:38  adam
   8  * Temporary sort files are compressed.
   9  *
  10  * Revision 1.20  1995/10/06  13:52:05  adam
  11  * Bug fixes. Handler may abort further scanning.
  12  *
  13  * Revision 1.19  1995/10/04  12:55:16  adam
  14  * Bug fix in ranked search. Use=Any keys inserted.
  15  *
  16  * Revision 1.18  1995/10/04  09:37:08  quinn
  17  * Fixed bug.
  18  *
  19  * Revision 1.17  1995/10/03  14:28:57  adam
  20  * Buffered read in extract works.
  21  *
  22  * Revision 1.16  1995/10/03  14:28:45  adam
  23  * Work on more effecient read handler in extract.
  24  *
  25  * Revision 1.15  1995/10/02  15:42:53  adam
  26  * Extract uses file descriptors instead of FILE pointers.
  27  *
  28  * Revision 1.14  1995/10/02  15:29:13  adam
  29  * More logging in file_extract.
  30  *
  31  * Revision 1.13  1995/09/29  14:01:39  adam
  32  * Bug fixes.
  33  *
  34  * Revision 1.12  1995/09/28  14:22:56  adam
  35  * Sort uses smaller temporary files.
  36  *
  37  * Revision 1.11  1995/09/28  12:10:31  adam
  38  * Bug fixes. Field prefix used in queries.
  39  *
  40  * Revision 1.10  1995/09/28  09:19:41  adam
  41  * xfree/xmalloc used everywhere.
  42  * Extract/retrieve method seems to work for text records.
  43  *
  44  * Revision 1.9  1995/09/27  12:22:28  adam
  45  * More work on extract in record control.
  46  * Field name is not in isam keys but in prefix in dictionary words.
  47  *
  48  * Revision 1.8  1995/09/14  07:48:22  adam
  49  * Record control management.
  50  *
  51  * Revision 1.7  1995/09/11  13:09:32  adam
  52  * More work on relevance feedback.
  53  *
  54  * Revision 1.6  1995/09/08  14:52:27  adam
  55  * Minor changes. Dictionary is lower case now.
  56  *
  57  * Revision 1.5  1995/09/06  16:11:16  adam
  58  * Option: only one word key per file.
  59  *
  60  * Revision 1.4  1995/09/05  15:28:39  adam
  61  * More work on search engine.
  62  *
  63  * Revision 1.3  1995/09/04  12:33:41  adam
  64  * Various cleanup. YAZ util used instead.
  65  *
  66  * Revision 1.2  1995/09/04  09:10:34  adam
  67  * More work on index add/del/update.
  68  * Merge sort implemented.
  69  * Initial work on z39 server.
  70  *
  71  * Revision 1.1  1995/09/01  14:06:35  adam
  72  * Split of work into more files.
  73  *
  74  */
  75 #include <stdio.h>
  76 #include <assert.h>
  77 #include <unistd.h>
  78 #include <fcntl.h>
  79 #include <ctype.h>
  80
  81 #include <alexutil.h>
  82 #include <recctrl.h>
  83 #include "index.h"
  84
  85 static Dict file_idx;
  86 static SYSNO sysno_next;
  87 static int sys_idx_fd = -1;
  88
  89 static int key_cmd;
  90 static int key_sysno;
  91 static char **key_buf;
  92 static size_t ptr_top;
  93 static size_t ptr_i;
  94 static size_t kused;
  95 static int key_file_no;
  96
  97 void key_open (int mem)
  98 {
  99     void *file_key;
 100
 101     if (mem < 50000)
 102         mem = 50000;
 103     key_buf = xmalloc (mem);
 104     ptr_top = mem/sizeof(char*);
 105     ptr_i = 0;
 106     kused = 0;
 107     key_file_no = 0;
 108
 109     if (!(file_idx = dict_open (FNAME_FILE_DICT, 40, 1)))
 110     {
 111         logf (LOG_FATAL, "dict_open fail of %s", "fileidx");
 112         exit (1);
 113     }
 114     file_key = dict_lookup (file_idx, ".");
 115     if (file_key)
 116         memcpy (&sysno_next, (char*)file_key+1, sizeof(sysno_next));
 117     else
 118         sysno_next = 1;
 119     if ((sys_idx_fd = open (FNAME_SYS_IDX, O_RDWR|O_CREAT, 0666)) == -1)
 120     {
 121         logf (LOG_FATAL|LOG_ERRNO, "open %s", FNAME_SYS_IDX);
 122         exit (1);
 123     }
 124 }
 125
 126 struct encode_info {
 127     int  sysno;
 128     int  seqno;
 129     char buf[512];
 130 };
 131
 132 void encode_key_init (struct encode_info *i)
 133 {
 134     i->sysno = 0;
 135     i->seqno = 0;
 136 }
 137
 138 char *encode_key_int (int d, char *bp)
 139 {
 140     if (d <= 63)
 141         *bp++ = d;
 142     else if (d <= 16383)
 143     {
 144         *bp++ = 64 + (d>>8);
 145         *bp++ = d  & 255;
 146     }
 147     else if (d <= 4194303)
 148     {
 149         *bp++ = 128 + (d>>16);
 150         *bp++ = (d>>8) & 255;
 151         *bp++ = d & 255;
 152     }
 153     else
 154     {
 155         *bp++ = 192 + (d>>24);
 156         *bp++ = (d>>16) & 255;
 157         *bp++ = (d>>8) & 255;
 158         *bp++ = d & 255;
 159     }
 160     return bp;
 161 }
 162
 163 void encode_key_write (char *k, struct encode_info *i, FILE *outf)
 164 {
 165     struct it_key key;
 166     char *bp = i->buf;
 167
 168     while ((*bp++ = *k++))
 169         ;
 170     memcpy (&key, k+1, sizeof(struct it_key));
 171     bp = encode_key_int ( (key.sysno - i->sysno) * 2 + *k, bp);
 172     if (i->sysno != key.sysno)
 173     {
 174         i->sysno = key.sysno;
 175         i->seqno = 0;
 176     }
 177     bp = encode_key_int (key.seqno - i->seqno, bp);
 178     i->seqno = key.seqno;
 179     if (fwrite (i->buf, bp - i->buf, 1, outf) != 1)
 180     {
 181         logf (LOG_FATAL|LOG_ERRNO, "fwrite");
 182         exit (1);
 183     }
 184 }
 185
 186 void key_flush (void)
 187 {
 188     FILE *outf;
 189     char out_fname[200];
 190     char *prevcp, *cp;
 191     struct encode_info encode_info;
 192
 193     if (ptr_i <= 0)
 194         return;
 195
 196     key_file_no++;
 197     logf (LOG_LOG, "sorting section %d", key_file_no);
 198     qsort (key_buf + ptr_top-ptr_i, ptr_i, sizeof(char*), key_qsort_compare);
 199     sprintf (out_fname, TEMP_FNAME, key_file_no);
 200
 201     if (!(outf = fopen (out_fname, "w")))
 202     {
 203         logf (LOG_FATAL|LOG_ERRNO, "fopen (4) %s", out_fname);
 204         exit (1);
 205     }
 206     logf (LOG_LOG, "writing section %d", key_file_no);
 207     prevcp = cp = key_buf[ptr_top-ptr_i];
 208
 209     encode_key_init (&encode_info);
 210     encode_key_write (cp, &encode_info, outf);
 211     while (--ptr_i > 0)
 212     {
 213         cp = key_buf[ptr_top-ptr_i];
 214         if (strcmp (cp, prevcp))
 215         {
 216             encode_key_init (&encode_info);
 217             encode_key_write (cp, &encode_info, outf);
 218             prevcp = cp;
 219         }
 220         else
 221             encode_key_write (cp + strlen(cp), &encode_info, outf);
 222     }
 223     if (fclose (outf))
 224     {
 225         logf (LOG_FATAL|LOG_ERRNO, "fclose %s", out_fname);
 226         exit (1);
 227     }
 228     logf (LOG_LOG, "finished section %d", key_file_no);
 229     ptr_i = 0;
 230     kused = 0;
 231 }
 232
 233 int key_close (void)
 234 {
 235     key_flush ();
 236     xfree (key_buf);
 237     close (sys_idx_fd);
 238     dict_insert (file_idx, ".", sizeof(sysno_next), &sysno_next);
 239     dict_close (file_idx);
 240     return key_file_no;
 241 }
 242
 243 static void wordInit (RecWord *p)
 244 {
 245     p->attrSet = 1;
 246     p->attrUse = 1016;
 247     p->which = Word_String;
 248 }
 249
 250 static void wordAdd (const RecWord *p)
 251 {
 252     struct it_key key;
 253     size_t i;
 254
 255     if (kused + 1024 > (ptr_top-ptr_i)*sizeof(char*))
 256         key_flush ();
 257     ++ptr_i;
 258     key_buf[ptr_top-ptr_i] = (char*)key_buf + kused;
 259     kused += index_word_prefix ((char*)key_buf + kused,
 260                                 p->attrSet, p->attrUse);
 261     switch (p->which)
 262     {
 263     case Word_String:
 264         for (i = 0; p->u.string[i]; i++)
 265             ((char*)key_buf) [kused++] = index_char_cvt (p->u.string[i]);
 266         ((char*)key_buf) [kused++] = '\0';
 267         break;
 268     default:
 269         return ;
 270     }
 271     ((char*) key_buf)[kused++] = ((key_cmd == 'a') ? 1 : 0);
 272     key.sysno = key_sysno;
 273     key.seqno = p->seqno;
 274     memcpy ((char*)key_buf + kused, &key, sizeof(key));
 275     kused += sizeof(key);
 276 }
 277
 278 static void wordAddAny (const RecWord *p)
 279 {
 280     if (p->attrSet != 1 || p->attrUse != 1016)
 281     {
 282         RecWord w;
 283
 284         memcpy (&w, p, sizeof(w));
 285         w.attrSet = 1;
 286         w.attrUse = 1016;
 287         wordAdd (&w);
 288     }
 289     wordAdd (p);
 290 }
 291
 292
 293 #define FILE_READ_BUF 1
 294 #if FILE_READ_BUF
 295 static char *file_buf;
 296 static int file_offset;
 297 static int file_bufsize;
 298
 299 static void file_read_start (int fd)
 300 {
 301     file_offset = 0;
 302     file_buf = xmalloc (4096);
 303     file_bufsize = read (fd, file_buf, 4096);
 304 }
 305
 306 static void file_read_stop (int fd)
 307 {
 308     xfree (file_buf);
 309 }
 310
 311 static int file_read (int fd, char *buf, size_t count)
 312 {
 313     int l = file_bufsize - file_offset;
 314
 315     if (count > l)
 316     {
 317         int r;
 318         if (l > 0)
 319             memcpy (buf, file_buf + file_offset, l);
 320         count = count-l;
 321         if (count > file_bufsize)
 322         {
 323             if ((r = read (fd, buf + l, count)) == -1)
 324             {
 325                 logf (LOG_FATAL|LOG_ERRNO, "read");
 326                 exit (1);
 327             }
 328             file_bufsize = 0;
 329             file_offset = 0;
 330             return r;
 331         }
 332         file_bufsize = r = read (fd, file_buf, 4096);
 333         if (r == -1)
 334         {
 335             logf (LOG_FATAL|LOG_ERRNO, "read");
 336             exit (1);
 337         }
 338         else if (r <= count)
 339         {
 340             file_offset = r;
 341             memcpy (buf + l, file_buf, r);
 342             return l + r;
 343         }
 344         else
 345         {
 346             file_offset = count;
 347             memcpy (buf + l, file_buf, count - l);
 348             return count;
 349         }
 350     }
 351     memcpy (buf, file_buf + file_offset, count);
 352     file_offset += count;
 353     return count;
 354 }
 355 #else
 356 static int file_read (int fd, char *buf, size_t count)
 357 {
 358     return read (fd, buf, count);
 359 }
 360 #endif
 361 void file_extract (int cmd, const char *fname, const char *kname)
 362 {
 363     int i, r;
 364     char ext[128];
 365     SYSNO sysno;
 366     char ext_res[128];
 367     const char *file_type;
 368     void *file_info;
 369     struct recExtractCtrl extractCtrl;
 370     RecType rt;
 371
 372     for (i = strlen(fname); --i >= 0; )
 373         if (fname[i] == '/')
 374         {
 375             strcpy (ext, "");
 376             break;
 377         }
 378         else if (fname[i] == '.')
 379         {
 380             strcpy (ext, fname+i+1);
 381             break;
 382         }
 383     sprintf (ext_res, "fileExtension.%s", ext);
 384     if (!(file_type = res_get (common_resource, ext_res)))
 385         return;
 386     if (!(rt = recType_byName (file_type)))
 387         return;
 388     logf (LOG_DEBUG, "%c %s k=%s", cmd, fname, kname);
 389     file_info = dict_lookup (file_idx, kname);
 390     if (!file_info)
 391     {
 392         sysno = sysno_next++;
 393         dict_insert (file_idx, kname, sizeof(sysno), &sysno);
 394         lseek (sys_idx_fd, sysno * SYS_IDX_ENTRY_LEN, SEEK_SET);
 395         write (sys_idx_fd, file_type, strlen (file_type)+1);
 396         write (sys_idx_fd, kname, strlen(kname)+1);
 397     }
 398     else
 399         memcpy (&sysno, (char*) file_info+1, sizeof(sysno));
 400
 401     if ((extractCtrl.fd = open (fname, O_RDONLY)) == -1)
 402     {
 403         logf (LOG_WARN|LOG_ERRNO, "open %s", fname);
 404         return;
 405     }
 406     extractCtrl.subType = "";
 407     extractCtrl.init = wordInit;
 408     extractCtrl.add = wordAddAny;
 409 #if FILE_READ_BUF
 410     file_read_start (extractCtrl.fd);
 411 #endif
 412     extractCtrl.readf = file_read;
 413     key_sysno = sysno;
 414     key_cmd = cmd;
 415     r = (*rt->extract)(&extractCtrl);
 416 #if FILE_READ_BUF
 417     file_read_stop (extractCtrl.fd);
 418 #endif
 419     close (extractCtrl.fd);
 420     if (r)
 421         logf (LOG_WARN, "Couldn't extract file %s, code %d", fname, r);
 422 }