Work on truncation.

[idzebra-moved-to-github.git] / index / recindex.c

diff --git a/index/recindex.c b/index/recindex.c
index 6f06cd5..3e562f4 100644 (file)
--- a/index/recindex.c
+++ b/index/recindex.c
@@ -1,10 +1,35 @@
 /*
- * Copyright (C) 1994-1995, Index Data I/S 
+ * Copyright (C) 1994-1996, Index Data I/S 
  * All rights reserved.
  * Sebastian Hammer, Adam Dickmeiss
  *
  * $Log: recindex.c,v $
- * Revision 1.10  1995-12-06 12:41:24  adam
+ * 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
+ * Improved flushing of records - all flushes except the last one
+ * don't write the last accessed. Also flush takes place if record
+ * info occupy more than about 256k.
+ *
+ * Revision 1.10  1995/12/06  12:41:24  adam
  * New command 'stat' for the index program.
  * Filenames can be read from stdin by specifying '-'.
  * Bug fix/enhancement of the transformation from terms to regular
@@ -48,7 +73,6 @@
 #include <stdio.h>
 #include <assert.h>
 #include <string.h>
-#include <ctype.h>
 
 #include "recindxp.h"
 
@@ -110,8 +134,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);
@@ -142,7 +166,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));
 }
@@ -198,8 +223,8 @@ static void rec_write_single (Records p, Record rec)
             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));
         }
@@ -300,10 +325,13 @@ Records rec_open (int rw)
     return p;
 }
 
-static void rec_cache_flush (Records p)
+static void rec_cache_flush (Records p, int saveCount)
 {
-    int i;
-    for (i = 0; i<p->cache_cur; i++)
+    int i, j;
+
+    if (saveCount >= p->cache_cur)
+        saveCount = 0;
+    for (i = 0; i<p->cache_cur - saveCount; i++)
     {
         struct record_cache_entry *e = p->record_cache + i;
         switch (e->flag)
@@ -322,7 +350,10 @@ static void rec_cache_flush (Records p)
         }
         rec_rm (&e->rec);
     }
-    p->cache_cur = 0;
+    for (j = 0; j<saveCount; j++, i++)
+        memcpy (p->record_cache+j, p->record_cache+i,
+                sizeof(*p->record_cache));
+    p->cache_cur = saveCount;
 }
 
 static Record *rec_cache_lookup (Records p, int sysno,
@@ -347,7 +378,20 @@ static void rec_cache_insert (Records p, Record rec, enum recordCacheFlag flag)
     struct record_cache_entry *e;
 
     if (p->cache_cur == p->cache_max)
-        rec_cache_flush (p);
+        rec_cache_flush (p, 1);
+    else if (p->cache_cur > 0)
+    {
+        int i, j;
+        int used = 0;
+        for (i = 0; i<p->cache_cur; i++)
+        {
+            Record r = (p->record_cache + i)->rec;
+            for (j = 0; j<REC_NO_INFO; j++)
+                used += r->size[j];
+        }
+        if (used > 256000)
+            rec_cache_flush (p, 1);
+    }
     assert (p->cache_cur < p->cache_max);
 
     e = p->record_cache + (p->cache_cur)++;
@@ -362,7 +406,7 @@ void rec_close (Records *pp)
 
     assert (p);
 
-    rec_cache_flush (p);
+    rec_cache_flush (p, 0);
     xfree (p->record_cache);
 
     if (p->rw)
@@ -397,16 +441,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! */
+
+    if (!entry.size)
+        return NULL;       /* record is deleted */
 
-    dst_type = entry.u.used.next & 7;
+    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);
@@ -458,7 +506,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;
@@ -475,6 +523,7 @@ void rec_del (Records p, Record *recpp)
 {
     Record *recp;
 
+    (p->head.no_records)--;
     if ((recp = rec_cache_lookup (p, (*recpp)->sysno, recordFlagDelete)))
     {
         rec_rm (recp);
@@ -508,6 +557,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);