private CompilableProvider InsertCalculateFilter(CompilableProvider source, CalculateProvider calculateProvider) { var result = source; if (State.CalculateFilters.ContainsKey(calculateProvider)) { Expression <Func <Tuple, bool> > concatenatedPredicate = null; foreach (var filterPair in State.CalculateFilters[calculateProvider]) { var currentPredicate = (Expression <Func <Tuple, bool> >)calculateExpressionRewriter .Rewrite(filterPair.First, filterPair.First.Parameters[0], filterPair.Second, result.Header.Columns); if (concatenatedPredicate == null) { concatenatedPredicate = currentPredicate; } else { concatenatedPredicate = collectorHelper .CreatePredicatesConjunction(currentPredicate, concatenatedPredicate); } } result = new FilterProvider(result, concatenatedPredicate); State.CalculateFilters.Remove(calculateProvider); } return(result); }
/// <inheritdoc/> protected override SqlProvider VisitCalculate(CalculateProvider provider) { var source = Compile(provider.Source); SqlSelect sqlSelect; if (provider.Source.Header.Length == 0) { SqlSelect sourceSelect = source.Request.Statement; sqlSelect = sourceSelect.ShallowClone(); sqlSelect.Columns.Clear(); } else { sqlSelect = ExtractSqlSelect(provider, source); } var sourceColumns = ExtractColumnExpressions(sqlSelect); var allBindings = EnumerableUtils <QueryParameterBinding> .Empty; foreach (var column in provider.CalculatedColumns) { var result = ProcessExpression(column.Expression, sourceColumns); var predicate = result.First; var bindings = result.Second; if (column.Type.StripNullable() == typeof(bool)) { predicate = GetBooleanColumnExpression(predicate); } AddInlinableColumn(provider, column, sqlSelect, predicate); allBindings = allBindings.Concat(bindings); } return(CreateProvider(sqlSelect, allBindings, provider, source)); }
private List <ApplyParameter> FindApplyParameters(CalculateProvider newProvider) { return((from column in newProvider.CalculatedColumns let parameter = parameterSearcher.Find(column.Expression) where parameter != null select parameter).Distinct().ToList()); }
public bool TryAdd(CalculateProvider provider) { var applyParameters = FindApplyParameters(provider); if (applyParameters.Count == 0) { return(false); } if (applyParameters.Count > 1) { ApplyProviderCorrectorRewriter.ThrowInvalidOperationException(); } var applyParameter = applyParameters[0]; if (owner.State.SelfConvertibleApplyProviders[applyParameter]) { return(false); } var newPair = new Pair <CalculateProvider, ColumnCollection>(provider, provider.Header.Columns); if (owner.State.CalculateProviders.ContainsKey(applyParameter)) { owner.State.CalculateProviders[applyParameter].Add(newPair); } else { owner.State.CalculateProviders.Add(applyParameter, new List <Pair <CalculateProvider, ColumnCollection> > { newPair }); } return(true); }
private static CalculateProvider RecreateCalculate(CalculateProvider provider, CompilableProvider source) { var ccd = provider.CalculatedColumns.Select( column => new CalculatedColumnDescriptor(column.Name, column.Type, column.Expression)); return(new CalculateProvider(source, ccd.ToArray())); }
public static Matrix operator *(Matrix matrix, double number) { if (matrix == null) { throw new ArgumentNullException(nameof(matrix)); } return(CalculateProvider.Multiply(matrix, number)); }
protected override Provider VisitCalculate(CalculateProvider provider) { var source = VisitCompilable(provider.Source); var newProvider = provider; if (source != provider.Source) { newProvider = RecreateCalculate(provider, source); } return(calculateProviderCollector.TryAdd(newProvider) ? source : newProvider); }
public bool Equals(Matrix matrix) { if (ReferenceEquals(matrix, null)) { return(false); } if (ReferenceEquals(this, matrix)) { return(true); } return(CalculateProvider.IsEqual(this, matrix)); }
private void AddCalculateFilter(CalculateProvider calculateProvider, FilterProvider filterProvider) { var newPair = new Pair <Expression <Func <Tuple, bool> >, ColumnCollection>(filterProvider.Predicate, filterProvider.Header.Columns); if (owner.State.CalculateFilters.ContainsKey(calculateProvider)) { owner.State.CalculateFilters[calculateProvider].Add(newPair); } else { owner.State.CalculateFilters.Add(calculateProvider, new List <Pair <Expression <Func <Tuple, bool> >, ColumnCollection> > { newPair }); } }
protected override Provider VisitCalculate(CalculateProvider provider) { int sourceLength = provider.Source.Header.Length; var usedColumns = mappings[provider]; var sourceMapping = Merge( mappings[provider].Where(i => i < sourceLength), provider.CalculatedColumns.SelectMany(c => mappingsGatherer.Gather(c.Expression)) ); mappings[provider.Source] = sourceMapping; var newSourceProvider = VisitCompilable(provider.Source); mappings[provider] = mappings[provider.Source]; bool translated = false; var descriptors = new List <CalculatedColumnDescriptor>(provider.CalculatedColumns.Length); var currentMapping = mappings[provider]; for (int calculatedColumnIndex = 0; calculatedColumnIndex < provider.CalculatedColumns.Length; calculatedColumnIndex++) { if (usedColumns.Contains(provider.CalculatedColumns[calculatedColumnIndex].Index)) { currentMapping.Add(provider.Source.Header.Length + calculatedColumnIndex); var column = provider.CalculatedColumns[calculatedColumnIndex]; var expression = TranslateLambda(provider, column.Expression); if (expression != column.Expression) { translated = true; } var ccd = new CalculatedColumnDescriptor(column.Name, column.Type, (Expression <Func <Tuple, object> >)expression); descriptors.Add(ccd); } } mappings[provider] = currentMapping; if (descriptors.Count == 0) { return(newSourceProvider); } if (!translated && newSourceProvider == provider.Source && descriptors.Count == provider.CalculatedColumns.Length) { return(provider); } return(new CalculateProvider(newSourceProvider, descriptors.ToArray())); }
public static Matrix operator *(Matrix leftSide, Matrix rightSide) { if (leftSide == null) { throw new ArgumentNullException(nameof(leftSide)); } if (rightSide == null) { throw new ArgumentNullException(nameof(rightSide)); } if (leftSide.ColumnsCount != rightSide.RowsCount) { throw new DimensionsDontMatchException("Multiplication is impossible"); } return(CalculateProvider.Multiply(leftSide, rightSide)); }
/// <summary> /// Compiles <see cref="CalculateProvider"/>. /// </summary> /// <param name="provider">Calculate provider.</param> protected abstract TResult VisitCalculate(CalculateProvider provider);
private static bool ContainsAccessToTupleField(IEnumerable <int> tupleAccesses, CalculateProvider calculateProvider, FilterProvider provider) { return(tupleAccesses.Any(i => calculateProvider.Header.Columns.Contains(provider.Header.Columns[i]))); }