X-Git-Url: http://git.indexdata.com/?a=blobdiff_plain;f=index%2Frecindex.c;h=8f3005c9ebc83c75c61e990df8af14e098d6ed06;hb=bceca936710690858ea162e7bc22de819f0e280f;hp=09cc7084f06e94026c6be1803c79d19f4d0d4754;hpb=4e2fc80e64f3d7895a871ea5b08aa80045a59f2c;p=idzebra-moved-to-github.git

diff --git a/index/recindex.c b/index/recindex.c
index 09cc708..8f3005c 100644
--- a/index/recindex.c
+++ b/index/recindex.c
@@ -1,10 +1,51 @@
 /*
- * Copyright (C) 1994-1995, Index Data I/S 
+ * Copyright (C) 1994-1999, Index Data
  * All rights reserved.
  * Sebastian Hammer, Adam Dickmeiss
  *
  * $Log: recindex.c,v $
- * Revision 1.12  1995-12-07 17:38:47  adam
+ * Revision 1.22  1999-02-18 12:49:34  adam
+ * Changed file naming scheme for register files as well as record
+ * store/index files.
+ *
+ * Revision 1.21  1999/02/02 14:51:03  adam
+ * Updated WIN32 code specific sections. Changed header.
+ *
+ * Revision 1.20  1998/01/12 15:04:08  adam
+ * The test option (-s) only uses read-lock (and not write lock).
+ *
+ * Revision 1.19  1997/09/17 12:19:16  adam
+ * Zebra version corresponds to YAZ version 1.4.
+ * Changed Zebra server so that it doesn't depend on global common_resource.
+ *
+ * Revision 1.18  1997/07/15 16:28:42  adam
+ * Bug fix: storeData didn't work with files with multiple records.
+ * Bug fix: fixed memory management with records; not really well
+ *  thought through.
+ *
+ * Revision 1.17  1997/02/12 20:39:46  adam
+ * Implemented options -f <n> that limits the log to the first <n>
+ * records.
+ * Changed some log messages also.
+ *
+ * Revision 1.16  1996/06/04 10:19:00  adam
+ * Minor changes - removed include of ctype.h.
+ *
+ * Revision 1.15  1996/05/13  14:23:06  adam
+ * Work on compaction of set/use bytes in dictionary.
+ *
+ * Revision 1.14  1996/02/01  20:48:15  adam
+ * The total size of records are always checked in rec_cache_insert to
+ * reduce memory usage.
+ *
+ * Revision 1.13  1995/12/11  09:12:49  adam
+ * The rec_get function returns NULL if record doesn't exist - will
+ * happen in the server if the result set records have been deleted since
+ * the creation of the set (i.e. the search).
+ * The server saves a result temporarily if it is 'volatile', i.e. the
+ * set is register dependent.
+ *
+ * Revision 1.12  1995/12/07  17:38:47  adam
  * Work locking mechanisms for concurrent updates/commit.
  *
  * Revision 1.11  1995/12/06  13:58:26  adam
@@ -56,7 +97,6 @@
 #include <stdio.h>
 #include <assert.h>
 #include <string.h>
-#include <ctype.h>
 
 #include "recindxp.h"
 
@@ -77,11 +117,11 @@ static void rec_write_head (Records p)
 
 static void rec_tmp_expand (Records p, int size, int dst_type)
 {
-    if (p->tmp_size < size + 256 ||
+    if (p->tmp_size < size + 2048 ||
         p->tmp_size < p->head.block_size[dst_type]*2)
     {
         xfree (p->tmp_buf);
-        p->tmp_size = size + p->head.block_size[dst_type]*2 + 256;
+        p->tmp_size = size + p->head.block_size[dst_type]*2 + 2048;
         p->tmp_buf = xmalloc (p->tmp_size);
     }
 }
@@ -97,7 +137,6 @@ static int read_indx (Records p, int sysno, void *buf, int itemsize,
     {
         logf (LOG_FATAL|LOG_ERRNO, "read in %s at pos %ld",
               p->index_fname, (long) pos);
-        abort ();
         exit (1);
     }
     return r;
@@ -118,8 +157,8 @@ static void rec_release_blocks (Records p, int sysno)
 
     if (read_indx (p, sysno, &entry, sizeof(entry), 1) != 1)
         return ;
-    p->head.total_bytes -= entry.u.used.size;
-    freeblock = entry.u.used.next;
+    p->head.total_bytes -= entry.size;
+    freeblock = entry.next;
     assert (freeblock > 0);
     dst_type = freeblock & 7;
     assert (dst_type < REC_BLOCK_TYPES);
@@ -150,7 +189,8 @@ static void rec_delete_single (Records p, Record rec)
 
     rec_release_blocks (p, rec->sysno);
 
-    entry.u.free.next = p->head.index_free;
+    entry.next = p->head.index_free;
+    entry.size = 0;
     p->head.index_free = rec->sysno;
     write_indx (p, rec->sysno, &entry, sizeof(entry));
 }
@@ -200,14 +240,15 @@ static void rec_write_single (Records p, Record rec)
             {
                 logf (LOG_FATAL|LOG_ERRNO, "read in %s at free block %d",
                       p->data_fname[dst_type], block_free);
+		exit (1);
             }
         }
         else
             block_free = p->head.block_last[dst_type]++;
         if (block_prev == -1)
         {
-            entry.u.used.next = block_free*8 + dst_type;
-            entry.u.used.size = size;
+            entry.next = block_free*8 + dst_type;
+            entry.size = size;
             p->head.total_bytes += size;
             write_indx (p, rec->sysno, &entry, sizeof(entry));
         }
@@ -234,7 +275,7 @@ static void rec_update_single (Records p, Record rec)
     rec_write_single (p, rec);
 }
 
-Records rec_open (int rw)
+Records rec_open (BFiles bfs, int rw)
 {
     Records p;
     int i, r;
@@ -243,8 +284,8 @@ Records rec_open (int rw)
     p->rw = rw;
     p->tmp_size = 1024;
     p->tmp_buf = xmalloc (p->tmp_size);
-    p->index_fname = "recindex";
-    p->index_BFile = bf_open (p->index_fname, 128, rw);
+    p->index_fname = "reci";
+    p->index_BFile = bf_open (bfs, p->index_fname, 128, rw);
     if (p->index_BFile == NULL)
     {
         logf (LOG_FATAL|LOG_ERRNO, "open %s", p->index_fname);
@@ -287,14 +328,14 @@ Records rec_open (int rw)
     for (i = 0; i<REC_BLOCK_TYPES; i++)
     {
         char str[80];
-        sprintf (str, "recdata%c", i + 'A');
+        sprintf (str, "recd%c", i + 'A');
         p->data_fname[i] = xmalloc (strlen(str)+1);
         strcpy (p->data_fname[i], str);
         p->data_BFile[i] = NULL;
     }
     for (i = 0; i<REC_BLOCK_TYPES; i++)
     {
-        if (!(p->data_BFile[i] = bf_open (p->data_fname[i],
+        if (!(p->data_BFile[i] = bf_open (bfs, p->data_fname[i],
                                           p->head.block_size[i],
                                           rw)))
         {
@@ -362,7 +403,7 @@ static void rec_cache_insert (Records p, Record rec, enum recordCacheFlag flag)
 
     if (p->cache_cur == p->cache_max)
         rec_cache_flush (p, 1);
-    else if (p->cache_cur > 2)
+    else if (p->cache_cur > 0)
     {
         int i, j;
         int used = 0;
@@ -424,16 +465,20 @@ Record rec_get (Records p, int sysno)
     if ((recp = rec_cache_lookup (p, sysno, recordFlagNop)))
         return rec_cp (*recp);
 
-    read_indx (p, sysno, &entry, sizeof(entry), 0);
+    if (!read_indx (p, sysno, &entry, sizeof(entry), 1))
+        return NULL;       /* record is not there! */
 
-    dst_type = entry.u.used.next & 7;
+    if (!entry.size)
+        return NULL;       /* record is deleted */
+
+    dst_type = entry.next & 7;
     assert (dst_type < REC_BLOCK_TYPES);
-    freeblock = entry.u.used.next / 8;
+    freeblock = entry.next / 8;
 
     assert (freeblock > 0);
     
     rec = xmalloc (sizeof(*rec));
-    rec_tmp_expand (p, entry.u.used.size, dst_type);
+    rec_tmp_expand (p, entry.size, dst_type);
 
     cptr = p->tmp_buf;
     bf_read (p->data_BFile[dst_type], freeblock, 0, 0, cptr);
@@ -477,7 +522,7 @@ Record rec_new (Records p)
 
     assert (p);
     rec = xmalloc (sizeof(*rec));
-    if (p->head.index_free == 0)
+    if (1 || p->head.index_free == 0)
         sysno = (p->head.index_last)++;
     else
     {
@@ -485,7 +530,7 @@ Record rec_new (Records p)
 
         read_indx (p, p->head.index_free, &entry, sizeof(entry), 0);
         sysno = p->head.index_free;
-        p->head.index_free = entry.u.free.next;
+        p->head.index_free = entry.next;
     }
     (p->head.no_records)++;
     rec->sysno = sysno;
@@ -536,6 +581,9 @@ void rec_put (Records p, Record *recpp)
 void rec_rm (Record *recpp)
 {
     int i;
+
+    if (!*recpp)
+        return ;
     for (i = 0; i < REC_NO_INFO; i++)
         xfree ((*recpp)->info[i]);
     xfree (*recpp);