public LTrieRow(LTrieRootNode root)
{
_root = root;
this._linkToValue = root.EmptyPointer;
TableFixTime = root.Tree.Storage.StorageFixTime;
}
public LTrieRow(LTrieRootNode root)
{
_root = root;
this._linkToValue = root.EmptyPointer;
TableFixTime = root.Tree.Storage.StorageFixTime;
}
//Format
//TotalSize,LinkToValue,0-255 Links to Kids
public LTrieGenerationNode(LTrieRootNode rootNode)
{
_root = rootNode;
DefaultEmptyPointer = this._root.EmptyPointer;
DefaultPointerLen = this._root.Tree.Storage.TrieSettings.POINTER_LENGTH;
Pointer = new byte[DefaultPointerLen];
KidsInNode = new LTrieKidsInNode(DefaultPointerLen);
//Total length,link to value, 256* (Ptr + 1[name of kid[0-255]] + 1 (ptr to next gen or to value)
MaximumKidLineLength = 2 + DefaultPointerLen + (256 * (DefaultPointerLen + 2));
}
public IEnumerable<LTrieRow> IterateBackwardSkipFrom(byte[] key, ulong skippingQuantity)
{
this.CheckTableIsOperable();
LTrieRootNode readRootNode = new LTrieRootNode(this);
Backward bw = new Backward(readRootNode);
return bw.IterateBackwardSkipFrom(key, skippingQuantity,true);
}
public IEnumerable<LTrieRow> IterateBackwardSkip(ulong skippingQuantity, bool useCache)
{
this.CheckTableIsOperable();
if (!useCache)
{
//Flashing changes on the disk before commit. In case if the same thread uses the same root node
this.SaveGenerationMap();
Backward bw = new Backward(rn);
return bw.IterateBackwardSkip(skippingQuantity, false);
}
else
{
LTrieRootNode readRootNode = new LTrieRootNode(this);
Backward bw = new Backward(readRootNode);
return bw.IterateBackwardSkip(skippingQuantity, true);
}
}
public LTrieRow IterateBackwardForMaximal(bool useCache)
{
this.CheckTableIsOperable();
if (!useCache)
{
//Flashing changes on the disk before commit. In case if the same thread uses the same root node
this.SaveGenerationMap();
Backward bw = new Backward(rn);
return bw.IterateBackwardForMaximal(false);
}
else
{
LTrieRootNode readRootNode = new LTrieRootNode(this);
Backward bw = new Backward(readRootNode);
return bw.IterateBackwardForMaximal(true);
}
}
public LTrieRow IterateBackwardForMaximal()
{
this.CheckTableIsOperable();
LTrieRootNode readRootNode = new LTrieRootNode(this);
Backward bw = new Backward(readRootNode);
return bw.IterateBackwardForMaximal(true);
}
public IEnumerable<LTrieRow> IterateBackward()
{
this.CheckTableIsOperable();
LTrieRootNode readRootNode = new LTrieRootNode(this);
Backward bw = new Backward(readRootNode);
return bw.IterateBackward(true);
}
//Iterate
public IEnumerable<LTrieRow> IterateForward()
{
this.CheckTableIsOperable();
LTrieRootNode readRootNode = new LTrieRootNode(this);
Forward fw = new Forward(readRootNode);
return fw.IterateForward(true);
}
/// <summary>
/// if useCache = true; uses newly created root node, else uses writing root node
/// </summary>
/// <returns></returns>
public ulong Count(bool useCache)
{
this.CheckTableIsOperable();
if (useCache)
{
LTrieRootNode readRootNode = new LTrieRootNode(this);
return readRootNode.RecordsCount;
}
else
{
//Flashing changes on the disk before commit. In case if the same thread uses the same root node
this.SaveGenerationMap();
return rn.RecordsCount;
}
}
/// <summary>
///
/// </summary>
/// <param name="startKey"></param>
/// <returns></returns>
public IEnumerable<LTrieRow> IterateForwardStartsWithClosestToPrefix(byte[] startKey)
{
this.CheckTableIsOperable();
LTrieRootNode readRootNode = new LTrieRootNode(this);
Forward bw = new Forward(readRootNode);
return bw.IterateForwardStartsWithClosestToPrefix(startKey, true);
}
/// <summary>
///
/// </summary>
/// <param name="startKey"></param>
/// <param name="useCache"></param>
/// <returns></returns>
public IEnumerable<LTrieRow> IterateForwardStartsWithClosestToPrefix(byte[] startKey, bool useCache)
{
this.CheckTableIsOperable();
if (!useCache)
{
//Flashing changes on the disk before commit. In case if the same thread uses the same root node
this.SaveGenerationMap();
Forward bw = new Forward(rn);
return bw.IterateForwardStartsWithClosestToPrefix(startKey, false);
}
else
{
LTrieRootNode readRootNode = new LTrieRootNode(this);
Forward bw = new Forward(readRootNode);
return bw.IterateForwardStartsWithClosestToPrefix(startKey, true);
}
}
//SKIP
public IEnumerable<LTrieRow> IterateForwardSkip(ulong skippingQuantity)
{
this.CheckTableIsOperable();
LTrieRootNode readRootNode = new LTrieRootNode(this);
Forward bw = new Forward(readRootNode);
return bw.IterateForwardSkip(skippingQuantity,true);
}
//Iterate From - To
public IEnumerable<LTrieRow> IterateForwardFromTo(byte[] startKey, byte[] stopKey,bool includeStartKey, bool includeStopKey)
{
this.CheckTableIsOperable();
LTrieRootNode readRootNode = new LTrieRootNode(this);
Forward bw = new Forward(readRootNode);
return bw.IterateForwardFromTo(startKey,stopKey,includeStartKey,includeStopKey,true);
}
//bool SYNCHRO_READ
public IEnumerable<LTrieRow> IterateForward(bool useCache)
{
this.CheckTableIsOperable();
if (!useCache) //SYNCHRO_READ
{
//Flashing changes on the disk before commit. In case if the same thread uses the same root node
this.SaveGenerationMap();
Forward fw = new Forward(rn);
return fw.IterateForward(false);
}
else
{
LTrieRootNode readRootNode = new LTrieRootNode(this);
Forward fw = new Forward(readRootNode);
return fw.IterateForward(true);
}
}
public IEnumerable<LTrieRow> IterateBackwardStartFrom(byte[] key, bool includeStartKey)
{
this.CheckTableIsOperable();
LTrieRootNode readRootNode = new LTrieRootNode(this);
Backward bw = new Backward(readRootNode);
return bw.IterateBackwardStartFrom(key, includeStartKey,true);
}
public IEnumerable<LTrieRow> IterateBackwardStartsWith(byte[] startKey)
{
this.CheckTableIsOperable();
LTrieRootNode readRootNode = new LTrieRootNode(this);
Backward bw = new Backward(readRootNode);
return bw.IterateBackwardStartsWith(startKey,true);
}
public IEnumerable<LTrieRow> IterateBackwardStartFrom(byte[] key, bool includeStartKey, bool useCache)
{
this.CheckTableIsOperable();
if (!useCache)
{
//Flashing changes on the disk before commit. In case if the same thread uses the same root node
this.SaveGenerationMap();
Backward bw = new Backward(rn);
return bw.IterateBackwardStartFrom(key, includeStartKey, false);
}
else
{
LTrieRootNode readRootNode = new LTrieRootNode(this);
Backward bw = new Backward(readRootNode);
return bw.IterateBackwardStartFrom(key, includeStartKey, true);
}
}
/// <summary>
/// Interface function which recreates every time new rootNode from itself by every new function call.
/// and also packs root node last fixation dateTime (ROLL or COMMIT).
/// It will be used for READ FUNC's via Transaction, they can decide if to create new instance of read root or use existing.
/// Returns NULL is !TableIsOperable.
/// </summary>
/// <param name="modifiedDt"></param>
/// <returns></returns>
public ITrieRootNode GetTrieReadNode(out long dtTableFixed)
{
dtTableFixed = DtTableFixed;
if (!TableIsOperable)
return null;
LTrieRootNode readRootNode = new LTrieRootNode(this);
return readRootNode;
}
/// <summary>
/// if useCache = true; uses newly created root node, else uses writing root node
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public LTrieRow GetKey(byte[] key,bool useCache)
{
this.CheckTableIsOperable();
if (useCache)
{
//Creating new Root -
LTrieRootNode readRootNode = new LTrieRootNode(this);
return readRootNode.GetKey(key, true);
}
else
{
//Flashing changes on the disk before commit. In case if the same thread uses the same root node
this.SaveGenerationMap();
return rn.GetKey(key, false);
}
}
/// <summary>
/// Liana Trie
/// </summary>
/// <param name="storage"></param>
public LTrie(IStorage storage)
{
Storage = storage;
try
{
//Will instantiate also RollerBack
Cache = new LTrieWriteCache(this);
//If first reading or writing of root node fails also bring to exception
rn = new LTrieRootNode(this);
//rollBackFileName = Cache.RollBackFileName;
}
catch (Exception ex)
{
//lock (lock_TableIsOperatable)
TableIsOperable = false;
throw new Exception(String.Format("LTrie init failed: {0}; Exception: {1}", this.TableName, ex.ToString()));
}
}