New update method: the 'old' keys are saved for each records.

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

diff --git a/index/recindex.c b/index/recindex.c
index b8ccae7..bdd134c 100644 (file)
--- a/index/recindex.c
+++ b/index/recindex.c
@@ -4,7 +4,13 @@
  * Sebastian Hammer, Adam Dickmeiss
  *
  * $Log: recindex.c,v $
- * Revision 1.2  1995-11-15 19:13:08  adam
+ * Revision 1.4  1995-11-20 16:59:46  adam
+ * New update method: the 'old' keys are saved for each records.
+ *
+ * Revision 1.3  1995/11/16  15:34:55  adam
+ * Uses new record management system in both indexer and server.
+ *
+ * Revision 1.2  1995/11/15  19:13:08  adam
  * Work on record management.
  *
  * Revision 1.1  1995/11/15  14:46:20  adam
@@ -63,13 +69,17 @@ struct record_index_entry {
 
 #define REC_HEAD_MAGIC "rechead"
 
-char *rec_strdup (const char *s)
+char *rec_strdup (const char *s, size_t *len)
 {
     char *p;
 
     if (!s)
+    {
+        *len = 0;
         return NULL;
-    p = malloc (strlen(s)+1);
+    }
+    *len = strlen(s)+1;
+    p = malloc (*len);
     if (!p)
     {
         logf (LOG_FATAL|LOG_ERRNO, "malloc");
@@ -134,6 +144,7 @@ Records rec_open (int rw)
         logf (LOG_FATAL|LOG_ERRNO, "read %s", p->index_fname);
         exit (1);
     case 0:
+        memcpy (p->head.magic, REC_HEAD_MAGIC, sizeof(p->head.magic));
         p->head.index_free = 0;
         p->head.index_last = 1;
         p->head.no_records = 0;
@@ -162,7 +173,7 @@ Records rec_open (int rw)
         logf (LOG_FATAL|LOG_ERRNO, "open %s", p->data_fname);
         exit (1);
     }
-    p->cache_max = 100;
+    p->cache_max = 10;
     p->cache_cur = 0;
     if (!(p->record_cache = malloc (sizeof(*p->record_cache)*p->cache_max)))
     {
@@ -205,9 +216,9 @@ static void rec_write_single (Records p, Record rec)
 
     for (i = 0; i < REC_NO_INFO; i++)
         if (!rec->info[i])
-            size++;
+            size += sizeof(*rec->size);
         else
-            size += strlen(rec->info[i])+1;
+            size += sizeof(*rec->size) + rec->size[i];
     
     entry.u.used.offset = p->head.data_size;
     entry.u.used.size = size;
@@ -249,13 +260,15 @@ static void rec_write_single (Records p, Record rec)
     }
     cptr = p->tmp_buf;
     for (i = 0; i < REC_NO_INFO; i++)
-        if (!rec->info[i])
-            *cptr++ = '\0';
-        else
+    {
+        memcpy (cptr, &rec->size[i], sizeof(*rec->size));
+        cptr += sizeof(*rec->size);
+        if (rec->info[i])
         {
-            strcpy (cptr, rec->info[i]);
-            cptr += strlen(rec->info[i]) + 1;
+            memcpy (cptr, rec->info[i], rec->size[i]);
+            cptr += rec->size[i];
         }
+    }
     for (got = 0; got < entry.u.used.size; got += r)
     {
         r = write (p->data_fd, p->tmp_buf + got, entry.u.used.size - got);
@@ -264,7 +277,6 @@ static void rec_write_single (Records p, Record rec)
             logf (LOG_FATAL|LOG_ERRNO, "write of %s", p->data_fname);
             exit (1);
         }
-        got += r;
     }
 }
 
@@ -276,7 +288,7 @@ static void rec_cache_flush (Records p)
         struct record_cache_entry *e = p->record_cache + i;
         if (e->dirty)
             rec_write_single (p, e->rec);
-        rec_rm (e->rec);
+        rec_rm (&e->rec);
     }
     p->cache_cur = 0;
 }
@@ -306,7 +318,7 @@ static void rec_cache_insert (Records p, Record rec, int dirty)
     assert (p->cache_cur < p->cache_max);
 
     e = p->record_cache + (p->cache_cur)++;
-    e->dirty = 1;
+    e->dirty = dirty;
     e->rec = rec_cp (rec);
 }
 
@@ -317,6 +329,9 @@ void rec_close (Records *p)
     rec_cache_flush (*p);
     free ((*p)->record_cache);
 
+    if ((*p)->rw)
+        rec_write_head (*p);
+
     if ((*p)->index_fd != -1)
         close ((*p)->index_fd);
 
@@ -374,22 +389,23 @@ Record rec_get (Records p, int sysno)
             logf (LOG_FATAL|LOG_ERRNO, "read of %s", p->data_fname);
             exit (1);
         }
-        got += r;
     }
     rec->sysno = sysno;
 
     nptr = p->tmp_buf;
     for (i = 0; i < REC_NO_INFO; i++)
-        if (*nptr)
+    {
+        memcpy (&rec->size[i], nptr, sizeof(*rec->size));
+        nptr += sizeof(*rec->size);
+        if (rec->size[i])
         {
-            rec->info[i] = rec_strdup (nptr);
-            nptr += strlen(nptr)+1;
+            rec->info[i] = malloc (rec->size[i]);
+            memcpy (rec->info[i], nptr, rec->size[i]);
+            nptr += rec->size[i];
         }
         else
-        {
-            nptr++;
             rec->info[i] = NULL;
-        }
+    }
     rec_cache_insert (p, rec, 0);
     return rec;
 }
@@ -418,30 +434,38 @@ Record rec_new (Records p)
     (p->head.no_records)++;
     rec->sysno = sysno;
     for (i = 0; i < REC_NO_INFO; i++)
+    {
         rec->info[i] = NULL;
+        rec->size[i] = 0;
+    }
     rec_cache_insert (p, rec, 1);
     return rec;
 }
 
-void rec_put (Records p, Record rec)
+void rec_put (Records p, Record *recpp)
 {
     Record *recp;
 
-    if ((recp = rec_cache_lookup (p, rec->sysno, 1)))
+    if ((recp = rec_cache_lookup (p, (*recpp)->sysno, 1)))
     {
-        rec_rm (*recp);
-        *recp = rec_cp (rec);
+        rec_rm (recp);
+        *recp = *recpp;
     }
     else
-        rec_cache_insert (p, rec, 1);
+    {
+        rec_cache_insert (p, *recpp, 1);
+        rec_rm (recpp);
+    }
+    *recpp = NULL;
 }
 
-void rec_rm (Record rec)
+void rec_rm (Record *recpp)
 {
     int i;
     for (i = 0; i < REC_NO_INFO; i++)
-        free (rec->info[i]);
-    free (rec);
+        free ((*recpp)->info[i]);
+    free (*recpp);
+    *recpp = NULL;
 }
 
 Record rec_cp (Record rec)
@@ -456,6 +480,20 @@ Record rec_cp (Record rec)
     }
     n->sysno = rec->sysno;
     for (i = 0; i < REC_NO_INFO; i++)
-        n->info[i] = rec_strdup (rec->info[i]);
+        if (!rec->info[i])
+        {
+            n->info[i] = NULL;
+            n->size[i] = 0;
+        }
+        else
+        {
+            n->size[i] = rec->size[i];
+            if (!(n->info[i] = malloc (rec->size[i])))
+            {
+                logf (LOG_FATAL|LOG_ERRNO, "malloc. rec_cp");
+                exit (1);
+            }
+            memcpy (n->info[i], rec->info[i], rec->size[i]);
+        }
     return n;
 }