public override void VisitMainFromClause(MainFromClause fromClause, QueryModel queryModel)
 {
     Log.Trace(m => m("Original QueryModel:     {0}", queryModel));
     new AggressiveSubQueryFromClauseFlattener().VisitMainFromClause(fromClause, queryModel);
     Log.Trace(m => m("Transformed QueryModel after AggressiveSubQueryFromClauseFlattener: {0}", queryModel));
     base.VisitMainFromClause(fromClause, queryModel);
 }
        private static void ExtractQueryAnnotations(
            QueryModel queryModel, ICollection<IQueryAnnotation> queryAnnotations)
        {
            queryModel.MainFromClause
                .TransformExpressions(e =>
                    ExtractQueryAnnotations(e, queryAnnotations));

            foreach (var bodyClause in queryModel.BodyClauses)
            {
                bodyClause
                    .TransformExpressions(e =>
                        ExtractQueryAnnotations(e, queryAnnotations));
            }

            foreach (var resultOperator in queryModel.ResultOperators.ToList())
            {
                var queryAnnotation = resultOperator as IQueryAnnotation;

                if (queryAnnotation != null)
                {
                    queryAnnotations.Add(queryAnnotation);

                    queryAnnotation.QueryModel = queryModel;

                    if (queryAnnotation.QuerySource == null)
                    {
                        queryAnnotation.QuerySource = queryModel.MainFromClause;
                    }

                    queryModel.ResultOperators.Remove(resultOperator);
                }
            }
        }
        private void VisitAnyResultOperator(AnyResultOperator anyResultOperator, Remotion.Linq.QueryModel queryModel, int index)
        {
            string targetIdentifierString            = _visitor.Query.CreateIdentifier(_visitor.ItemNameOverride);
            IList <EntityConstrain> entityConstrains = null;
            StrongEntityAccessor    entityAccessor   = (from accessor in _visitor.Query.GetQueryComponentNavigator().FindAllComponents <StrongEntityAccessor>()
                                                        let constrains = accessor.Elements.OfType <EntityConstrain>()
                                                                         from constrain in constrains
                                                                         let predicate = constrain.Predicate as Literal
                                                                                         where predicate != null
                                                                                         let predicateUri = (Uri)predicate.Value
                                                                                                            let identifier = constrain.Value as Identifier
                                                                                                                             where identifier != null
                                                                                                                             let identifierString = _visitor.Query.RetrieveIdentifier(identifier.Name)
                                                                                                                                                    where (identifierString == targetIdentifierString) || ((_fromExpression != null) && (constrain.TargetExpression.EqualsTo(_fromExpression)))
                                                                                                                                                    where (entityConstrains = constrains.Where(item =>
                                                                                                                                                                                               (item.Predicate is Literal) && (((Uri)((Literal)item.Predicate).Value).AbsoluteUri == predicateUri.AbsoluteUri)).ToList()).Count > 0
                                                                                                                                                    select accessor).FirstOrDefault();

            if (entityAccessor != null)
            {
                foreach (EntityConstrain entityConstrain in entityConstrains)
                {
                    int indexOf = entityAccessor.Elements.IndexOf(entityConstrain);
                    entityAccessor.Elements.RemoveAt(indexOf);
                    OptionalPattern optional = new OptionalPattern();
                    optional.Patterns.Add(entityConstrain);
                    entityAccessor.Elements.Insert(indexOf, optional);
                }
            }

            Call call = new Call(MethodNames.Bound);

            _result = call;
        }
 public override void VisitOrderByClause(OrderByClause orderByClause, QueryModel queryModel, int index)
 {
     foreach (var ordering in orderByClause.Orderings)
     {
         model.AddSort(ordering.Expression, ordering.OrderingDirection);
     }
 }
		public static void ReWrite(QueryModel model)
		{
			// firstly, get the group join clauses
			var groupJoin = model.BodyClauses.OfType<GroupJoinClause>();

			if (!groupJoin.Any())
			{
				// No group join here..
				return;
			}

			// Now walk the tree to decide which groupings are fully aggregated (and can hence be done in hql)
			var aggregateDetectorResults = IsAggregatingGroupJoin(model, groupJoin);

			if (aggregateDetectorResults.AggregatingClauses.Count > 0)
			{
				// Re-write the select expression
				model.SelectClause.TransformExpressions(s => GroupJoinSelectClauseRewriter.ReWrite(s, aggregateDetectorResults));

				// Remove the aggregating group joins
				foreach (GroupJoinClause aggregatingGroupJoin in aggregateDetectorResults.AggregatingClauses)
				{
					model.BodyClauses.Remove(aggregatingGroupJoin);
				}
			}
		}
 protected override void FlattenSubQuery(SubQueryExpression subQueryExpression, FromClauseBase fromClause, QueryModel queryModel,
     int destinationIndex)
 {
     var subQueryModel = subQueryExpression.QueryModel;
     MoveResultOperatorsToParent(queryModel, subQueryModel);
     base.FlattenSubQuery(subQueryExpression, fromClause, queryModel, destinationIndex);
 }
        public static AdvancedSearchCriteria Generate(QueryModel model, IEktronIdProvider idProvider)
        {
            TransformationVisitor.Transform(model);
            AdvancedSearchCriteria criteria = TranslationVisitor.Translate(model, idProvider);

            return criteria;
        }
Пример #8
0
        /// <summary>
        /// Implement the skipping. We have a main limitation: we currently know only how to implement integer skipping.
        /// We implement with "if" statements to support composability, even if it means running longer in the end...
        /// We actually return nothing when goes - we aren't really a final result the way "Count" is.
        /// </summary>
        /// <param name="resultOperator"></param>
        /// <param name="queryModel"></param>
        /// <param name="_codeEnv"></param>
        /// <returns></returns>
        public void ProcessResultOperator(ResultOperatorBase resultOperator, QueryModel queryModel, IGeneratedQueryCode codeEnv, ICodeContext codeContext, CompositionContainer container)
        {
            ///
            /// Quick checks to make sure
            /// 

            if (codeEnv == null)
                throw new ArgumentNullException("codeEnv cannot be null");

            var take = resultOperator as TakeResultOperator;
            var skip = resultOperator as SkipResultOperator;

            if (take == null && skip == null)
            {
                throw new ArgumentNullException("resultOperator must not be null and must represent either a take or a skip operation!");
            }

            if (take != null && take.Count.Type != typeof(int))
                throw new ArgumentException("Take operator count must be an integer!");
            if (skip != null && skip.Count.Type != typeof(int))
                throw new ArgumentException("Skip operator count must be an integer!");

            // If this is a "global" take, then we need to declare the variable a bit specially.
            // Global: we have a limit on the number of objects that goes across events. We test this by seeing if this
            // is a sub-query that is registered (or not).
            var isGlobalTake = codeContext.IsInTopLevelQueryModel(queryModel);

            // Now, we create a count variable and that is how we will tell if we are still skipping or
            // taking. It must be declared in the current block, before our current code! :-)

            var counter = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int), otherDependencies: codeContext.LoopIndexVariable.Return<IDeclaredParameter>());
            if (isGlobalTake)
            {
                counter.DeclareAsStatic = true;
                codeEnv.Add(counter);
            } else
            {
                codeEnv.AddOutsideLoop(counter);
            }

            var comparison = StatementIfOnCount.ComparisonOperator.LessThanEqual;
            IValue limit = null;
            if (skip != null)
            {
                comparison = StatementIfOnCount.ComparisonOperator.GreaterThan;
                limit = ExpressionToCPP.GetExpression(skip.Count, codeEnv, codeContext, container);
            }
            else
            {
                limit = ExpressionToCPP.GetExpression(take.Count, codeEnv, codeContext, container);
            }

            codeEnv.Add(new StatementIfOnCount(counter, limit, comparison));

            ///
            /// We are particularly fortunate here. We don't have to update the Loop variable - whatever it is, is
            /// still the right one! Normally we'd have to futz with the LoopVariable in code context because we
            /// were iterating over something new. :-) Easy!
            /// 
        }
        protected override QueryModel ApplyNodeSpecificSemantics(QueryModel queryModel,
            ClauseGenerationContext clauseGenerationContext)
        {
            queryModel.BodyClauses.Add(new UseKeysClause(Keys));

            return queryModel;
        }
Пример #10
0
        public override void VisitJoinClause(JoinClause joinClause, QueryModel queryModel, int index)
        {
            var subQueryExpression = joinClause.InnerSequence as SubQueryExpression;

            if (subQueryExpression != null)
            {
                VisitQueryModel(subQueryExpression.QueryModel);

                if (subQueryExpression.QueryModel.IsIdentityQuery()
                    && !subQueryExpression.QueryModel.ResultOperators.Any())
                {
                    joinClause.InnerSequence
                        = subQueryExpression.QueryModel.MainFromClause.FromExpression;

                    foreach (var queryAnnotation
                        in _queryAnnotations
                            .Where(qa => qa.QuerySource == subQueryExpression.QueryModel.MainFromClause))
                    {
                        queryAnnotation.QuerySource = joinClause;
                    }
                }
            }

            base.VisitJoinClause(joinClause, queryModel, index);
        }
Пример #11
0
        public virtual T ExecuteSingle <T>(Remotion.Linq.QueryModel queryModel, bool returnDefaultWhenEmpty)
        {
            var executeSingle = QueryableDataSource.ExecuteSingle <T>((GetQueryDescription(queryModel)), _binder);

            return(executeSingle);
            // return returnDefaultWhenEmpty ? ExecuteCollection<T>(queryModel).SingleOrDefault() : ExecuteCollection<T>(queryModel).Single();
        }
Пример #12
0
 public override void VisitWhereClause(WhereClause whereClause, QueryModel queryModel, int index)
 {
     WhereJoinDetector.Find(whereClause.Predicate,_nameGenerator,
                                       this,
                                       _joins,
                                       _expressionMap);
 }
        private static void ExtractQueryAnnotations(
            QueryModel queryModel, ICollection<QueryAnnotationBase> queryAnnotations)
        {
            foreach (var resultOperator
                in queryModel.ResultOperators
                    .OfType<QueryAnnotationResultOperator>()
                    .ToList())
            {
                resultOperator.Annotation.QueryModel = queryModel;
                resultOperator.Annotation.QuerySource = queryModel.MainFromClause;
                queryAnnotations.Add(resultOperator.Annotation);
                queryModel.ResultOperators.Remove(resultOperator);
            }

            queryModel.MainFromClause
                .TransformExpressions(e =>
                    ExtractQueryAnnotations(e, queryAnnotations));

            foreach (var bodyClause in queryModel.BodyClauses)
            {
                bodyClause
                    .TransformExpressions(e =>
                        ExtractQueryAnnotations(e, queryAnnotations));
            }
        }
Пример #14
0
        public static IWhereFragment SimpleArrayContains(ISerializer serializer, QueryModel queryModel, ContainsResultOperator contains)
        {
            var from = queryModel.MainFromClause.FromExpression;
            var visitor = new FindMembers();
            visitor.Visit(from);

            var members = visitor.Members;

            var constant = contains.Item as ConstantExpression;

            if (constant != null)
            {
                var array = Array.CreateInstance(constant.Type, 1);
                array.SetValue(constant.Value, 0);

                var dict = new Dictionary<string, object>();
                dict.Add(members.Last().Name, array);

                members.Reverse().Skip(1).Each(m =>
                {
                    dict = new Dictionary<string, object>() { {m.Name, dict} };
                });

                return new ContainmentWhereFragment(serializer, dict);
            }

            throw new NotSupportedException();
        }
		private void FlattenSubQuery(SubQueryExpression subQueryExpression, QueryModel queryModel)
		{
			// Create a new client-side select for the outer
			// TODO - don't like calling GetGenericArguments here...
			var clientSideSelect = new ClientSideSelect(
				new NonAggregatingGroupBySelectRewriter()
					.Visit(queryModel.SelectClause.Selector, subQueryExpression.Type.GetGenericArguments()[0], queryModel.MainFromClause));

			// Replace the outer select clause...
			queryModel.SelectClause = subQueryExpression.QueryModel.SelectClause;

			// Replace the outer from clause...
			queryModel.MainFromClause = subQueryExpression.QueryModel.MainFromClause;

			foreach (var bodyClause in subQueryExpression.QueryModel.BodyClauses)
			{
				queryModel.BodyClauses.Add(bodyClause);
			}

			// Move the result operator up 
			if (queryModel.ResultOperators.Count != 0)
			{
				throw new NotImplementedException();
			}

			queryModel.ResultOperators.Add(new NonAggregatingGroupBy((GroupResultOperator)subQueryExpression.QueryModel.ResultOperators[0]));
			queryModel.ResultOperators.Add(clientSideSelect);
		}
        /// <summary>Visits a select clause.</summary>
        /// <param name="selectClause">Select clause to be visited.</param>
        /// <param name="queryModel">Query model containing given select clause.</param>
        public override void VisitSelectClause(SelectClause selectClause, Remotion.Linq.QueryModel queryModel)
        {
            queryModel.MainFromClause.Accept(this, queryModel);
            QuerySourceReferenceExpression querySource = FindQuerySource(selectClause.Selector);

            _visitor.Visit(selectClause.Selector);
            QueryComponent component = _visitor.RetrieveComponent();

            _query             = _visitor.Query;
            _mainFromComponent = _query.FindAllComponents <StrongEntityAccessor>().Where(item => item.SourceExpression == querySource.ReferencedQuerySource).First();
            if (_query.Subject == null)
            {
                _query.Subject = _mainFromComponent.About;
                UnboundConstrain genericConstrain = new UnboundConstrain(new Identifier("s"), new Identifier("p"), new Identifier("o"), _mainFromComponent.SourceExpression.FromExpression);
                _mainFromComponent.Elements.Insert(0, genericConstrain);
                _mainFromComponent.UnboundGraphName = null;
                _query.Select.Add(genericConstrain);
            }

            _subject = _query.Subject;
            _query.Select.Add(_mainFromComponent);
            VisitBodyClauses(queryModel.BodyClauses, queryModel);
            VisitResultOperators(queryModel.ResultOperators, queryModel);
            OverrideSelector(component, selectClause.Selector);
        }
Пример #17
0
        /// <summary>
        /// Visits the main from clause.
        /// </summary>
        /// <param name="fromClause">From clause.</param>
        /// <param name="queryModel">The query model.</param>
        /// <remarks></remarks>
        public override void VisitMainFromClause(MainFromClause fromClause, Remotion.Linq.QueryModel queryModel)
        {
            var sourceAsConstant = queryModel.MainFromClause.FromExpression as ConstantExpression;

            if (sourceAsConstant != null)
            {
                _queryDescription.SetFromClause("", HierarchyScope.AllOrNone, FromClause.RevisionStatusNotSpecifiedType);
                // Tues 1 Nov: _queryDescription.SetResultFilterClause(fromClause.ItemType, ResultFilterType.Sequence, -1);
                _queryDescription.SetResultFilterClause(GetResultType(fromClause, queryModel), ResultFilterType.Sequence, -1);

                RunCustomModifiers(queryModel);
            }

            var sourceAsSubQuery = fromClause.FromExpression as SubQueryExpression;

            if (sourceAsSubQuery != null)
            {
                var subQueryModel = sourceAsSubQuery.QueryModel;
                RunCustomModifiers(subQueryModel);
            }

            // If the Where clause is null, we have a request for "get all", but the VisitWhereClause method never runs (thanks Remotion!)
            // so let's fake it here
            if (!queryModel.BodyClauses.Any())
            {
                queryModel.BodyClauses.Add(new WhereClause(Expression.Equal(IgnoreExpression, IgnoreExpression)));
            }

            base.VisitMainFromClause(fromClause, queryModel);
        }
Пример #18
0
        /// <summary>
        /// Actually try and process this! The count consisits of a count integer and something to increment it
        /// at its current spot.
        /// </summary>
        /// <param name="resultOperator"></param>
        /// <param name="queryModel"></param>
        /// <param name="codeEnv"></param>
        /// <returns></returns>
        public Expression ProcessResultOperator(ResultOperatorBase resultOperator, QueryModel queryModel, IGeneratedQueryCode gc, ICodeContext cc, CompositionContainer container)
        {
            if (gc == null)
                throw new ArgumentNullException("CodeEnv must not be null!");

            var c = resultOperator as CountResultOperator;
            if (c == null)
                throw new ArgumentNullException("resultOperator can only be a CountResultOperator and must not be null");

            //
            // The accumulator where we will store the result.
            //

            var accumulator = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
            accumulator.SetInitialValue("0");

            //
            // Use the Aggregate infrasturcutre to do the adding. This
            // has the advantage that it will correctly combine with
            // similar statements during query optimization.
            //

            var add = Expression.Add(accumulator, Expression.Constant((int)1));
            var addResolved = ExpressionToCPP.GetExpression(add, gc, cc, container);

            gc.Add(new StatementAggregate(accumulator, addResolved));
            return accumulator;
        }
            /// <summary>
            /// Look at all the result operators. The Concat operators can affect what happens before and after their
            /// position in the RO list. So we have to look at it as a collection, rather than individually.
            /// </summary>
            /// <param name="resultOperators"></param>
            /// <param name="queryModel"></param>
            protected override void VisitResultOperators(ObservableCollection<ResultOperatorBase> resultOperators, QueryModel queryModel)
            {
                // First, visit each individual result operator.
                for (int i = 0; i < queryModel.ResultOperators.Count; i++)
                {
                    var ro = queryModel.ResultOperators[i];
                    _seenConcat = _seenConcat || (ro is ConcatResultOperator);
                    if (_seenConcat && (ro is TakeResultOperator || ro is SkipResultOperator))
                    {
                        throw new NotSupportedException("A top level Take or Skip operator is not supported after using Concat of two streams. To pull a number of objects from each stream and add them, use TakePerSource or SkipPerSource.");
                    }
                    
                    // If the operator is the special kind of take or skip, then we should replace it with a normal take or skip
                    // as the user has, effectively, told us they know what they are doing.

                    if (ro is TakeSkipResultOperator)
                    {
                        var ts = ro as TakeSkipResultOperator;
                        if (ts.IsTake)
                        {
                            queryModel.ResultOperators[i] = new TakeResultOperator(ts.Count);
                        } else
                        {
                            queryModel.ResultOperators[i] = new SkipResultOperator(ts.Count);
                        }
                        ro = queryModel.ResultOperators[i];
                    }

                    // Now visit the particular result operator.
                    VisitResultOperator(ro, queryModel, i);
                }

                _allModels.AddRange(SplitQMByConcatResultOperator(queryModel));
            }
		public override void VisitQueryModel(QueryModel queryModel)
		{
			queryModel.MainFromClause.Accept(this, queryModel);
			VisitBodyClauses(queryModel.BodyClauses, queryModel);
			VisitResultOperators(queryModel.ResultOperators, queryModel);
			queryModel.SelectClause.Accept(this, queryModel);
		}
		public override void VisitMainFromClause(MainFromClause fromClause, QueryModel queryModel)
		{
			var subQueryExpression = fromClause.FromExpression as SubQueryExpression;
			if (subQueryExpression != null)
				FlattenSubQuery(subQueryExpression, fromClause, queryModel, 0);
			base.VisitMainFromClause(fromClause, queryModel);
		}
Пример #22
0
        private void FlattenSubQuery(SubQueryExpression subQueryExpression, FromClauseBase fromClause,
		                             QueryModel queryModel)
        {
            // Move the result operator up
            if (queryModel.ResultOperators.Count != 0)
            {
                throw new NotImplementedException();
            }

            var groupBy = (GroupResultOperator) subQueryExpression.QueryModel.ResultOperators[0];

            // Replace the outer select clause...
            queryModel.SelectClause.TransformExpressions(s => GroupBySelectClauseRewriter.ReWrite(s, groupBy, subQueryExpression.QueryModel));

            queryModel.SelectClause.TransformExpressions(
                s =>
                new SwapQuerySourceVisitor(queryModel.MainFromClause, subQueryExpression.QueryModel.MainFromClause).Swap
                    (s));

            MainFromClause innerMainFromClause = subQueryExpression.QueryModel.MainFromClause;
            CopyFromClauseData(innerMainFromClause, fromClause);

            foreach (var bodyClause in subQueryExpression.QueryModel.BodyClauses)
            {
                queryModel.BodyClauses.Add(bodyClause);
            }

            queryModel.ResultOperators.Add(groupBy);
        }
        public virtual void VisitGroupJoinClause(GroupJoinClause groupJoinClause, QueryModel queryModel, int index)
        {
            ArgumentUtility.CheckNotNull ("groupJoinClause", groupJoinClause);
              ArgumentUtility.CheckNotNull ("queryModel", queryModel);

              groupJoinClause.JoinClause.Accept (this, queryModel, groupJoinClause);
        }
        public virtual void VisitAdditionalFromClause(AdditionalFromClause fromClause, QueryModel queryModel, int index)
        {
            ArgumentUtility.CheckNotNull ("fromClause", fromClause);
              ArgumentUtility.CheckNotNull ("queryModel", queryModel);

              // nothing to do here
        }
        protected override QueryModel ApplyNodeSpecificSemantics(QueryModel queryModel,
            ClauseGenerationContext clauseGenerationContext)
        {
            queryModel.BodyClauses.Add(new WhereMissingClause(GetResolvedPredicate(clauseGenerationContext)));

            return queryModel;
        }
        public virtual void VisitJoinClause(JoinClause joinClause, QueryModel queryModel, int index)
        {
            ArgumentUtility.CheckNotNull ("joinClause", joinClause);
              ArgumentUtility.CheckNotNull ("queryModel", queryModel);

              // nothing to do here
        }
        public static void TransformQueryModel(QueryModel queryModel)
        {
            var instance = new QueryModelTransformer();

            queryModel.Accept(instance);

        }
 public override void VisitWhereClause(WhereClause whereClause, QueryModel queryModel, int index)
 {
     var visitor = new QueryBuildingExpressionTreeVisitor(context, fieldMappingInfoProvider);
     visitor.VisitExpression(whereClause.Predicate);
     
     model.AddQuery(visitor.Query);
 }
		public override void VisitAdditionalFromClause(AdditionalFromClause fromClause, QueryModel queryModel, int index)
		{
			var subQueryExpression = fromClause.FromExpression as SubQueryExpression;
			if (subQueryExpression != null)
				FlattenSubQuery(subQueryExpression, fromClause, queryModel, index + 1);
			base.VisitAdditionalFromClause(fromClause, queryModel, index);
		}
		private static void FlattenSubQuery(SubQueryExpression subQueryExpression, QueryModel queryModel)
		{
			// Create a new client-side select for the outer
			var clientSideSelect = CreateClientSideSelect(subQueryExpression, queryModel);

			var subQueryModel = subQueryExpression.QueryModel;

			// Replace the outer select clause...
			queryModel.SelectClause = subQueryModel.SelectClause;

			// Replace the outer from clause...
			queryModel.MainFromClause = subQueryModel.MainFromClause;

			foreach (var bodyClause in subQueryModel.BodyClauses)
			{
				queryModel.BodyClauses.Add(bodyClause);
			}

			// Move the result operator up 
			if (queryModel.ResultOperators.Count != 0)
			{
				throw new NotImplementedException();
			}

			queryModel.ResultOperators.Add(new NonAggregatingGroupBy((GroupResultOperator) subQueryModel.ResultOperators[0]));
			queryModel.ResultOperators.Add(clientSideSelect);
		}
        private static void ExtractQueryAnnotations(
            QueryModel queryModel, ICollection<QueryAnnotationBase> queryAnnotations)
        {
            foreach (var resultOperator
                in queryModel.ResultOperators
                    .OfType<QueryAnnotationResultOperator>()
                    .ToList())
            {
                resultOperator.Annotation.QueryModel = queryModel;

                var includeAnnotation = resultOperator.Annotation as IncludeQueryAnnotation;
                resultOperator.Annotation.QuerySource = includeAnnotation != null
                    ? ExtractSourceReferenceExpression(includeAnnotation.NavigationPropertyPath).ReferencedQuerySource
                    : queryModel.MainFromClause;

                queryAnnotations.Add(resultOperator.Annotation);
                queryModel.ResultOperators.Remove(resultOperator);
            }

            queryModel.MainFromClause
                .TransformExpressions(e =>
                    ExtractQueryAnnotations(e, queryAnnotations));

            foreach (var bodyClause in queryModel.BodyClauses)
            {
                bodyClause
                    .TransformExpressions(e =>
                        ExtractQueryAnnotations(e, queryAnnotations));
            }
        }
Пример #32
0
		public override void VisitAdditionalFromClause(AdditionalFromClause fromClause, QueryModel queryModel, int index)
		{
			var subQuery = fromClause.FromExpression as SubQueryExpression;
			if (subQuery == null)
				return;

			var subQueryModel = subQuery.QueryModel;
			if (!IsLeftJoin(subQueryModel))
				return;

			var mainFromClause = subQueryModel.MainFromClause;

			var restrictions = subQueryModel.BodyClauses
				.OfType<WhereClause>()
				.Select(w => new NhWithClause(w.Predicate));

			var join = new NhJoinClause(mainFromClause.ItemName,
										mainFromClause.ItemType,
										mainFromClause.FromExpression,
										restrictions);

			var innerSelectorMapping = new QuerySourceMapping();
			innerSelectorMapping.AddMapping(fromClause, subQueryModel.SelectClause.Selector);

			queryModel.TransformExpressions(ex => ReferenceReplacingExpressionTreeVisitor.ReplaceClauseReferences(ex, innerSelectorMapping, false));

			queryModel.BodyClauses.RemoveAt(index);
			queryModel.BodyClauses.Insert(index, @join);
			InsertBodyClauses(subQueryModel.BodyClauses.Where(b => !(b is WhereClause)), queryModel, index + 1);

			var innerBodyClauseMapping = new QuerySourceMapping();
			innerBodyClauseMapping.AddMapping(mainFromClause, new QuerySourceReferenceExpression(@join));

			queryModel.TransformExpressions(ex => ReferenceReplacingExpressionTreeVisitor.ReplaceClauseReferences(ex, innerBodyClauseMapping, false));
		}
        public virtual void VisitMainFromClause(MainFromClause fromClause, QueryModel queryModel)
        {
            ArgumentUtility.CheckNotNull ("fromClause", fromClause);
              ArgumentUtility.CheckNotNull ("queryModel", queryModel);

              // nothing to do here
        }
        public virtual void VisitOrderByClause(OrderByClause orderByClause, QueryModel queryModel, int index)
        {
            ArgumentUtility.CheckNotNull ("orderByClause", orderByClause);
              ArgumentUtility.CheckNotNull ("queryModel", queryModel);

              VisitOrderings (orderByClause.Orderings, queryModel, orderByClause);
        }
Пример #35
0
        /// <summary>
        /// Visits the result operator.
        /// </summary>
        /// <param name="resultOperator">The result operator.</param>
        /// <param name="queryModel">The query model.</param>
        /// <param name="index">The index.</param>
        /// <remarks></remarks>
        public override void VisitResultOperator(ResultOperatorBase resultOperator, Remotion.Linq.QueryModel queryModel, int index)
        {
            if (typeof(CountResultOperator).IsAssignableFrom(resultOperator.GetType()))
            {
                _queryDescription.SetResultFilterClause(queryModel.MainFromClause.ItemType, ResultFilterType.Count, 0);
            }

            if (typeof(SingleResultOperator).IsAssignableFrom(resultOperator.GetType()))
            {
                var op     = resultOperator as SingleResultOperator;
                var filter = op.ReturnDefaultWhenEmpty ? ResultFilterType.SingleOrDefault : ResultFilterType.Single;
                _queryDescription.SetResultFilterClause(queryModel.MainFromClause.ItemType, filter, 0);
            }

            if (typeof(TakeResultOperator).IsAssignableFrom(resultOperator.GetType()))
            {
                var firstResultOperator = resultOperator as TakeResultOperator;
                var countExpression     = firstResultOperator.Count as ConstantExpression;
                var count = Convert.ToInt32(countExpression.Value);
                _queryDescription.SetResultFilterClause(queryModel.MainFromClause.ItemType, ResultFilterType.Take, count);
            }

            var skipResultOp = resultOperator as SkipResultOperator;

            if (skipResultOp != null)
            {
                var countExpression = skipResultOp.Count as ConstantExpression;
                var count           = Convert.ToInt32(countExpression.Value);
                _queryDescription.SetResultFilterClause(queryModel.MainFromClause.ItemType, ResultFilterType.Skip, count);
            }

            if (resultOperator is AnyResultOperator)
            {
                _queryDescription.SetResultFilterClause(queryModel.MainFromClause.ItemType, ResultFilterType.Any, 0);
            }

            var allResultOp = resultOperator as AllResultOperator;

            if (allResultOp != null)
            {
                var criteriaExpression = this.GetCriteriaExpression(queryModel, allResultOp.Predicate);
                _queryDescription.SetCriteria(criteriaExpression);
                _queryDescription.SetResultFilterClause(queryModel.MainFromClause.ItemType, ResultFilterType.All, 0);
            }

            var firstResultOp = resultOperator as FirstResultOperator;

            if (firstResultOp != null)
            {
                this._queryDescription.SetResultFilterClause(
                    queryModel.MainFromClause.ItemType,
                    firstResultOp.ReturnDefaultWhenEmpty ? ResultFilterType.FirstOrDefault : ResultFilterType.First,
                    0);
            }

            base.VisitResultOperator(resultOperator, queryModel, index);
        }
Пример #36
0
        /// <summary>
        /// Visits the where clause.
        /// </summary>
        /// <param name="whereClause">The where clause.</param>
        /// <param name="queryModel">The query model.</param>
        /// <param name="index">The index.</param>
        /// <remarks></remarks>
        public override void VisitWhereClause(WhereClause whereClause, Remotion.Linq.QueryModel queryModel, int index)
        {
            var wherePredicate = whereClause.Predicate;

            var criteriaExpression = this.GetCriteriaExpression(queryModel, wherePredicate);

            _queryDescription.SetCriteria(criteriaExpression);
            base.VisitWhereClause(whereClause, queryModel, index);
        }
        private void VisitTakeResultOperator(TakeResultOperator takeResultOperation, Remotion.Linq.QueryModel queryModel, int index)
        {
            if (!(takeResultOperation.Count is System.Linq.Expressions.ConstantExpression))
            {
                throw new InvalidOperationException("Only constant expressions are supported for the Take operators.");
            }

            _query.Limit = Convert.ToInt32(((System.Linq.Expressions.ConstantExpression)takeResultOperation.Count).Value);
        }
Пример #38
0
        /// <summary>
        /// Visits the <paramref name="queryModel"/> and generates a <see cref="QueryDescription"/>.
        /// </summary>
        /// <param name="queryModel">The query model.</param>
        /// <returns></returns>
        /// <remarks></remarks>
        public QueryDescription VisitAndGenerateQueryDescription(Remotion.Linq.QueryModel queryModel)
        {
            // Reset description builder
            _queryDescription = new QueryDescriptionBuilder();

            VisitQueryModel(queryModel);

            return(_queryDescription);
        }
        /// <summary>Visits a where clause.</summary>
        /// <param name="whereClause">Where clause to be visited.</param>
        /// <param name="queryModel">Query model containing given from clause.</param>
        /// <param name="index">Index of the where clause in the query model.</param>
        public override void VisitWhereClause(WhereClause whereClause, Remotion.Linq.QueryModel queryModel, int index)
        {
            _visitor.Visit(whereClause.Predicate);
            QueryComponent queryComponent = _visitor.RetrieveComponent();

            if (queryComponent != null)
            {
                _bodies.Add(queryComponent);
            }

            base.VisitWhereClause(whereClause, queryModel, index);
        }
Пример #40
0
        /// <summary>
        /// Save a query model result for later lookup.
        /// </summary>
        /// <param name="queryModel"></param>
        /// <param name="result"></param>
        /// <returns></returns>
        /// <remarks>Cache any QueryReferences that have been looked up in addtion to the result so we know when to
        /// invalidate this.</remarks>
        public IVariableScopeHolder Add(Remotion.Linq.QueryModel queryModel, Expression result)
        {
            var scope = new CQReplacementExpression(this, queryModel, _queryModelCache.ContainsKey(queryModel) ? _queryModelCache[queryModel] : null);
            var v     = new QueryModelCacheLine()
            {
                _value = result, _referencedQS = _QSReferencedSet.ToArray()
            };

            _QSReferencedSet.Clear();
            AddInternal(queryModel, v);
            return(scope);
        }
 private void VisitAnyResultOperator(AnyResultOperator anyResultOperator, Remotion.Linq.QueryModel queryModel, int index)
 {
     if (_query.IsSubQuery)
     {
         Call call = new Call(MethodNames.Any);
         call.Arguments.Add(_query);
         _result = call;
     }
     else
     {
         _query.QueryForm = QueryForms.Ask;
     }
 }
        /// <summary>Visits a where clause.</summary>
        /// <param name="whereClause">Where clause to be visited.</param>
        /// <param name="queryModel">Query model containing given from clause.</param>
        /// <param name="index">Index of the where clause in the query model.</param>
        public override void VisitWhereClause(WhereClause whereClause, Remotion.Linq.QueryModel queryModel, int index)
        {
            _visitor.ConstantFromClause = _auxFromComponent;
            _visitor.Visit(whereClause.Predicate);
            QueryComponent           queryComponent          = _visitor.RetrieveComponent();
            IQueryComponentNavigator queryComponentNavigator = queryComponent.GetQueryComponentNavigator();

            if (queryComponentNavigator != null)
            {
                queryComponentNavigator.ReplaceComponent(Identifier.Current, _subject);
            }

            if (queryComponent is QueryElement)
            {
                if ((!(queryComponent is EntityConstrain)) && (!_query.Elements.Contains((QueryElement)queryComponent)))
                {
                    _query.Elements.Add((QueryElement)queryComponent);
                }
            }
            else if (!_query.FindAllComponents <Filter>().Any(item => item.Expression == queryComponent))
            {
                Filter filter = new Filter((IExpression)queryComponent);
                StrongEntityAccessor targetEntityAccessor = null;
                if ((_subject != _mainFromComponent.About) && (queryComponentNavigator.Contains(_subject)))
                {
                    targetEntityAccessor = (from entityAccessor in _query.FindAllComponents <StrongEntityAccessor>()
                                            from constrain in entityAccessor.FindAllComponents <EntityConstrain>()
                                            where (constrain.GetType() == typeof(EntityConstrain)) && (_subject.Equals(constrain.Value))
                                            select entityAccessor).FirstOrDefault();
                }

                if (targetEntityAccessor == null)
                {
                    IEnumerable <StrongEntityAccessor> targetEntityAccessorExression = _query.Elements.OfType <StrongEntityAccessor>();
                    if ((_query.IsSubQuery) || (whereClause.Predicate is Remotion.Linq.Clauses.Expressions.SubQueryExpression))
                    {
                        targetEntityAccessorExression = targetEntityAccessorExression.Except(new StrongEntityAccessor[] { _query.Elements.OfType <StrongEntityAccessor>().LastOrDefault() });
                    }

                    targetEntityAccessor = targetEntityAccessorExression.LastOrDefault() ?? _mainFromComponent;
                }

                if ((!targetEntityAccessor.Elements.Contains(queryComponent)) && (!targetEntityAccessor.Elements.Contains(filter)))
                {
                    targetEntityAccessor.Elements.Add(filter);
                }
            }

            _auxFromComponent = null;
            base.VisitWhereClause(whereClause, queryModel, index);
        }
Пример #43
0
        private static Type GetResultType(MainFromClause fromClause, Remotion.Linq.QueryModel queryModel)
        {
            var resultTypeOverride = queryModel.ResultTypeOverride;

            if (typeof(IQueryable).IsAssignableFrom(resultTypeOverride))
            {
                var genericArguments = resultTypeOverride.GetGenericArguments();
                if (genericArguments.Any())
                {
                    return(genericArguments.FirstOrDefault());
                }
            }
            return(resultTypeOverride ?? fromClause.ItemType);
        }
        /// <summary>Visits a result operator.</summary>
        /// <param name="resultOperator">Result operator to be visited.</param>
        /// <param name="queryModel">Query model containing given from clause.</param>
        /// <param name="index">Index of the visited result operator in the result operators collection.</param>
        public override void VisitResultOperator(ResultOperatorBase resultOperator, Remotion.Linq.QueryModel queryModel, int index)
        {
            MethodInfo visitResultOperatorMethod = GetType().GetMethod("Visit" + resultOperator.GetType().Name, BindingFlags.Instance | BindingFlags.NonPublic);

            if (visitResultOperatorMethod != null)
            {
                visitResultOperatorMethod.Invoke(this, new object[] { resultOperator, queryModel, index });
            }
            else
            {
                throw new NotSupportedException(System.String.Format("Expressions of type '{0}' are not supported.", resultOperator.GetType().Name.Replace("ResultOperator", System.String.Empty)));
            }

            base.VisitResultOperator(resultOperator, queryModel, index);
        }
        /// <summary>Visits a main from clause.</summary>
        /// <param name="fromClause">Main from clause to be visited.</param>
        /// <param name="queryModel">Query model containing given from clause.</param>
        public override void VisitMainFromClause(MainFromClause fromClause, Remotion.Linq.QueryModel queryModel)
        {
            VisitQuerableFromClause(fromClause, queryModel, -1);
            if (fromClause.FromExpression is System.Linq.Expressions.MemberExpression)
            {
                System.Linq.Expressions.MemberExpression memberExpression = (System.Linq.Expressions.MemberExpression)fromClause.FromExpression;
                if (memberExpression.Member is PropertyInfo)
                {
                    _visitor.Visit(memberExpression.Expression);
                    _visitor.Visit(memberExpression);
                }
            }

            base.VisitMainFromClause(fromClause, queryModel);
        }
Пример #46
0
        /// <summary>
        /// Visits the <paramref name="queryModel"/> and generates a <see cref="QueryDescription"/>.
        /// </summary>
        /// <param name="queryModel">The query model.</param>
        /// <returns></returns>
        /// <remarks></remarks>
        public QueryDescription VisitAndGenerateQueryDescription(Remotion.Linq.QueryModel queryModel)
        {
            // Reset description builder
            _queryDescription = new QueryDescriptionBuilder();

            VisitQueryModel(queryModel);

            // If we haven't found any result operators then add one just saying sequence
            if (!_queryDescription.ResultFilters.Any())
            {
                _queryDescription.AddResultFilter(GetResultType(queryModel), ResultFilterType.Sequence, -1);
            }

            return(_queryDescription);
        }
 /// <summary>Visits a from clause.</summary>
 /// <param name="fromClause">From clause to be visited.</param>
 /// <param name="queryModel">Query model containing given from clause.</param>
 /// <param name="index">Index of the where clause in the query model. In case of the main from clause this value is -1.</param>
 protected virtual void VisitQuerableFromClause(FromClauseBase fromClause, Remotion.Linq.QueryModel queryModel, int index)
 {
     if (typeof(IQueryable).IsAssignableFrom(fromClause.FromExpression.Type))
     {
         if ((fromClause.FromExpression.Type.GetGenericArguments().Length > 0) && (fromClause.FromExpression.Type.GetGenericArguments()[0] != typeof(IEntity)))
         {
             StrongEntityAccessor entityAccessor = this.GetEntityAccessor(fromClause);
             if (_mainFromComponent == null)
             {
                 _query.Elements.Add(_mainFromComponent = entityAccessor);
             }
         }
     }
     else
     {
         _visitor.Visit(fromClause.FromExpression);
     }
 }
Пример #48
0
        /// <summary>
        /// Creates a new <see cref="QueryModelVisitor"/>, and returns the result of running <see cref="QueryModelVisitor.VisitAndGenerateQueryDescription"/> on the
        /// supplied <paramref name="queryModel"/>.
        /// </summary>
        /// <param name="queryModel">The query model.</param>
        /// <returns></returns>
        /// <remarks></remarks>
        public static QueryDescription FromQueryModel(Remotion.Linq.QueryModel queryModel)
        {
            Func <AbstractQueryStructureBinder> generateBinder = () =>
            {
                var resultType            = queryModel.MainFromClause.ItemType;
                var structureBinderAttrib =
                    resultType.GetCustomAttributes(typeof(QueryStructureBinderOfTypeAttribute),
                                                   true).OfType <QueryStructureBinderOfTypeAttribute>().FirstOrDefault();

                if (structureBinderAttrib == null)
                {
                    return(new DefaultQueryStructureBinder());
                }

                return(Activator.CreateInstance(structureBinderAttrib.StructureBinder) as AbstractQueryStructureBinder);
            };

            var defaultQueryStructureBinder = generateBinder.Invoke();

            return(FromQueryModel(queryModel, defaultQueryStructureBinder, new DefaultExpressionTreeVisitor(defaultQueryStructureBinder)));
        }
Пример #49
0
        /// <summary>
        /// Visits the main from clause.
        /// </summary>
        /// <param name="fromClause">From clause.</param>
        /// <param name="queryModel">The query model.</param>
        /// <remarks></remarks>
        public override void VisitMainFromClause(MainFromClause fromClause, Remotion.Linq.QueryModel queryModel)
        {
            var sourceAsConstant = queryModel.MainFromClause.FromExpression as ConstantExpression;

            if (sourceAsConstant != null)
            {
                _queryDescription.SetFromClause(HierarchyScope.Indeterminate, FromClause.RevisionStatusNotSpecifiedType);
                // Tues 1 Nov: _queryDescription.SetResultFilterClause(fromClause.ItemType, ResultFilterType.Sequence, -1);
                //_queryDescription.AddResultFilter(GetResultType(fromClause, queryModel), ResultFilterType.Sequence, -1);
            }
            RunCustomModifiers(queryModel);

            var sourceAsSubQuery = fromClause.FromExpression as SubQueryExpression;

            if (sourceAsSubQuery != null)
            {
                var subQueryModel = sourceAsSubQuery.QueryModel;
                RunCustomModifiers(subQueryModel);

                // When there is a query like "MyList.Skip(5).Count()" then "MyList.Skip(5)" is the MainFromClause
                // and it's represented as a SubQuery, with "Count()" being the single ResultOperator on the outer query
                // Since for our purposes we flatten this all because we don't support subqueries, then
                // go and visit the ResultOperators of the inner query to add them to our single QueryDescription's
                // ResultFilters list to make sure we catch both Skip and Count in this example.
                for (int index = 0; index < subQueryModel.ResultOperators.Count; index++)
                {
                    var resultOperator = subQueryModel.ResultOperators[index];
                    VisitResultOperator(resultOperator, sourceAsSubQuery.QueryModel, index);
                }
            }

            // If the Where clause is null, we have a request for "get all", but the VisitWhereClause method never runs (thanks Remotion!)
            // so let's fake it here
            if (!queryModel.BodyClauses.Any())
            {
                queryModel.BodyClauses.Add(new WhereClause(Expression.Equal(IgnoreExpression, IgnoreExpression)));
            }

            base.VisitMainFromClause(fromClause, queryModel);
        }
Пример #50
0
 public virtual T ExecuteScalar <T>(Remotion.Linq.QueryModel queryModel)
 {
     return(QueryableDataSource.ExecuteScalar <T>(GetQueryDescription(queryModel), _binder));
 }
Пример #51
0
 /// <summary>
 /// Visits the additional from clause.
 /// </summary>
 /// <param name="fromClause">From clause.</param>
 /// <param name="queryModel">The query model.</param>
 /// <param name="index">The index.</param>
 /// <remarks></remarks>
 public override void VisitAdditionalFromClause(AdditionalFromClause fromClause, Remotion.Linq.QueryModel queryModel, int index)
 {
     base.VisitAdditionalFromClause(fromClause, queryModel, index);
 }
Пример #52
0
 /// <summary>
 /// Visits the select clause.
 /// </summary>
 /// <param name="selectClause">The select clause.</param>
 /// <param name="queryModel">The query model.</param>
 /// <remarks></remarks>
 public override void VisitSelectClause(SelectClause selectClause, Remotion.Linq.QueryModel queryModel)
 {
     // Assess for stuff like Count, Top etc.
 }
Пример #53
0
        /// <summary>
        /// Creates a new <see cref="QueryModelVisitor"/>, and returns the result of running <see cref="QueryModelVisitor.VisitAndGenerateQueryDescription"/> on the
        /// supplied <paramref name="queryModel"/>.
        /// </summary>
        /// <param name="queryModel">The query model.</param>
        /// <param name="structureBinder">The structure binder.</param>
        /// <param name="treeVisitor">The tree visitor.</param>
        /// <returns></returns>
        /// <remarks></remarks>
        public static QueryDescription FromQueryModel(Remotion.Linq.QueryModel queryModel, AbstractQueryStructureBinder structureBinder, AbstractExpressionTreeVisitor treeVisitor)
        {
            var elrmv = new QueryModelVisitor(structureBinder, treeVisitor);

            return(elrmv.VisitAndGenerateQueryDescription(queryModel));
        }
Пример #54
0
 protected QueryDescription GetQueryDescription(Remotion.Linq.QueryModel queryModel)
 {
     return(LastGeneratedDescription = QueryModelVisitor.FromQueryModel(queryModel));
 }
Пример #55
0
 public virtual IEnumerable <T> ExecuteCollection <T>(Remotion.Linq.QueryModel queryModel)
 {
     return(QueryableDataSource.ExecuteMany <T>((GetQueryDescription(queryModel)), _binder));
 }
        /// <summary>Visits body clauses.</summary>
        /// <param name="bodyClauses">Body clause to be visited.</param>
        /// <param name="queryModel">Query model containing given body clause.</param>
        protected override void VisitBodyClauses(ObservableCollection <IBodyClause> bodyClauses, Remotion.Linq.QueryModel queryModel)
        {
            int index = 0;

            foreach (var bodyClause in bodyClauses)
            {
                bodyClause.Accept(this, queryModel, index);
                index++;
            }
        }
 /// <summary>Visits a query model.</summary>
 /// <param name="queryModel">Query model to be visited.</param>
 public override void VisitQueryModel(Remotion.Linq.QueryModel queryModel)
 {
     queryModel.SelectClause.Accept(this, queryModel);
 }
        private void VisitContainsResultOperator(ContainsResultOperator containsResultOperator, Remotion.Linq.QueryModel queryModel, int index)
        {
            if (_query.IsSubQuery)
            {
                _visitor.Visit(containsResultOperator.Item);
                QueryComponent item = _visitor.RetrieveComponent();
                if (item is IExpression)
                {
                    Filter filter = new Filter(new BinaryOperator(MethodNames.Equal, _mainFromComponent.About, (IExpression)item));
                    if (!_mainFromComponent.Elements.Contains(filter))
                    {
                        _mainFromComponent.Elements.Add(filter);
                    }
                }

                EntityConstrain constrain = new EntityConstrain(
                    new Identifier(_mainFromComponent.About.Name + "_p"),
                    new Identifier(_mainFromComponent.About.Name + "_o"),
                    containsResultOperator.Item);
                if (!_mainFromComponent.Elements.Contains(constrain))
                {
                    _mainFromComponent.Elements.Add(constrain);
                }

                Call call = new Call(MethodNames.Any);
                call.Arguments.Add(_query);
                _result = call;
            }
            else
            {
                throw new NotSupportedException(System.String.Format("Cannot perform 'Contains' operation on top level query."));
            }
        }
 private void VisitSingleResultOperator(SingleResultOperator countResultOperator, Remotion.Linq.QueryModel queryModel, int index)
 {
 }
        private void VisitCountResultOperator(CountResultOperator countResultOperator, Remotion.Linq.QueryModel queryModel, int index)
        {
            Call distinct = new Call(MethodNames.Distinct);

            distinct.Arguments.Add(_mainFromComponent.About);
            UnboundConstrain constrain = (UnboundConstrain)_mainFromComponent.Elements.FirstOrDefault(item => item.GetType() == typeof(UnboundConstrain));

            if (constrain != null)
            {
                _mainFromComponent.Elements.Remove(constrain);
            }

            Call count = new Call(MethodNames.Count);

            count.Arguments.Add(distinct);
            _query.Select.Clear();
            Alias alias = new Alias(count, new Identifier(_query.CreateVariableName(_query.RetrieveIdentifier(_mainFromComponent.About.Name) + "Count"), typeof(int)));

            _query.Select.Add(alias);
        }