/// <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);