Esempio n. 1
0
        public static Expression ExtractParameters(
            [NotNull] Expression expression,
            [NotNull] QueryContext queryContext,
            [NotNull] IEvaluatableExpressionFilter evaluatableExpressionFilter,
            [NotNull] ISensitiveDataLogger logger)
        {
            var visitor = new ParameterExtractingExpressionVisitor(evaluatableExpressionFilter, queryContext, logger);

            return(visitor.ExtractParameters(expression));
        }
Esempio n. 2
0
        /// <summary>
        ///     This API supports the Entity Framework Core infrastructure and is not intended to be used
        ///     directly from your code. This API may change or be removed in future releases.
        /// </summary>
        public static Expression ExtractParameters(
            [NotNull] Expression expression,
            [NotNull] QueryContext queryContext,
            [NotNull] IEvaluatableExpressionFilter evaluatableExpressionFilter,
            [NotNull] IInterceptingLogger <LoggerCategory.Query> logger,
            bool parameterize)
        {
            var visitor
                = new ParameterExtractingExpressionVisitor(
                      evaluatableExpressionFilter,
                      queryContext,
                      logger,
                      parameterize);

            return(visitor.ExtractParameters(expression));
        }
Esempio n. 3
0
        /// <summary>
        ///     This API supports the Entity Framework Core infrastructure and is not intended to be used
        ///     directly from your code. This API may change or be removed in future releases.
        /// </summary>
        protected override Expression VisitConstant(ConstantExpression constantExpression)
        {
            if (constantExpression.IsEntityQueryable())
            {
                var type       = ((IQueryable)constantExpression.Value).ElementType;
                var entityType = _queryCompilationContext.Model.FindEntityType(type)?.RootType();

                if (entityType != null)
                {
                    Expression newExpression = constantExpression;

                    if (entityType.FindPrimaryKey() == null)
                    {
                        IsKeylessQuery = true;

                        var query = entityType.GetDefiningQuery();

                        if (query != null &&
                            _entityQueryModelVisitor.ShouldApplyDefiningQuery(entityType, _querySource))
                        {
                            var parameterizedQuery
                                = _parameterExtractingExpressionVisitor.ExtractParameters(query.Body);

                            var subQueryModel = _queryModelGenerator.ParseQuery(parameterizedQuery);

                            newExpression = new SubQueryExpression(subQueryModel);
                        }
                    }

                    if (!_queryCompilationContext.IgnoreQueryFilters &&
                        entityType.GetQueryFilter() != null)
                    {
                        var parameterizedFilter
                            = (LambdaExpression)_parameterExtractingExpressionVisitor
                              .ExtractParameters(entityType.GetQueryFilter());

                        var oldParameterExpression = parameterizedFilter.Parameters[0];
                        var newParameterExpression = Expression.Parameter(type, oldParameterExpression.Name);

                        var predicateExpression
                            = ReplacingExpressionVisitor
                              .Replace(
                                  oldParameterExpression,
                                  newParameterExpression,
                                  parameterizedFilter.Body);

                        var whereExpression
                            = Expression.Call(
                                  _whereMethod.MakeGenericMethod(type),
                                  newExpression,
                                  Expression.Lambda(
                                      predicateExpression,
                                      newParameterExpression));

                        var subQueryModel = _queryModelGenerator.ParseQuery(whereExpression);

                        newExpression = new SubQueryExpression(subQueryModel);
                    }

                    return(newExpression);
                }
            }

            return(constantExpression);
        }