-/* $Id: extract.c,v 1.126 2002-10-22 12:51:08 adam Exp $
+/* $Id: extract.c,v 1.131 2002-11-15 21:26:00 adam Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002
Index Data Aps
spec_src = rGroup->groupName;
else if (!strcmp (special, "database"))
spec_src = rGroup->databaseName;
- else if (!strcmp (special, "filename"))
+ else if (!strcmp (special, "filename")) {
spec_src = fname;
+ }
else if (!strcmp (special, "type"))
spec_src = rGroup->recordType;
else
zh->reg->keys.prevAttrUse = -1;
zh->reg->keys.prevAttrSet = -1;
zh->reg->keys.prevSeqNo = 0;
- zh->reg->sortKeys = 0;
+ zh->reg->sortKeys.buf_used = 0;
+ zh->reg->sortKeys.buf_max = 0;
+ zh->reg->sortKeys.buf = 0;
recordOffset = fi->file_moffset;
extractCtrl.offset = fi->file_moffset;
{
dict_insert (zh->reg->matchDict, matchStr, sizeof(*sysno), sysno);
}
- extract_flushRecordKeys (zh, *sysno, 1, &zh->reg->keys);
extract_flushSortKeys (zh, *sysno, 1, &zh->reg->sortKeys);
+ extract_flushRecordKeys (zh, *sysno, 1, &zh->reg->keys);
zh->records_inserted++;
}
{
/* record already exists */
struct recKeys delkeys;
+ struct sortKeys sortKeys;
rec = rec_get (zh->reg->records, *sysno);
assert (rec);
}
delkeys.buf_used = rec->size[recInfo_delKeys];
delkeys.buf = rec->info[recInfo_delKeys];
- extract_flushSortKeys (zh, *sysno, 0, &zh->reg->sortKeys);
+
+ sortKeys.buf_used = rec->size[recInfo_sortKeys];
+ sortKeys.buf = rec->info[recInfo_sortKeys];
+
+ extract_flushSortKeys (zh, *sysno, 0, &sortKeys);
extract_flushRecordKeys (zh, *sysno, 0, &delkeys);
if (deleteFlag)
{
if (zh->records_processed < rGroup->fileVerboseLimit)
logf (LOG_LOG, "update %s %s " PRINTF_OFF_T,
rGroup->recordType, fname, recordOffset);
+ extract_flushSortKeys (zh, *sysno, 1, &zh->reg->sortKeys);
extract_flushRecordKeys (zh, *sysno, 1, &zh->reg->keys);
zh->records_updated++;
}
xfree (rec->info[recInfo_delKeys]);
if (zh->reg->keys.buf_used > 0 && rGroup->flagStoreKeys == 1)
{
-#if 1
rec->size[recInfo_delKeys] = zh->reg->keys.buf_used;
rec->info[recInfo_delKeys] = zh->reg->keys.buf;
zh->reg->keys.buf = NULL;
zh->reg->keys.buf_max = 0;
-#else
- rec->info[recInfo_delKeys] = xmalloc (reckeys.buf_used);
- rec->size[recInfo_delKeys] = reckeys.buf_used;
- memcpy (rec->info[recInfo_delKeys], reckeys.buf,
- rec->size[recInfo_delKeys]);
-#endif
}
else
{
rec->size[recInfo_delKeys] = 0;
}
+ /* update sort keys */
+ xfree (rec->info[recInfo_sortKeys]);
+
+ rec->size[recInfo_sortKeys] = zh->reg->sortKeys.buf_used;
+ rec->info[recInfo_sortKeys] = zh->reg->sortKeys.buf;
+ zh->reg->sortKeys.buf = NULL;
+ zh->reg->sortKeys.buf_max = 0;
+
/* save file size of original record */
zebraExplain_recordBytesIncrement (zh->reg->zei,
- recordAttr->recordSize);
close (fd);
return r;
}
-
-
int extract_rec_in_mem (ZebraHandle zh, const char *recordType,
const char *buf, size_t buf_size,
const char *databaseName, int delete_flag,
int store_keys, int store_data,
const char *match_criteria)
{
+ struct recordGroup rGroup;
+ rGroup.groupName = NULL;
+ rGroup.databaseName = (char *)databaseName;
+ rGroup.path = NULL;
+ rGroup.recordId = NULL;
+ rGroup.recordType = (char *)recordType;
+ rGroup.flagStoreData = store_data;
+ rGroup.flagStoreKeys = store_keys;
+ rGroup.flagRw = 1;
+ rGroup.databaseNamePath = 0;
+ rGroup.explainDatabase = 0;
+ rGroup.fileVerboseLimit = 100000;
+ rGroup.followLinks = -1;
+ return (bufferExtractRecord (zh,
+ buf, buf_size,
+ &rGroup,
+ delete_flag,
+ test_mode,
+ sysno,
+ match_criteria,
+ "<no file>"));
+}
+/*
+ If sysno is provided, then it's used to identify the reocord.
+ If not, and match_criteria is provided, then sysno is guessed
+ If not, and a record is provided, then sysno is got from there
+
+ */
+int bufferExtractRecord (ZebraHandle zh,
+ const char *buf, size_t buf_size,
+ struct recordGroup *rGroup,
+ int delete_flag,
+ int test_mode,
+ int *sysno,
+ const char *match_criteria,
+ const char *fname)
+
+{
RecordAttr *recordAttr;
struct recExtractCtrl extractCtrl;
int i, r;
RecType recType;
char subType[1024];
void *clientData;
- const char *fname = "<no file>";
+ SYSNO sysnotmp;
+ // const char *fname = "<no file>";
Record rec;
long recordOffset = 0;
struct zebra_fetch_control fc;
extractCtrl.fh = &fc;
/* announce database */
- if (zebraExplain_curDatabase (zh->reg->zei, databaseName))
+ if (zebraExplain_curDatabase (zh->reg->zei, rGroup->databaseName))
{
- if (zebraExplain_newDatabase (zh->reg->zei, databaseName, 0))
+ if (zebraExplain_newDatabase (zh->reg->zei, rGroup->databaseName, 0))
return 0;
}
+
+ if (!(rGroup->recordType)) {
+ logf (LOG_WARN, "No such record type defined");
+ return 0;
+ }
+
if (!(recType =
- recType_byName (zh->reg->recTypes, recordType, subType,
+ recType_byName (zh->reg->recTypes, rGroup->recordType, subType,
&clientData)))
{
- logf (LOG_WARN, "No such record type: %s", recordType);
+ logf (LOG_WARN, "No such record type: %s", rGroup->recordType);
return 0;
}
-
zh->reg->keys.buf_used = 0;
zh->reg->keys.prevAttrUse = -1;
zh->reg->keys.prevAttrSet = -1;
zh->reg->keys.prevSeqNo = 0;
- zh->reg->sortKeys = 0;
+ zh->reg->sortKeys.buf_used = 0;
+ zh->reg->sortKeys.buf_max = 0;
+ zh->reg->sortKeys.buf = 0;
extractCtrl.subType = subType;
extractCtrl.init = extract_init;
return 1;
}
/* match criteria */
+ matchStr = NULL;
+
+ if (! *sysno) {
+ char *rinfo;
+ if (strlen(match_criteria) > 0) {
+ matchStr = (char *)match_criteria;
+ } else {
+ if (rGroup->recordId && *rGroup->recordId) {
+ matchStr = fileMatchStr (zh, &zh->reg->keys, rGroup, fname,
+ rGroup->recordId);
+ }
+ }
+ if (matchStr) {
+ rinfo = dict_lookup (zh->reg->matchDict, matchStr);
+ if (rinfo)
+ memcpy (sysno, rinfo+1, sizeof(*sysno));
+ } else {
+ logf (LOG_WARN, "Bad match criteria (recordID)");
+ return 0;
+ }
+
+ }
if (! *sysno)
{
/* new record */
if (delete_flag)
{
- logf (LOG_LOG, "delete %s %s %ld", recordType,
+ logf (LOG_LOG, "delete %s %s %ld", rGroup->recordType,
fname, (long) recordOffset);
logf (LOG_WARN, "cannot delete record above (seems new)");
return 1;
}
- logf (LOG_LOG, "add %s %s %ld", recordType, fname,
+ logf (LOG_LOG, "add %s %s %ld", rGroup->recordType, fname,
(long) recordOffset);
rec = rec_new (zh->reg->records);
dict_insert (zh->reg->matchDict, matchStr,
sizeof(*sysno), sysno);
}
- extract_flushRecordKeys (zh, *sysno, 1, &zh->reg->keys);
extract_flushSortKeys (zh, *sysno, 1, &zh->reg->sortKeys);
+ extract_flushRecordKeys (zh, *sysno, 1, &zh->reg->keys);
+
+ zh->records_inserted++;
}
else
{
/* record already exists */
struct recKeys delkeys;
+ struct sortKeys sortKeys;
rec = rec_get (zh->reg->records, *sysno);
assert (rec);
if (recordAttr->runNumber ==
zebraExplain_runNumberIncrement (zh->reg->zei, 0))
{
- logf (LOG_LOG, "skipped %s %s %ld", recordType,
+ logf (LOG_LOG, "skipped %s %s %ld", rGroup->recordType,
fname, (long) recordOffset);
+ extract_flushSortKeys (zh, *sysno, -1, &zh->reg->sortKeys);
rec_rm (&rec);
+ logRecord(zh);
return 1;
}
delkeys.buf_used = rec->size[recInfo_delKeys];
delkeys.buf = rec->info[recInfo_delKeys];
- extract_flushSortKeys (zh, *sysno, 0, &zh->reg->sortKeys);
+
+ sortKeys.buf_used = rec->size[recInfo_sortKeys];
+ sortKeys.buf = rec->info[recInfo_sortKeys];
+
+ extract_flushSortKeys (zh, *sysno, 0, &sortKeys);
extract_flushRecordKeys (zh, *sysno, 0, &delkeys);
if (delete_flag)
{
/* record going to be deleted */
if (!delkeys.buf_used)
{
- logf (LOG_LOG, "delete %s %s %ld", recordType,
+ logf (LOG_LOG, "delete %s %s %ld", rGroup->recordType,
fname, (long) recordOffset);
logf (LOG_WARN, "cannot delete file above, storeKeys false");
}
else
{
- logf (LOG_LOG, "delete %s %s %ld", recordType,
+ logf (LOG_LOG, "delete %s %s %ld", rGroup->recordType,
fname, (long) recordOffset);
-#if 0
+ zh->records_deleted++;
if (matchStr)
- dict_delete (matchDict, matchStr);
-#endif
+ dict_delete (zh->reg->matchDict, matchStr);
rec_del (zh->reg->records, &rec);
}
rec_rm (&rec);
+ logRecord(zh);
return 1;
}
else
/* record going to be updated */
if (!delkeys.buf_used)
{
- logf (LOG_LOG, "update %s %s %ld", recordType,
+ logf (LOG_LOG, "update %s %s %ld", rGroup->recordType,
fname, (long) recordOffset);
logf (LOG_WARN, "cannot update file above, storeKeys false");
}
else
{
- logf (LOG_LOG, "update %s %s %ld", recordType,
+ logf (LOG_LOG, "update %s %s %ld", rGroup->recordType,
fname, (long) recordOffset);
+ extract_flushSortKeys (zh, *sysno, 1, &zh->reg->sortKeys);
extract_flushRecordKeys (zh, *sysno, 1, &zh->reg->keys);
+ zh->records_updated++;
}
}
}
/* update file type */
xfree (rec->info[recInfo_fileType]);
rec->info[recInfo_fileType] =
- rec_strdup (recordType, &rec->size[recInfo_fileType]);
+ rec_strdup (rGroup->recordType, &rec->size[recInfo_fileType]);
/* update filename */
xfree (rec->info[recInfo_filename]);
/* update delete keys */
xfree (rec->info[recInfo_delKeys]);
- if (zh->reg->keys.buf_used > 0 && store_keys == 1)
+ if (zh->reg->keys.buf_used > 0 && rGroup->flagStoreKeys == 1)
{
rec->size[recInfo_delKeys] = zh->reg->keys.buf_used;
rec->info[recInfo_delKeys] = zh->reg->keys.buf;
rec->size[recInfo_delKeys] = 0;
}
+ /* update sort keys */
+ xfree (rec->info[recInfo_sortKeys]);
+
+ rec->size[recInfo_sortKeys] = zh->reg->sortKeys.buf_used;
+ rec->info[recInfo_sortKeys] = zh->reg->sortKeys.buf;
+ zh->reg->sortKeys.buf = NULL;
+ zh->reg->sortKeys.buf_max = 0;
+
/* save file size of original record */
zebraExplain_recordBytesIncrement (zh->reg->zei,
- recordAttr->recordSize);
/* update store data */
xfree (rec->info[recInfo_storeData]);
- if (store_data == 1)
+ if (rGroup->flagStoreData == 1)
{
rec->size[recInfo_storeData] = recordAttr->recordSize;
rec->info[recInfo_storeData] = (char *)
/* update database name */
xfree (rec->info[recInfo_databaseName]);
rec->info[recInfo_databaseName] =
- rec_strdup (databaseName, &rec->size[recInfo_databaseName]);
+ rec_strdup (rGroup->databaseName, &rec->size[recInfo_databaseName]);
/* update offset */
recordAttr->recordOffset = recordOffset;
/* commit this record */
rec_put (zh->reg->records, &rec);
-
+ logRecord(zh);
return 0;
}
+
+
int explain_extract (void *handle, Record rec, data1_node *n)
{
ZebraHandle zh = (ZebraHandle) handle;
zh->reg->keys.prevAttrUse = -1;
zh->reg->keys.prevAttrSet = -1;
zh->reg->keys.prevSeqNo = 0;
- zh->reg->sortKeys = 0;
+ zh->reg->sortKeys.buf_used = 0;
extractCtrl.init = extract_init;
extractCtrl.tokenAdd = extract_token_add;
if (rec->size[recInfo_delKeys])
{
struct recKeys delkeys;
- struct sortKey *sortKeys = 0;
+ struct sortKeys sortkeys;
delkeys.buf_used = rec->size[recInfo_delKeys];
delkeys.buf = rec->info[recInfo_delKeys];
- extract_flushSortKeys (zh, rec->sysno, 0, &sortKeys);
+
+ sortkeys.buf_used = rec->size[recInfo_sortKeys];
+ sortkeys.buf = rec->info[recInfo_sortKeys];
+
+ extract_flushSortKeys (zh, rec->sysno, 0, &sortkeys);
extract_flushRecordKeys (zh, rec->sysno, 0, &delkeys);
}
extract_flushRecordKeys (zh, rec->sysno, 1, &zh->reg->keys);
rec->info[recInfo_delKeys] = zh->reg->keys.buf;
zh->reg->keys.buf = NULL;
zh->reg->keys.buf_max = 0;
+
+ xfree (rec->info[recInfo_sortKeys]);
+ rec->size[recInfo_sortKeys] = zh->reg->sortKeys.buf_used;
+ rec->info[recInfo_sortKeys] = zh->reg->sortKeys.buf;
+ zh->reg->sortKeys.buf = NULL;
+ zh->reg->sortKeys.buf_max = 0;
+
return 0;
}
static void extract_add_sort_string (RecWord *p, const char *string,
int length)
{
- struct sortKey *sk;
ZebraHandle zh = p->extractCtrl->handle;
+ struct sortKeys *sk = &zh->reg->sortKeys;
+ size_t off = 0;
- for (sk = zh->reg->sortKeys; sk; sk = sk->next)
- if (sk->attrSet == p->attrSet && sk->attrUse == p->attrUse)
- return;
-
- sk = (struct sortKey *) xmalloc (sizeof(*sk));
- sk->next = zh->reg->sortKeys;
- zh->reg->sortKeys = sk;
-
- sk->string = (char *) xmalloc (length);
- sk->length = length;
- memcpy (sk->string, string, length);
+ while (off < sk->buf_used)
+ {
+ int set, use, slen;
- sk->attrSet = p->attrSet;
- sk->attrUse = p->attrUse;
+ off += key_SU_decode(&set, sk->buf + off);
+ off += key_SU_decode(&use, sk->buf + off);
+ off += key_SU_decode(&slen, sk->buf + off);
+ off += slen;
+ if (p->attrSet == set && p->attrUse == use)
+ return;
+ }
+ assert (off == sk->buf_used);
+
+ if (sk->buf_used + IT_MAX_WORD > sk->buf_max)
+ {
+ char *b;
+
+ b = (char *) xmalloc (sk->buf_max += 128000);
+ if (sk->buf_used > 0)
+ memcpy (b, sk->buf, sk->buf_used);
+ xfree (sk->buf);
+ sk->buf = b;
+ }
+ off += key_SU_encode(p->attrSet, sk->buf + off);
+ off += key_SU_encode(p->attrUse, sk->buf + off);
+ off += key_SU_encode(length, sk->buf + off);
+ memcpy (sk->buf + off, string, length);
+ sk->buf_used = off + length;
}
void extract_add_string (RecWord *p, const char *string, int length)
}
void extract_flushSortKeys (ZebraHandle zh, SYSNO sysno,
- int cmd, struct sortKey **skp)
+ int cmd, struct sortKeys *sk)
{
- struct sortKey *sk = *skp;
SortIdx sortIdx = zh->reg->sortIdx;
+ size_t off = 0;
sortIdx_sysno (sortIdx, sysno);
- while (sk)
+
+ while (off < sk->buf_used)
{
- struct sortKey *sk_next = sk->next;
+ int set, use, slen, l;
+
+ off += key_SU_decode(&set, sk->buf + off);
+ off += key_SU_decode(&use, sk->buf + off);
+ off += key_SU_decode(&slen, sk->buf + off);
+
+ sortIdx_type(sortIdx, use);
if (cmd == 1)
- {
- /* insert/update: set it */
- sortIdx_type (sortIdx, sk->attrUse);
- sortIdx_add (sortIdx, sk->string, sk->length);
- }
- else if (cmd == 0)
- { /* delete : zero it */
- sortIdx_type (sortIdx, sk->attrUse);
- sortIdx_add (sortIdx, "", 1);
- }
- xfree (sk->string);
- xfree (sk);
- sk = sk_next;
+ sortIdx_add(sortIdx, sk->buf + off, slen);
+ else
+ sortIdx_add(sortIdx, "", 1);
+ off += slen;
}
- *skp = 0;
}
void encode_key_init (struct encode_info *i)
while ((*bp++ = *k++))
;
i->keylen= bp - i->buf -1;
+ assert(i->keylen+1+sizeof(struct it_key) < ENCODE_BUFLEN);
}
else
{
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)