private IEnumerable <long> MergeSorted(IEnumerable <long>[] items, ERowIDSortDirection sortDirection)
{
if (items.Length == 1)
{
return(items[0]);
}
return(GetMergeSorted(items, sortDirection));
}
public IEnumerable <long> Filter(IEnumerable <PartitionRowIDRange> partitions,
IReadTransactionContext tx, ERowIDSortDirection sort)
{
if (_column.Indexed)
{
return(GetLatestByIndexedSymbol(partitions, tx, sort));
}
return(GetLatestByNonIndexedField(partitions, tx, sort));
}
public IEnumerable <long> Filter(IEnumerable <PartitionRowIDRange> partitions,
IReadTransactionContext tx, ERowIDSortDirection sortDirection)
{
if (_column.Indexed)
{
var values = GetAllMatchingValues(tx);
if (!values.IsNone)
{
if (!values.IsSigle)
{
var valueSet = values.Values.Distinct().ToList();
var items = new IEnumerable <long> [valueSet.Count];
return(partitions.SelectMany(part =>
{
var partition = tx.Read(part.PartitionID);
for (int v = 0; v < valueSet.Count; v++)
{
var symbolValue = valueSet[v];
var rowIDs = TakeFromTo(part, partition.GetSymbolRows(_column.ColumnID, symbolValue, tx));
if (sortDirection == ERowIDSortDirection.Asc)
{
// Todo: use tx.ReadContext and reuse buffers.
rowIDs = rowIDs.Reverse();
}
items[v] = rowIDs;
}
if (sortDirection == ERowIDSortDirection.None)
{
return items.SelectMany(i => i);
}
return MergeSorted(items, sortDirection);
}));
}
else
{
return(partitions.SelectMany(part =>
{
var partition = tx.Read(part.PartitionID);
var rowIDs = TakeFromTo(part, partition.GetSymbolRows(_column.ColumnID, values.Value, tx));
if (sortDirection == ERowIDSortDirection.Asc)
{
rowIDs = rowIDs.Reverse();
}
return rowIDs;
}));
}
}
}
return(partitions.SelectMany(part =>
{
var partition = tx.Read(part.PartitionID);
return IsPartitionMatch(tx, part, partition, sortDirection);
}));
}
public IEnumerable <long> Execute(IJournalCore journal, IReadTransactionContext tx,
ERowIDSortDirection sort)
{
var intervalFilter = new PartitionIntervalIterator();
var intervals = Timestamps.AllIntervals.SelectMany(
i => intervalFilter.IteratePartitions(tx.ReadPartitions, i, tx)).ToList();
if (sort == ERowIDSortDirection.Desc)
{
intervals.Reverse();
}
if (_partitionFilter != null)
{
if (_andFilters == null)
{
return(_partitionFilter.Filter(intervals, tx, sort));
}
OptimizeFilters(journal, tx);
return(ApplyFilters(_partitionFilter.Filter(intervals, tx, sort), tx));
}
OptimizeFilters(journal, tx);
return(FilterRowsRange(tx, intervals, sort));
}
private IEnumerable <long> IsPartitionMatch(IReadTransactionContext tx, PartitionRowIDRange part,
IPartitionReader partition, ERowIDSortDirection sortDirection)
{
if (sortDirection == ERowIDSortDirection.Asc)
{
for (long rowId = part.Low; rowId <= part.High; rowId++)
{
if (IsMatch(partition, tx.ReadCache, rowId))
{
yield return(RowIDUtil.ToRowID(part.PartitionID, rowId));
}
}
}
else
{
for (long rowId = part.High; rowId >= part.Low; rowId--)
{
if (IsMatch(partition, tx.ReadCache, rowId))
{
yield return(RowIDUtil.ToRowID(part.PartitionID, rowId));
}
}
}
}
private IEnumerable <long> Intersect(IEnumerable <long> enum1, IEnumerable <long> enum2, ERowIDSortDirection sort)
{
if (sort != ERowIDSortDirection.Asc)
{
return(IntersectDesc(enum1, enum2));
}
return(IntersectAsc(enum1, enum2));
}
public IEnumerable <long> Execute(IJournalCore journal, IReadTransactionContext tx, ERowIDSortDirection sort)
{
// Timestamp restricted
if (_left is TimestampRangePlanItem)
{
return(_right.Execute(journal, tx, sort));
}
if (_right is TimestampRangePlanItem)
{
return(_left.Execute(journal, tx, sort));
}
if (_left.Cardinality(journal, tx) < _right.Cardinality(journal, tx))
{
return(Intersect(_left.Execute(journal, tx, sort), _right.Execute(journal, tx, sort), sort));
}
return(Intersect(_right.Execute(journal, tx, sort), _left.Execute(journal, tx, sort), sort));
}
public IEnumerable <long> Execute(IJournalCore journal, IReadTransactionContext tx, ERowIDSortDirection sort)
{
var intervalFilter = new PartitionIntervalIterator();
if (sort == ERowIDSortDirection.Desc)
{
return(Timestamps.AllIntervals.Reverse().SelectMany(
interval => GetIdsDesc(
intervalFilter.IteratePartitions(
tx.ReadPartitions.Reverse(), interval, tx))
));
}
return(Timestamps.AllIntervals.SelectMany(
interval => GetIdsAsc(
intervalFilter.IteratePartitions(tx.ReadPartitions, interval, tx))
));
}
private IEnumerable <long> FilterRowsRange(IReadTransactionContext tx, List <PartitionRowIDRange> intervals, ERowIDSortDirection sort)
{
for (int i = 0; i < intervals.Count; i++)
{
var partitionRowIDRange = intervals[i];
var paritition = tx.Read(partitionRowIDRange.PartitionID);
long from = sort == ERowIDSortDirection.Asc ? partitionRowIDRange.Low : partitionRowIDRange.High;
long to = sort == ERowIDSortDirection.Asc ? partitionRowIDRange.High: partitionRowIDRange.Low;
long increment = sort == ERowIDSortDirection.Asc ? 1 : -1;
for (long rowID = from; rowID < to; rowID += increment)
{
if (MatchFilters(paritition, tx.ReadCache, rowID))
{
yield return(RowIDUtil.ToRowID(partitionRowIDRange.PartitionID, rowID));
}
}
}
}
private IEnumerable <long> GetMergeSorted(IEnumerable <IEnumerable <long> > items, ERowIDSortDirection sortDirection)
{
var ens = items.Select(i => i.GetEnumerator()).Where(e => e.MoveNext()).ToArray();
// Trivial solutions.
if (ens.Length == 0)
{
yield break;
}
if (ens.Length == 1)
{
do
{
yield return(ens[0].Current);
} while (ens[0].MoveNext());
yield break;
}
// Priority Queue.
var pq = new EnumerablePriorityQueue(ens.Length, sortDirection == ERowIDSortDirection.Asc);
for (int i = 0; i < ens.Length; i++)
{
pq.Enqueue(ens[i]);
}
while (pq.Count > 0)
{
var e = pq.Dequeue();
yield return(e.Current);
if (e.MoveNext())
{
pq.Enqueue(e);
}
}
}
private IEnumerable <long> GetLatestByIndexedSymbol(IEnumerable <PartitionRowIDRange> partitions,
IReadTransactionContext tx, ERowIDSortDirection sort)
{
List <long> latestRowIDs;
if (_keys != null)
{
latestRowIDs = GetLatestByIndexedSymbolByKeys(partitions, tx);
}
else
{
latestRowIDs = GetAllLatestByIndexedSymbolByKeys(partitions, tx);
}
// RowID sort asc.
latestRowIDs.Sort();
int startIndex = latestRowIDs.BinarySearch(1L);
if (startIndex < 0)
{
startIndex = ~startIndex;
}
var result = new ArraySlice <long>(latestRowIDs, startIndex, latestRowIDs.Count - startIndex,
sort == ERowIDSortDirection.Asc);
return(result);
}
private IEnumerable <long> GetLatestByNonIndexedField(IEnumerable <PartitionRowIDRange> partitions,
IReadTransactionContext tx, ERowIDSortDirection sort)
{
if (sort == ERowIDSortDirection.Desc)
{
return(GetLatestFromDescending(partitions, tx));
}
return(GetLatestFromDescending(partitions.Reverse(), tx).Reverse());
}
public IEnumerable <long> Execute(IJournalCore journal, IReadTransactionContext tx, ERowIDSortDirection sortDirection)
{
var intervalFilter = new PartitionIntervalIterator();
var symbolFilter = new LatestByFilter <T>(journal, _column, _keys);
return(Timestamps.AllIntervals.Reverse().SelectMany(interval =>
symbolFilter.Filter(intervalFilter.IteratePartitions(
tx.ReverseReadPartitions, interval, tx), tx, sortDirection)
));
}
private IEnumerable <long> MergeDistinct(IEnumerable <long> enum1, IEnumerable <long> enum2, ERowIDSortDirection sort)
{
if (sort != ERowIDSortDirection.Asc)
{
return(MergeDistinctDesc(enum1, enum2));
}
return(MergeDistinctAsc(enum1, enum2));
}
public IEnumerable <long> Execute(IJournalCore journal, IReadTransactionContext tx, ERowIDSortDirection sort)
{
return(MergeDistinct(_left.Execute(journal, tx, sort), _right.Execute(journal, tx, sort), sort));
}
