private void CheckIndexState()
{
log.Debug("Checking Index state...");
int last = _index.GetLastIndexedRecordNumber();
int count = _archive.Count();
if (last < count)
{
log.Debug("Rebuilding index...");
log.Debug(" last index count = " + last);
log.Debug(" data items count = " + count);
// check last index record and archive record
// rebuild index if needed
for (int i = last; i < count; i++)
{
bool deleted = false;
T key = _archive.GetKey(i, out deleted);
if (deleted == false)
{
_index.Set(key, i);
}
else
{
_index.RemoveKey(key);
}
if (i % 100000 == 0)
{
log.Debug("100,000 items re-indexed");
}
}
log.Debug("Rebuild index done.");
}
}
public bool Delete(T id, byte[] data)
{
lock (_archivelock) _archive.WriteData(id, data, true);
lock (_indexlock)
{
return(_index.RemoveKey(id));
}
}
public bool DeleteKeyHF(string key)
{
lock (_lock)
{
int alloc;
if (_keys.Get(key, out alloc))
{
if (_isDirty == false)
{
WriteDirtyFile();
}
byte[] keybytes = Helper.GetBytes(key);
AllocationBlock ab = FillAllocationBlock(alloc);
ab.keylen = (byte)keybytes.Length;
_keys.RemoveKey(key);// remove key from index
// write ab
ab.deleteKey = true;
ab.datalength = 0;
byte[] header = CreateAllocHeader(ab, keybytes);
_datastore.SeekBlock(ab.blocknumber);
_datastore.WriteBlockBytes(header, 0, header.Length);
// free old data blocks
_datastore.FreeBlocks(ab.Blocks);
return(true);
}
}
return(false);
}
private void RebuildDataFiles()
{
MGIndex <string> keys = null;
try
{
// remove old free list
if (File.Exists(_Path + "data.bmp"))
{
File.Delete(_Path + "data.bmp");
}
_datastore = new StorageFileHF(_Path + "data.mghf", Global.HighFrequencyKVDiskBlockSize);
_BlockSize = _datastore.GetBlockSize();
if (File.Exists(_Path + "keys.idx"))
{
_log.Debug("removing old keys index");
foreach (var f in Directory.GetFiles(_Path, "keys.*"))
{
File.Delete(f);
}
}
keys = new MGIndex <string>(_Path, "keys.idx", 255, /*Global.PageItemCount,*/ false);
WAHBitArray visited = new WAHBitArray();
int c = _datastore.NumberofBlocks();
for (int i = 0; i < c; i++) // go through blocks
{
if (visited.Get(i))
{
continue;
}
byte[] b = _datastore.ReadBlockBytes(i, _blockheader.Length + 255);
int bnum = Helper.ToInt32(b, 0);
if (bnum > 0) // check if a start block
{
visited.Set(i, true);
_datastore.FreeBlock(i); // mark as free
continue;
}
AllocationBlock ab = new AllocationBlock();
// start block found
int blocknumexpected = 0;
int next = ParseBlockHeader(ab, b, blocknumexpected);
int last = 0;
bool freelast = false;
AllocationBlock old = null;
if (keys.Get(ab.key, out last))
{
old = this.FillAllocationBlock(last);
freelast = true;
}
blocknumexpected++;
bool failed = false;
if (ab.deleteKey == false)
{
while (next > 0) // read the blocks
{
ab.Blocks.Add(next);
b = _datastore.ReadBlockBytes(next, _blockheader.Length + ab.keylen);
next = ParseBlockHeader(ab, b, blocknumexpected);
if (next == -1) // non matching block
{
failed = true;
break;
}
blocknumexpected++;
}
}
else
{
failed = true;
keys.RemoveKey(ab.key);
}
// new data ok
if (failed == false)
{
keys.Set(ab.key, ab.blocknumber); // valid block found
if (freelast) // free the old blocks
{
_datastore.FreeBlocks(old.Blocks);
}
}
visited.Set(i, true);
}
// all ok delete temp.$ file
if (File.Exists(_Path + _dirtyFilename))
{
File.Delete(_Path + _dirtyFilename);
}
}
catch (Exception ex)
{
_log.Error(ex);
}
finally
{
_log.Debug("Shutting down files and index");
_datastore.Shutdown();
keys.SaveIndex();
keys.Shutdown();
}
}
public bool RemoveKey(T key)
{
// remove and store key in storage file
_archive.WriteData(key, null, true);
return(_index.RemoveKey(key));
}