-/* $Id: extract.c,v 1.120 2002-08-02 19:26:55 adam Exp $
+/* $Id: extract.c,v 1.125 2002-10-22 09:37:55 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002
Index Data Aps
#define PRINTF_OFF_T "%ld"
#endif
+#define USE_SHELLSORT 0
+
+#if USE_SHELLSORT
static void shellsort(void *ar, int r, size_t s,
int (*cmp)(const void *a, const void *b))
{
memcpy (a+s*j, v, s);
}
}
-
+#endif
static void logRecord (ZebraHandle zh)
{
struct recordGroup *rGroup;
};
-static void recordLogPreamble (int level, const char *msg, void *info)
-{
- struct recordLogInfo *p = (struct recordLogInfo *) info;
- FILE *outf = yaz_log_file ();
-
- if (level & LOG_LOG)
- return ;
- fprintf (outf, "File %s, offset %d, type %s\n",
- p->rGroup->recordType, p->recordOffset, p->fname);
- log_event_start (NULL, NULL);
-}
-
-
static int recordExtract (ZebraHandle zh,
SYSNO *sysno, const char *fname,
struct recordGroup *rGroup, int deleteFlag,
char *matchStr;
SYSNO sysnotmp;
Record rec;
- struct recordLogInfo logInfo;
off_t recordOffset = 0;
if (fi->fd != -1)
if (!rGroup->flagRw)
printf ("File: %s " PRINTF_OFF_T "\n", fname, recordOffset);
-
- logInfo.fname = fname;
- logInfo.recordOffset = recordOffset;
- logInfo.rGroup = rGroup;
- log_event_start (recordLogPreamble, &logInfo);
+ if (rGroup->flagRw)
+ {
+ char msg[512];
+ sprintf (msg, "%s:" PRINTF_OFF_T , fname, recordOffset);
+ yaz_log_init_prefix2 (msg);
+ }
r = (*recType->extract)(clientData, &extractCtrl);
- log_event_start (NULL, NULL);
-
+ yaz_log_init_prefix2 (0);
if (r == RECCTRL_EXTRACT_EOF)
return 0;
- else if (r == RECCTRL_EXTRACT_ERROR)
+ else if (r == RECCTRL_EXTRACT_ERROR_GENERIC)
{
/* error occured during extraction ... */
if (rGroup->flagRw &&
}
return 0;
}
+ else if (r == RECCTRL_EXTRACT_ERROR_NO_SUCH_FILTER)
+ {
+ /* error occured during extraction ... */
+ if (rGroup->flagRw &&
+ zh->records_processed < rGroup->fileVerboseLimit)
+ {
+ logf (LOG_WARN, "no filter for %s %s "
+ PRINTF_OFF_T, rGroup->recordType,
+ fname, recordOffset);
+ }
+ return 0;
+ }
if (zh->reg->keys.buf_used == 0)
{
/* the extraction process returned no information - the record
if (r == RECCTRL_EXTRACT_EOF)
return 0;
- else if (r == RECCTRL_EXTRACT_ERROR)
+ else if (r == RECCTRL_EXTRACT_ERROR_GENERIC)
{
/* error occured during extraction ... */
-#if 1
- yaz_log (LOG_WARN, "extract error");
-#else
- if (rGroup->flagRw &&
- zh->records_processed < rGroup->fileVerboseLimit)
- {
- logf (LOG_WARN, "fail %s %s %ld", rGroup->recordType,
- fname, (long) recordOffset);
- }
-#endif
+ yaz_log (LOG_WARN, "extract error: generic");
+ return 0;
+ }
+ else if (r == RECCTRL_EXTRACT_ERROR_NO_SUCH_FILTER)
+ {
+ /* error occured during extraction ... */
+ yaz_log (LOG_WARN, "extract error: no such filter");
return 0;
}
if (zh->reg->keys.buf_used == 0)
if (!zh->reg->key_buf)
{
- int mem = 8*1024*1024;
+ int mem= 1024*1024* atoi( res_get_def( zh->res, "memmax", "8"));
+ if (mem <= 0)
+ {
+ logf(LOG_WARN, "Invalid memory setting, using default 8 MB");
+ mem= 1024*1024*8;
+ }
+ /* FIXME: That "8" should be in a default settings include */
+ /* not hard-coded here! -H */
zh->reg->key_buf = (char**) xmalloc (mem);
zh->reg->ptr_top = mem/sizeof(char*);
zh->reg->ptr_i = 0;
cp = (zh->reg->key_buf)[zh->reg->ptr_top - ptr_i];
if (strcmp (cp, prevcp))
{
+ encode_key_flush ( &encode_info, outf);
encode_key_init (&encode_info);
encode_key_write (cp, &encode_info, outf);
prevcp = cp;
else
encode_key_write (cp + strlen(cp), &encode_info, outf);
}
+ encode_key_flush ( &encode_info, outf);
#else
qsort (key_buf + ptr_top-ptr_i, ptr_i, sizeof(char*), key_x_compare);
extract_get_fname_tmp (out_fname, key_file_no);
cp = key_buf[ptr_top-ptr_i];
encode_key_write (cp+key_y_len, &encode_info, outf);
}
+ encode_key_flush ( &encode_info, outf);
if (!i)
break;
prevcp = key_buf[ptr_top-ptr_i];
i->sysno = 0;
i->seqno = 0;
i->cmd = -1;
+ i->prevsys=0;
+ i->prevseq=0;
+ i->prevcmd=-1;
+ i->keylen=0;
}
char *encode_key_int (int d, char *bp)
return bp;
}
+#ifdef OLDENCODE
+/* this is the old encode_key_write
+ * may be deleted once we are confident that the new works
+ * HL 15-oct-2002
+ */
void encode_key_write (char *k, struct encode_info *i, FILE *outf)
{
struct it_key key;
}
}
+void encode_key_flush (struct encode_info *i, FILE *outf)
+{ /* dummy routine */
+}
+
+#else
+
+/* new encode_key_write
+ * The idea is to buffer one more key, and compare them
+ * If we are going to delete and insert the same key,
+ * we may as well not bother. Should make a difference in
+ * updates with small modifications (appending to a mbox)
+ */
+void encode_key_write (char *k, struct encode_info *i, FILE *outf)
+{
+ struct it_key key;
+ char *bp;
+
+ if (*k) /* first time for new key */
+ {
+ bp = i->buf;
+ while ((*bp++ = *k++))
+ ;
+ i->keylen= bp - i->buf -1;
+ }
+ else
+ {
+ bp=i->buf + i->keylen;
+ *bp++=0;
+ k++;
+ }
+
+ memcpy (&key, k+1, sizeof(struct it_key));
+ if (0==i->prevsys) /* no previous filter, fill up */
+ {
+ i->prevsys=key.sysno;
+ i->prevseq=key.seqno;
+ i->prevcmd=*k;
+ }
+ else if ( (i->prevsys==key.sysno) &&
+ (i->prevseq==key.seqno) &&
+ (i->prevcmd!=*k) )
+ { /* same numbers, diff cmd, they cancel out */
+ i->prevsys=0;
+ }
+ else
+ { /* different stuff, write previous, move buf */
+ bp = encode_key_int ( (i->prevsys - i->sysno) * 2 + i->prevcmd, bp);
+ if (i->sysno != i->prevsys)
+ {
+ i->sysno = i->prevsys;
+ i->seqno = 0;
+ }
+ else if (!i->seqno && !i->prevseq && i->cmd == i->prevcmd)
+ {
+ return; /* ??? Filters some sort of duplicates away */
+ /* ??? Can this ever happen -H 15oct02 */
+ }
+ bp = encode_key_int (i->prevseq - i->seqno, bp);
+ i->seqno = i->prevseq;
+ i->cmd = i->prevcmd;
+ if (fwrite (i->buf, bp - i->buf, 1, outf) != 1)
+ {
+ logf (LOG_FATAL|LOG_ERRNO, "fwrite");
+ exit (1);
+ }
+ i->keylen=0; /* ok, it's written, forget it */
+ i->prevsys=key.sysno;
+ i->prevseq=key.seqno;
+ i->prevcmd=*k;
+ }
+#ifdef SKIPTHIS_OLDCODE
+ bp = encode_key_int ( (key.sysno - i->sysno) * 2 + *k, bp);
+ if (i->sysno != key.sysno)
+ {
+ i->sysno = key.sysno;
+ i->seqno = 0;
+ }
+ else if (!i->seqno && !key.seqno && i->cmd == *k)
+ return;
+ bp = encode_key_int (key.seqno - i->seqno, bp);
+ i->seqno = key.seqno;
+ i->cmd = *k;
+ if (fwrite (i->buf, bp - i->buf, 1, outf) != 1)
+ {
+ logf (LOG_FATAL|LOG_ERRNO, "fwrite");
+ exit (1);
+ }
+ i->keylen=0; /* ok, it's written, forget it */
+#endif
+}
+
+void encode_key_flush (struct encode_info *i, FILE *outf)
+{ /* flush the last key from i */
+ char *bp =i->buf + i->keylen;
+ if (0==i->prevsys)
+ {
+ return; /* nothing to flush */
+ }
+ *bp++=0;
+ bp = encode_key_int ( (i->prevsys - i->sysno) * 2 + i->prevcmd, bp);
+ if (i->sysno != i->prevsys)
+ {
+ i->sysno = i->prevsys;
+ i->seqno = 0;
+ }
+ else if (!i->seqno && !i->prevseq && i->cmd == i->prevcmd)
+ {
+ return; /* ??? Filters some sort of duplicates away */
+ /* ??? Can this ever happen -H 15oct02 */
+ }
+ bp = encode_key_int (i->prevseq - i->seqno, bp);
+ i->seqno = i->prevseq;
+ i->cmd = i->prevcmd;
+ if (fwrite (i->buf, bp - i->buf, 1, outf) != 1)
+ {
+ logf (LOG_FATAL|LOG_ERRNO, "fwrite");
+ exit (1);
+ }
+ i->keylen=0; /* ok, it's written, forget it */
+ i->prevsys=0; /* forget the values too */
+ i->prevseq=0;
+}
+#endif