X-Git-Url: http://git.indexdata.com/?a=blobdiff_plain;f=index%2Fkinput.c;h=5b14b744f1d8502c526dc454a028000284f03ae8;hb=9bbaa63b531cc24a1bc79e0447a9d6fbde113a3f;hp=b6eaca284c5311045baedf305cef0c40626bd6df;hpb=2b1851bd5565e3d21f9cf9a37661a584c063b75f;p=idzebra-moved-to-github.git

diff --git a/index/kinput.c b/index/kinput.c
index b6eaca2..5b14b74 100644
--- a/index/kinput.c
+++ b/index/kinput.c
@@ -1,15 +1,26 @@
-/*
- * Copyright (C) 1994-2002, Index Data
- * All rights reserved.
- * Sebastian Hammer, Adam Dickmeiss, Heikki Levanto
- *
- * $Id: kinput.c,v 1.47 2002-04-04 14:14:13 adam Exp $
- *
- * Bugs
- *  - Allocates a lot of memory for the merge process, but never releases it.
- *    Doesn't matter, as the program terminates soon after.  
- 
- */
+/* $Id: kinput.c,v 1.53 2002-08-05 19:46:01 adam Exp $
+   Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002
+   Index Data Aps
+
+This file is part of the Zebra server.
+
+Zebra is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2, or (at your option) any later
+version.
+
+Zebra is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License
+along with Zebra; see the file LICENSE.zebra.  If not, write to the
+Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
+02111-1307, USA.
+*/
+
+
  
 #include <fcntl.h>
 #ifdef WIN32
@@ -29,11 +40,6 @@
 #define INP_BUF_START 60000
 #define INP_BUF_ADD  400000
 
-static int no_diffs   = 0;
-static int no_updates = 0;
-static int no_deletions = 0;
-static int no_insertions = 0;
-static int no_iterations = 0;
 
 struct key_file {
     int   no;            /* file no */
@@ -229,13 +235,13 @@ struct heap_info {
     int    heapnum;
     int    *ptr;
     int    (*cmp)(const void *p1, const void *p2);
-    Dict dict;
-    ISAMS isams;
-#if ZMBOL
-    ISAM isam;
-    ISAMC isamc;
-    ISAMD isamd;
-#endif
+    struct zebra_register *reg;
+
+    int no_diffs;
+    int no_updates;
+    int no_deletions;
+    int no_insertions;
+    int no_iterations;
 };
 
 struct heap_info *key_heap_init (int nkeys,
@@ -256,13 +262,19 @@ struct heap_info *key_heap_init (int nkeys,
         hi->ptr[i] = i;
         hi->info.buf[i] = (char *) xmalloc (INP_NAME_MAX);
     }
+    hi->no_diffs = 0;
+    hi->no_diffs = 0;
+    hi->no_updates = 0;
+    hi->no_deletions = 0;
+    hi->no_insertions = 0;
+    hi->no_iterations = 0;
     return hi;
 }
 
 void key_heap_destroy (struct heap_info *hi, int nkeys)
 {
     int i;
-    yaz_log (LOG_LOG, "key_heap_destroy");
+    yaz_log (LOG_DEBUG, "key_heap_destroy");
     for (i = 0; i<=nkeys; i++)
         xfree (hi->info.buf[i]);
     
@@ -342,7 +354,7 @@ static int heap_read_one (struct heap_info *hi, char *name, char *key)
     key_heap_delete (hi);
     if ((r = key_file_read (kf, rbuf)))
         key_heap_insert (hi, rbuf, r, kf);
-    no_iterations++;
+    hi->no_iterations++;
     return 1;
 }
 
@@ -382,7 +394,6 @@ int heap_cread_item (void *vp, char **dst, int *insertMode)
     return 1;
 }
 
-#if ZMBOL
 int heap_inpc (struct heap_info *hi)
 {
     struct heap_cread_info hci;
@@ -404,30 +415,107 @@ int heap_inpc (struct heap_info *hi)
 
         strcpy (this_name, hci.cur_name);
 	assert (hci.cur_name[1]);
-        no_diffs++;
-        if ((dict_info = dict_lookup (hi->dict, hci.cur_name)))
+        hi->no_diffs++;
+        if ((dict_info = dict_lookup (hi->reg->dict, hci.cur_name)))
+        {
+            memcpy (&isamc_p, dict_info+1, sizeof(ISAMC_P));
+            isamc_p2 = isc_merge (hi->reg->isamc, isamc_p, isamc_i);
+            if (!isamc_p2)
+            {
+                hi->no_deletions++;
+                if (!dict_delete (hi->reg->dict, this_name))
+                    abort();
+            }
+            else 
+            {
+                hi->no_updates++;
+                if (isamc_p2 != isamc_p)
+                    dict_insert (hi->reg->dict, this_name,
+                                 sizeof(ISAMC_P), &isamc_p2);
+            }
+        } 
+        else
+        {
+            isamc_p = isc_merge (hi->reg->isamc, 0, isamc_i);
+            hi->no_insertions++;
+            dict_insert (hi->reg->dict, this_name, sizeof(ISAMC_P), &isamc_p);
+        }
+    }
+    xfree (isamc_i);
+    xfree (hci.key);
+    return 0;
+} 
+
+/* for debugging only */
+static void print_dict_item (ZebraMaps zm, const char *s)
+{
+    int reg_type = s[1];
+    char keybuf[IT_MAX_WORD+1];
+    char *to = keybuf;
+    const char *from = s + 2;
+
+    while (*from)
+    {
+        const char *res = zebra_maps_output (zm, reg_type, &from);
+        if (!res)
+            *to++ = *from++;
+        else
+            while (*res)
+                *to++ = *res++;
+    }
+    *to = '\0';
+    yaz_log (LOG_LOG, "%s", keybuf);
+}
+
+int heap_inpb (struct heap_info *hi)
+{
+    struct heap_cread_info hci;
+    ISAMC_I isamc_i = (ISAMC_I) xmalloc (sizeof(*isamc_i));
+
+    hci.key = (char *) xmalloc (KEY_SIZE);
+    hci.mode = 1;
+    hci.hi = hi;
+    hci.more = heap_read_one (hi, hci.cur_name, hci.key);
+
+    isamc_i->clientData = &hci;
+    isamc_i->read_item = heap_cread_item;
+
+    while (hci.more)
+    {
+        char this_name[INP_NAME_MAX];
+        ISAMC_P isamc_p, isamc_p2;
+        char *dict_info;
+
+        strcpy (this_name, hci.cur_name);
+	assert (hci.cur_name[1]);
+        hi->no_diffs++;
+
+#if 0
+        print_dict_item (hi->reg->zebra_maps, hci.cur_name);
+#endif
+        if ((dict_info = dict_lookup (hi->reg->dict, hci.cur_name)))
         {
             memcpy (&isamc_p, dict_info+1, sizeof(ISAMC_P));
-            isamc_p2 = isc_merge (hi->isamc, isamc_p, isamc_i);
+            isamc_p2 = isamb_merge (hi->reg->isamb, isamc_p, isamc_i);
             if (!isamc_p2)
             {
-                no_deletions++;
-                if (!dict_delete (hi->dict, this_name))
+                hi->no_deletions++;
+                if (!dict_delete (hi->reg->dict, this_name))
                     abort();
             }
             else 
             {
-                no_updates++;
+                hi->no_updates++;
                 if (isamc_p2 != isamc_p)
-                    dict_insert (hi->dict, this_name,
+                    dict_insert (hi->reg->dict, this_name,
                                  sizeof(ISAMC_P), &isamc_p2);
             }
         } 
         else
         {
-            isamc_p = isc_merge (hi->isamc, 0, isamc_i);
-            no_insertions++;
-            dict_insert (hi->dict, this_name, sizeof(ISAMC_P), &isamc_p);
+            isamc_p = isamb_merge (hi->reg->isamb, 0, isamc_i);
+            hi->no_insertions++;
+            dict_insert (hi->reg->dict, this_name, sizeof(ISAMC_P), &isamc_p);
         }
     }
     xfree (isamc_i);
@@ -451,35 +539,59 @@ int heap_inpd (struct heap_info *hi)
     while (hci.more)
     {
         char this_name[INP_NAME_MAX];
-        ISAMD_P isamd_p, isamd_p2;
         char *dict_info;
+        char dictentry[ISAMD_MAX_DICT_LEN+1];
+        char dictlen;
 
         strcpy (this_name, hci.cur_name);
+        
+        /* print_dict_item (hi->reg->zebra_maps, hci.cur_name); */
+        /*!*/ /* FIXME: depend on isamd-debug */
+
 	assert (hci.cur_name[1]);
-        no_diffs++;
-        if ((dict_info = dict_lookup (hi->dict, hci.cur_name)))
+        hi->no_diffs++;
+        if ((dict_info = dict_lookup (hi->reg->dict, hci.cur_name)))
         {
-            memcpy (&isamd_p, dict_info+1, sizeof(ISAMD_P));
-            isamd_p2 = isamd_append (hi->isamd, isamd_p, isamd_i);
-            if (!isamd_p2)
+            dictlen=dict_info[0];
+            memcpy (dictentry, dict_info+1, dictlen );
+#ifdef SKIPTHIS
+            logf(LOG_LOG,"dictentry before. len=%d: %d %d %d %d %d %d %d %d %d",
+               dictlen,dictentry[0], dictentry[1], dictentry[2],
+                       dictentry[3], dictentry[4], dictentry[5],
+                       dictentry[6], dictentry[7], dictentry[8]); /*!*/
+#endif
+            dictlen= isamd_append(hi->reg->isamd, dictentry, dictlen, isamd_i);
+             /* logf dictentry after */
+            if (dictlen)
             {
-                no_deletions++;
-                if (!dict_delete (hi->dict, this_name))
-                    abort();
+                hi->no_updates++;
+                if ( (dictlen!=dict_info[0]) ||
+                     (0!=memcmp(dictentry, dict_info+1, dictlen)) )
+                {
+                    dict_insert(hi->reg->dict, this_name,
+                                dictlen,dictentry);
+                }
             }
-            else 
+            else
             {
-                no_updates++;
-                if (isamd_p2 != isamd_p)
-                    dict_insert (hi->dict, this_name,
-                                 sizeof(ISAMD_P), &isamd_p2);
+                hi->no_deletions++;
+                if (!dict_delete (hi->reg->dict, this_name)) 
+                {
+	            logf (LOG_FATAL, "dict_delete failed");
+                    abort();
+                }
             }
         } 
         else
         {
-            isamd_p = isamd_append (hi->isamd, 0, isamd_i);
-            no_insertions++;
-            dict_insert (hi->dict, this_name, sizeof(ISAMD_P), &isamd_p);
+            dictlen=0;
+            memset (dictentry, '\0', ISAMD_MAX_DICT_LEN);
+            dictlen= isamd_append(hi->reg->isamd, dictentry, dictlen, isamd_i);
+             /* logf dictentry first */
+            hi->no_insertions++;
+            if (dictlen)
+                dict_insert(hi->reg->dict, this_name,
+                                dictlen,dictentry);
         }
     }
     xfree (isamd_i);
@@ -522,33 +634,34 @@ int heap_inp (struct heap_info *hi)
                 key_buf = new_key_buf;
             }
         }
-        no_diffs++;
+        hi->no_diffs++;
         nmemb = key_buf_ptr / KEY_SIZE;
         assert (nmemb * (int) KEY_SIZE == key_buf_ptr);
-        if ((info = dict_lookup (hi->dict, cur_name)))
+        if ((info = dict_lookup (hi->reg->dict, cur_name)))
         {
             ISAM_P isam_p, isam_p2;
             memcpy (&isam_p, info+1, sizeof(ISAM_P));
-            isam_p2 = is_merge (hi->isam, isam_p, nmemb, key_buf);
+            isam_p2 = is_merge (hi->reg->isam, isam_p, nmemb, key_buf);
             if (!isam_p2)
             {
-                no_deletions++;
-                if (!dict_delete (hi->dict, cur_name))
+                hi->no_deletions++;
+                if (!dict_delete (hi->reg->dict, cur_name))
                     abort ();
             }
             else 
             {
-                no_updates++;
+                hi->no_updates++;
                 if (isam_p2 != isam_p)
-                    dict_insert (hi->dict, cur_name, sizeof(ISAM_P), &isam_p2);
+                    dict_insert (hi->reg->dict, cur_name,
+                                 sizeof(ISAM_P), &isam_p2);
             }
         }
         else
         {
             ISAM_P isam_p;
-            no_insertions++;
-            isam_p = is_merge (hi->isam, 0, nmemb, key_buf);
-            dict_insert (hi->dict, cur_name, sizeof(ISAM_P), &isam_p);
+            hi->no_insertions++;
+            isam_p = is_merge (hi->reg->isam, 0, nmemb, key_buf);
+            dict_insert (hi->reg->dict, cur_name, sizeof(ISAM_P), &isam_p);
         }
         memcpy (key_buf, next_key, KEY_SIZE);
         strcpy (cur_name, next_name);
@@ -556,8 +669,6 @@ int heap_inp (struct heap_info *hi)
     return 0;
 }
 
-#endif
-
 int heap_inps (struct heap_info *hi)
 {
     struct heap_cread_info hci;
@@ -579,12 +690,12 @@ int heap_inps (struct heap_info *hi)
 
         strcpy (this_name, hci.cur_name);
 	assert (hci.cur_name[1]);
-        no_diffs++;
-        if (!(dict_info = dict_lookup (hi->dict, hci.cur_name)))
+        hi->no_diffs++;
+        if (!(dict_info = dict_lookup (hi->reg->dict, hci.cur_name)))
         {
-            isams_p = isams_merge (hi->isams, isams_i);
-            no_insertions++;
-            dict_insert (hi->dict, this_name, sizeof(ISAMS_P), &isams_p);
+            isams_p = isams_merge (hi->reg->isams, isams_i);
+            hi->no_insertions++;
+            dict_insert (hi->reg->dict, this_name, sizeof(ISAMS_P), &isams_p);
         }
 	else
 	{
@@ -668,38 +779,32 @@ void zebra_index_merge (ZebraHandle zh)
         progressInfo.totalOffset += kf[i]->buf_size;
     }
     hi = key_heap_init (nkeys, key_qsort_compare);
-    hi->dict = zh->reg->dict;
-    hi->isams = zh->reg->isams;
-#if ZMBOL
-    hi->isam = zh->reg->isam;
-    hi->isamc = zh->reg->isamc;
-    hi->isamd = zh->reg->isamd;
-#endif
+    hi->reg = zh->reg;
     
     for (i = 1; i<=nkeys; i++)
         if ((r = key_file_read (kf[i], rbuf)))
             key_heap_insert (hi, rbuf, r, kf[i]);
     if (zh->reg->isams)
 	heap_inps (hi);
-#if ZMBOL
-    else if (zh->reg->isamc)
+    if (zh->reg->isamc)
         heap_inpc (hi);
-    else if (zh->reg->isam)
+    if (zh->reg->isam)
 	heap_inp (hi);
-    else if (zh->reg->isamd)
+    if (zh->reg->isamd)
 	heap_inpd (hi);
-#endif
+    if (zh->reg->isamb)
+	heap_inpb (hi);
 	
     for (i = 1; i<=nkeys; i++)
     {
         extract_get_fname_tmp  (zh, rbuf, i);
         unlink (rbuf);
     }
-    logf (LOG_LOG, "Iterations . . .%7d", no_iterations);
-    logf (LOG_LOG, "Distinct words .%7d", no_diffs);
-    logf (LOG_LOG, "Updates. . . . .%7d", no_updates);
-    logf (LOG_LOG, "Deletions. . . .%7d", no_deletions);
-    logf (LOG_LOG, "Insertions . . .%7d", no_insertions);
+    logf (LOG_LOG, "Iterations . . .%7d", hi->no_iterations);
+    logf (LOG_LOG, "Distinct words .%7d", hi->no_diffs);
+    logf (LOG_LOG, "Updates. . . . .%7d", hi->no_updates);
+    logf (LOG_LOG, "Deletions. . . .%7d", hi->no_deletions);
+    logf (LOG_LOG, "Insertions . . .%7d", hi->no_insertions);
     zh->reg->key_file_no = 0;
 
     key_heap_destroy (hi, nkeys);