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; }
/// <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; }
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); }
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(); }
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)); } }
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); }
/// <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); }
/// <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); }
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)); } }
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); }
/// <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); }
/// <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); }
/// <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); }
/// <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); }
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); }
/// <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); } }
/// <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))); }
/// <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); }
public virtual T ExecuteScalar <T>(Remotion.Linq.QueryModel queryModel) { return(QueryableDataSource.ExecuteScalar <T>(GetQueryDescription(queryModel), _binder)); }
/// <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); }
/// <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. }
/// <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)); }
protected QueryDescription GetQueryDescription(Remotion.Linq.QueryModel queryModel) { return(LastGeneratedDescription = QueryModelVisitor.FromQueryModel(queryModel)); }
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); }