/// <inheritdoc/>
protected override SqlProvider VisitAggregate(AggregateProvider provider)
{
var source = Compile(provider.Source);
var sqlSelect = ExtractSqlSelect(provider, source);
var columns = ExtractColumnExpressions(sqlSelect);
var columnNames = columns.Select((c, i) =>
i >= sqlSelect.Columns.Count
? sqlSelect.From.Columns[i].Name
: sqlSelect.Columns[i].Name).ToList();
sqlSelect.Columns.Clear();
for (int i = 0; i < provider.GroupColumnIndexes.Length; i++)
{
var columnIndex = provider.GroupColumnIndexes[i];
var column = columns[columnIndex];
sqlSelect.GroupBy.Add(column);
var columnName = ProcessAliasedName(columnNames[columnIndex]);
sqlSelect.Columns.Add(column, columnName);
}
foreach (var column in provider.AggregateColumns)
{
var expression = ProcessAggregate(source, columns, column);
sqlSelect.Columns.Add(expression, column.Name);
}
return(CreateProvider(sqlSelect, provider, source));
}
public void AggregateProvider_Value_RaisesPropertyChangedOnCollectionChange()
{
var collection = new ObservableCollection <int>
{
3, 5, 7
};
int aggregationFunction(int state, int current) => current + state;
var aggregateProvider = new AggregateProvider <ObservableCollection <int>, int, int>(collection, aggregationFunction, 2);
var propertyChangedRaisedCounter = 0;
void propertyChanged(object sender, PropertyChangedEventArgs e)
{
if (e.PropertyName == nameof(aggregateProvider.Value))
{
propertyChangedRaisedCounter++;
}
}
aggregateProvider.PropertyChanged += propertyChanged;
collection.Add(11);
collection.Remove(5);
collection.Clear();
aggregateProvider.PropertyChanged -= propertyChanged;
Assert.AreEqual(3, propertyChangedRaisedCounter);
}
protected override Provider VisitAggregate(AggregateProvider provider)
{
var map = provider.AggregateColumns
.Select(c => c.SourceIndex)
.Union(provider.GroupColumnIndexes);
mappings[provider.Source] = Merge(mappings[provider], map);
var source = VisitCompilable(provider.Source);
var sourceMap = mappings[provider.Source];
var currentMap = mappings[provider];
var columns = new List <AggregateColumnDescriptor>();
for (int i = 0; i < provider.AggregateColumns.Length; i++)
{
int columnIndex = i + provider.GroupColumnIndexes.Length;
if (currentMap.BinarySearch(columnIndex) >= 0)
{
var column = provider.AggregateColumns[i];
columns.Add(new AggregateColumnDescriptor(column.Name, sourceMap.IndexOf(column.SourceIndex), column.AggregateType));
}
}
mappings[provider] = provider.Header.Columns.Select(c => c.Index).ToList();
var groupColumnIndexes = provider.GroupColumnIndexes.Select(index => sourceMap.IndexOf(index));
if (source == provider.Source)
{
return(provider);
}
return(new AggregateProvider(source, groupColumnIndexes.ToArray(), columns.ToArray()));
}
protected override Provider VisitAggregate(AggregateProvider provider)
{
var result = provider;
var source = VisitCompilable(provider.Source);
if (source != provider.Source)
{
var acds = provider.AggregateColumns
.Select(ac => new AggregateColumnDescriptor(ac.Name, ac.SourceIndex, ac.AggregateType));
result = new AggregateProvider(source, provider.GroupColumnIndexes, acds.ToArray());
}
if (sortOrder.Count > 0)
{
var selectOrdering = new DirectionCollection <int>();
foreach (var pair in sortOrder)
{
var columnIndex = result.GroupColumnIndexes.IndexOf(pair.Key);
if (columnIndex < 0)
{
if (selectOrdering.Count > 0)
{
selectOrdering.Clear();
}
break;
}
selectOrdering.Add(columnIndex, pair.Value);
}
sortOrder = selectOrdering;
}
return(result);
}
private static AggregateProvider RecreateAggregate(AggregateProvider provider,
CompilableProvider source)
{
var acd = provider.AggregateColumns.Select(
ac => new AggregateColumnDescriptor(ac.Name, ac.SourceIndex, ac.AggregateType));
return(new AggregateProvider(source, provider.GroupColumnIndexes, acd.ToArray()));
}
protected override Provider VisitAggregate(AggregateProvider provider)
{
var source = VisitCompilable(provider.Source);
var newProvider = provider;
if (source != provider.Source)
{
newProvider = RecreateAggregate(provider, source);
}
predicateCollector.ValidateAggregatedColumns(newProvider);
return(newProvider);
}
public void AggregateProvider_Value_CorrectlyComputedAfterInitialization()
{
var collection = new ObservableCollection <int>
{
3, 5, 7
};
int aggregationFunction(int state, int current) => current + state;
var aggregateProvider = new AggregateProvider <ObservableCollection <int>, int, int>(collection, aggregationFunction, 2);
Assert.AreEqual(17, aggregateProvider.Value);
}
public void AggregateProvider_Value_UpdatedAfterClearingCollection()
{
var collection = new ObservableCollection <int>
{
3, 5, 7
};
int aggregationFunction(int state, int current) => current + state;
var aggregateProvider = new AggregateProvider <ObservableCollection <int>, int, int>(collection, aggregationFunction, 2);
Assert.AreEqual(17, aggregateProvider.Value);
collection.Clear();
Assert.AreEqual(2, aggregateProvider.Value);
}
public void ValidateAggregatedColumns(AggregateProvider provider)
{
if (owner.State.Predicates.Count == 0)
{
return;
}
foreach (var parameterPair in owner.State.Predicates)
{
foreach (var predicatePair in parameterPair.Value)
{
foreach (var column in predicatePair.Second)
{
if (provider.GroupColumnIndexes.Contains(column.Index))
{
ApplyProviderCorrectorRewriter.ThrowInvalidOperationException(
Strings.ExColumnsUsedByPredicateContainingApplyParameterAreRemoved);
}
}
}
}
}
/// <summary> /// Compiles <see cref="AggregateProvider"/>. /// </summary> /// <param name="provider">Aggregate provider.</param> /// <returns></returns> protected abstract TResult VisitAggregate(AggregateProvider provider);
