-/*
- * Copyright (C) 1994-2002, Index Data
- * All rights reserved.
- * Sebastian Hammer, Adam Dickmeiss, Heikki Levanto
- *
- * $Id: kinput.c,v 1.46 2002-02-20 23:07:54 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.52 2002-08-02 19:26:55 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
#include <assert.h>
#include "index.h"
-#include "zserver.h"
#define KEY_SIZE (1+sizeof(struct it_key))
#define INP_NAME_MAX 768
#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 */
{
const char *pre;
- pre = res_get_def (zh->service->res, "keyTmpDir", ".");
+ pre = res_get_def (zh->res, "keyTmpDir", ".");
sprintf (fname, "%s/key%d.tmp", pre, no);
}
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,
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;
}
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;
}
return 1;
}
-#if ZMBOL
int heap_inpc (struct heap_info *hi)
{
struct heap_cread_info hci;
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);
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);
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);
return 0;
}
-#endif
-
int heap_inps (struct heap_info *hi)
{
struct heap_cread_info hci;
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
{
int i, r;
struct heap_info *hi;
struct progressInfo progressInfo;
- int nkeys = zh->key_file_no;
+ int nkeys = zh->reg->key_file_no;
if (nkeys < 0)
{
time (&progressInfo.lastTime);
for (i = 1; i<=nkeys; i++)
{
- kf[i] = key_file_init (i, 8192, zh->service->res);
+ kf[i] = key_file_init (i, 8192, zh->res);
kf[i]->readHandler = progressFunc;
kf[i]->readInfo = &progressInfo;
progressInfo.totalBytes += kf[i]->length;
progressInfo.totalOffset += kf[i]->buf_size;
}
hi = key_heap_init (nkeys, key_qsort_compare);
- hi->dict = zh->service->dict;
- hi->isams = zh->service->isams;
-#if ZMBOL
- hi->isam = zh->service->isam;
- hi->isamc = zh->service->isamc;
- hi->isamd = zh->service->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->service->isams)
+ if (zh->reg->isams)
heap_inps (hi);
-#if ZMBOL
- else if (zh->service->isamc)
+ if (zh->reg->isamc)
heap_inpc (hi);
- else if (zh->service->isam)
+ if (zh->reg->isam)
heap_inp (hi);
- else if (zh->service->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);
- zh->key_file_no = 0;
+ 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);
for (i = 1; i<=nkeys; i++)
projects / idzebra-moved-to-github.git / blobdiff