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));
        }
示例#3
0
 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());
 }
示例#4
0
        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()));
        }
示例#6
0
        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);
        }
示例#8
0
        public bool Equals(Matrix matrix)
        {
            if (ReferenceEquals(matrix, null))
            {
                return(false);
            }

            if (ReferenceEquals(this, matrix))
            {
                return(true);
            }

            return(CalculateProvider.IsEqual(this, matrix));
        }
示例#9
0
        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()));
        }
示例#11
0
        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));
        }
示例#12
0
 /// <summary>
 /// Compiles <see cref="CalculateProvider"/>.
 /// </summary>
 /// <param name="provider">Calculate provider.</param>
 protected abstract TResult VisitCalculate(CalculateProvider provider);
示例#13
0
 private static bool ContainsAccessToTupleField(IEnumerable <int> tupleAccesses,
                                                CalculateProvider calculateProvider, FilterProvider provider)
 {
     return(tupleAccesses.Any(i => calculateProvider.Header.Columns.Contains(provider.Header.Columns[i])));
 }