/// <summary> /// Visits a QueryExpression tree whose root node is the LinqExpandExpression. /// </summary> /// <param name="expression">The root node of the expression tree being visited.</param> /// <returns>Uri query string representing the expression.</returns> public override string Visit(LinqToAstoriaExpandExpression expression) { string source = this.ComputeUriInternal(expression.Source); this.SetExpandQueryOption(expression.ExpandString); this.hasQueryOption = true; return(source); }
/// <summary> /// Visits a LinqExpandExpression. /// </summary> /// <param name="expression">The expression.</param> /// <returns>The result of visiting this expression.</returns> public CodeExpression Visit(LinqToAstoriaExpandExpression expression) { var source = this.GenerateQueryCode(expression.Source).Expression; if (!expression.IsImplicit) { Type clrType = this.GetClrType(expression.Source); return(source.Cast(Code.GenericType("DataServiceQuery", clrType.FullName)).Call("Expand", Code.Primitive(expression.ExpandString))); } return(source); }
/// <summary> /// Visits a QueryExpression tree whose root node is the LinqExpandExpression. /// </summary> /// <param name="expression">The root node of the expression tree being visited.</param> /// <returns>Replaced expression.</returns> public virtual QueryExpression Visit(LinqToAstoriaExpandExpression expression) { QueryExpression source = this.ReplaceExpression(expression.Source); if (HasChanged(expression.Source, source)) { return(new LinqToAstoriaExpandExpression(source, expression.ExpandString, expression.ExpressionType, expression.IsImplicit)); } else { return(expression); } }
/// <summary> /// Visits a LinqExpandExpression. /// </summary> /// <param name="expression">The expression.</param> /// <returns>The result of visiting this expression.</returns> public Expression Visit(LinqToAstoriaExpandExpression expression) { Expression source = this.GenerateLinqExpression(expression.Source); if (!expression.IsImplicit) { var queryOptionParameters = new Expression[] { Expression.Constant(expression.ExpandString) }; var elementType = source.Type.GetGenericArguments()[0]; ExceptionUtilities.Assert(elementType != null, "Element type should not be null"); var typedDataServiceQuery = typeof(DataServiceQuery <>).MakeGenericType(elementType); var result = Expression.Call(Expression.Convert(source, typedDataServiceQuery), "Expand", new Type[] { }, queryOptionParameters); return(result); } return(source); }
/// <summary> /// Visits a LinqExpandExpression. /// </summary> /// <param name="expression">The expression.</param> /// <returns>Value of the expression</returns> public QueryValue Visit(LinqToAstoriaExpandExpression expression) { // expand is not handled here, instead it's handled in the trimming phase after // the whole expression has been evaluated var expanded = this.Evaluate(expression.Source); // if expanding a collection using sql strategy, we do not guarantee the order of top level set. var collection = expanded as QueryCollectionValue; if (collection != null) { var strategy = collection.Type.ElementType.EvaluationStrategy as ILinqToAstoriaQueryEvaluationStrategy; ExceptionUtilities.CheckObjectNotNull(strategy, "Cannot get astoria-specific evaluation strategy from collection value."); if (!strategy.IsCollectionOrderPredictable) { return(QueryCollectionValue.Create(collection.Type.ElementType, collection.Elements, false)); } } return(expanded); }
/// <summary> /// Visits a QueryExpression tree whose root node is the LinqExpandExpression. /// </summary> /// <param name="expression">The root node of the expression tree being visited.</param> /// <returns>Uri query string representing the expression.</returns> public override string Visit(LinqToAstoriaExpandExpression expression) { string source = this.ComputeUriInternal(expression.Source); this.SetExpandQueryOption(expression.ExpandString); this.hasQueryOption = true; return source; }
/// <summary> /// Visits a QueryExpression tree whose root node is the LinqToAstoriaExpandExpression. /// </summary> /// <param name="expression">The root node of the expression tree being visited.</param> /// <returns>Uri query string representing the expression.</returns> public virtual string Visit(LinqToAstoriaExpandExpression expression) { throw new TaupoNotSupportedException("Not supported"); }
/// <summary> /// Resolves types for the specified expression. /// </summary> /// <param name="expression">The expression to resolve types for.</param> /// <returns>Expression with resolved types.</returns> public QueryExpression Visit(LinqToAstoriaExpandExpression expression) { var source = this.ResolveTypes(expression.Source); return(new LinqToAstoriaExpandExpression(source, expression.ExpandString, source.ExpressionType, expression.IsImplicit)); }