public override async IAsyncEnumerable <IndexNode> Execute(IndexService indexer, CollectionIndex index)
{
var node = await indexer.Find(index, _value, false, Query.Ascending);
if (node == null)
{
yield break;
}
yield return(node);
if (index.Unique == false)
{
// navigate in both sides to return all nodes found
var first = node;
// first go forward
while (!node.Next[0].IsEmpty && ((node = await indexer.GetNode(node.Next[0])).Key.CompareTo(_value, indexer.Collation) == 0))
{
if (node.Key.IsMinValue || node.Key.IsMaxValue)
{
break;
}
yield return(node);
}
node = first;
// and than, go backward
while (!node.Prev[0].IsEmpty && ((node = await indexer.GetNode(node.Prev[0])).Key.CompareTo(_value, indexer.Collation) == 0))
{
if (node.Key.IsMinValue || node.Key.IsMaxValue)
{
break;
}
yield return(node);
}
}
}
private IEnumerable <IndexNode> ExecuteStartsWith(IndexService indexer, CollectionIndex index)
{
// find first indexNode
var first = indexer.Find(index, _startsWith, true, this.Order);
var node = first;
// if collection exists but are empty
if (first == null)
{
yield break;
}
// first, go backward to get all same values
while (node != null)
{
// if current node are edges exit while
if (node.Key.IsMinValue || node.Key.IsMaxValue)
{
break;
}
var valueString = node.Key.IsString ? node.Key.AsString : node.Key.ToString();
if (_equals ?
valueString.Equals(_startsWith, StringComparison.OrdinalIgnoreCase) :
valueString.StartsWith(_startsWith, StringComparison.OrdinalIgnoreCase))
{
// must still testing SqlLike method for rest of pattern - only if exists more to test (avoid slow SqlLike test)
if ((_testSqlLike == false) ||
(_testSqlLike == true && valueString.SqlLike(_pattern) == true))
{
yield return(node);
}
}
else
{
break;
}
node = indexer.GetNode(node.GetNextPrev(0, -this.Order));
}
// move fordward
node = indexer.GetNode(first.GetNextPrev(0, this.Order));
while (node != null)
{
// if current node are edges exit while
if (node.Key.IsMinValue || node.Key.IsMaxValue)
{
break;
}
var valueString = node.Key.IsString ? node.Key.AsString : node.Key.ToString();
if (_equals ?
valueString.Equals(_pattern, StringComparison.OrdinalIgnoreCase) :
valueString.StartsWith(_startsWith, StringComparison.OrdinalIgnoreCase))
{
// must still testing SqlLike method for rest of pattern - only if exists more to test (avoid slow SqlLike test)
if (node.DataBlock.IsEmpty == false &&
((_testSqlLike == false) ||
(_testSqlLike == true && valueString.SqlLike(_pattern) == true)))
{
yield return(node);
}
}
else
{
break;
}
// first, go backward to get all same values
node = indexer.GetNode(node.GetNextPrev(0, this.Order));
}
}
public BsonDocument Load(PageAddress rawId)
{
var node = _indexer.GetNode(rawId);
return(this.Load(node));
}
public async Task <BsonDocument> Load(PageAddress rawId)
{
var node = await _indexer.GetNode(rawId);
return(await this.Load(node));
}
public override IEnumerable <IndexNode> Execute(IndexService indexer, CollectionIndex index)
{
// if order are desc, swap start/end values
var start = this.Order == Query.Ascending ? _start : _end;
var end = this.Order == Query.Ascending ? _end : _start;
var startEquals = this.Order == Query.Ascending ? _startEquals : _endEquals;
var endEquals = this.Order == Query.Ascending ? _endEquals : _startEquals;
// find first indexNode (or get from head/tail if Min/Max value)
var first =
start.Type == BsonType.MinValue ? indexer.GetNode(index.Head) :
start.Type == BsonType.MaxValue ? indexer.GetNode(index.Tail) :
indexer.Find(index, start, true, this.Order);
var node = first;
// if startsEquals, return all equals value from start linked list
if (startEquals && node != null)
{
// going backward in same value list to get first value
while (!node.GetNextPrev(0, -this.Order).IsEmpty&& ((node = indexer.GetNode(node.GetNextPrev(0, -this.Order))).Key.CompareTo(start) == 0))
{
if (node.Key.IsMinValue || node.Key.IsMaxValue)
{
break;
}
yield return(node);
}
node = first;
}
// returns (or not) equals start value
while (node != null)
{
var diff = node.Key.CompareTo(start);
// if current value are not equals start, go out this loop
if (diff != 0)
{
break;
}
if (startEquals && !(node.Key.IsMinValue || node.Key.IsMaxValue))
{
yield return(node);
}
node = indexer.GetNode(node.GetNextPrev(0, this.Order));
}
// navigate using next[0] do next node - if less or equals returns
while (node != null)
{
var diff = node.Key.CompareTo(end);
if (endEquals && diff == 0 && !(node.Key.IsMinValue || node.Key.IsMaxValue))
{
yield return(node);
}
else if (diff == -this.Order && !(node.Key.IsMinValue || node.Key.IsMaxValue))
{
yield return(node);
}
else
{
break;
}
node = indexer.GetNode(node.GetNextPrev(0, this.Order));
}
}