public Table(StorageState storageState, FileData fileData)
{
_storageState = storageState;
try
{
_fileData = fileData;
if (_storageState.Options.MaxBlockCacheSizePerTableFile > 0)
{
_blockCache = new LruCache<BlockHandle, Block>(_storageState.Options.MaxBlockCacheSizePerTableFile);
}
if (fileData.Size < Footer.EncodedLength)
throw new CorruptedDataException("File is too short to be an sstable");
var footer = new Footer();
using (var accessor = fileData.File.CreateAccessor(fileData.Size - Footer.EncodedLength, Footer.EncodedLength))
{
footer.DecodeFrom(accessor);
}
var readOptions = new ReadOptions
{
VerifyChecksums = _storageState.Options.ParanoidChecks
};
_indexBlock = new Block(_storageState.Options, readOptions, footer.IndexHandle, fileData);
_indexBlock.IncrementUsage();
if (_storageState.Options.FilterPolicy == null)
return; // we don't need any metadata
using (var metaBlock = new Block(_storageState.Options, readOptions, footer.MetaIndexHandle, fileData))
using (var iterator = metaBlock.CreateIterator(CaseInsensitiveComparator.Default))
{
var filterName = ("filter." + _storageState.Options.FilterPolicy.Name);
iterator.Seek(filterName);
if (iterator.IsValid && CaseInsensitiveComparator.Default.Compare(filterName, iterator.Key) == 0)
{
var handle = new BlockHandle();
using (var stream = iterator.CreateValueStream())
{
handle.DecodeFrom(stream);
}
var filterAccessor = _fileData.File.CreateAccessor(handle.Position, handle.Count);
try
{
_filter = _storageState.Options.FilterPolicy.CreateFilter(filterAccessor);
}
catch (Exception)
{
if (_filter == null)
filterAccessor.Dispose();
else
_filter.Dispose();
throw;
}
}
}
}
catch (Exception)
{
Dispose();
throw;
}
}
public BlockIterator(IComparator comparator, Block parent)
{
_comparator = comparator;
_parent = parent;
_keyBuffer = _parent._storageOptions.BufferPool.Take(_parent._storageOptions.MaximumExpectedKeySize);
}
internal IIterator CreateBlockIterator(ReadOptions readOptions, BlockHandle handle)
{
if (_blockCache == null)
{
Block uncachedBlock = null;
IIterator blockIterator = null;
try
{
uncachedBlock = new Block(_storageState.Options, readOptions, handle, _fileData);
// uncachedBlock.IncrementUsage(); - intentionally not calling this, will be disposed when the iterator is disposed
blockIterator = uncachedBlock.CreateIterator(_storageState.InternalKeyComparator);
return blockIterator;
}
catch (Exception)
{
if (uncachedBlock != null)
uncachedBlock.Dispose();
if (blockIterator != null)
blockIterator.Dispose();
throw;
}
}
Block value;
if (_blockCache.TryGet(handle, out value))
{
return value.CreateIterator(_storageState.InternalKeyComparator);
}
var block = new Block(_storageState.Options, readOptions, handle, _fileData);
block.IncrementUsage(); // the cache is using this, so avoid having it disposed by the cache while in use
_blockCache.Set(handle, block);
return block.CreateIterator(_storageState.InternalKeyComparator);
}