/// <summary> /// Visit a SingleComplexNode /// </summary> /// <param name="nodeIn">the node to visit</param> /// <returns>true, indicating that the node has been visited.</returns> public override bool Visit(SingleComplexNode nodeIn) { validate(nodeIn); validate(nodeIn.Property); validate(nodeIn.TypeReference.Definition); return(true); }
public override SingleValueNode Visit(SingleValuePropertyAccessNode nodeIn) { if (nodeIn.Source != null) { if (nodeIn.Source.Kind == QueryNodeKind.SingleNavigationNode) { SingleNavigationNode singleNavigationNode = nodeIn.Source as SingleNavigationNode; if (EdmLibHelpers.IsNotSortable(nodeIn.Property, singleNavigationNode.NavigationProperty, singleNavigationNode.NavigationProperty.ToEntityType(), _model, _enableOrderBy)) { return(nodeIn); } } else if (nodeIn.Source.Kind == QueryNodeKind.SingleComplexNode) { SingleComplexNode singleComplexNode = nodeIn.Source as SingleComplexNode; if (EdmLibHelpers.IsNotSortable(nodeIn.Property, singleComplexNode.Property, nodeIn.Property.DeclaringType, _model, _enableOrderBy)) { return(nodeIn); } } else if (EdmLibHelpers.IsNotSortable(nodeIn.Property, _property, _structuredType, _model, _enableOrderBy)) { return(nodeIn); } } if (nodeIn.Source != null) { return(nodeIn.Source.Accept(this)); } return(null); }
private static string GetNavigationPath(SingleComplexNode nodeIn) { if (nodeIn.NavigationSource == null) { return(nodeIn.Property.Name); } string[] pathSegments; if (nodeIn.Source.Kind == QueryNodeKind.SingleComplexNode) { var paths = GetPathFromSource(nodeIn.Source as SingleComplexNode); paths.Add(nodeIn.Property.Name); pathSegments = paths.ToArray(); } else { if (nodeIn.NavigationSource.Path.PathSegments.ToArray().Length > 1) { pathSegments = nodeIn.NavigationSource.Path.PathSegments.Skip(1).ToArray(); } else { pathSegments = new[] { nodeIn.Property.Name } }; } var path = string.Join(Constants.SymbolDot, pathSegments); return(string.IsNullOrWhiteSpace(path) ? string.Empty : path); }
/// <summary> /// We return the <see cref="ResourceRangeVariableReferenceNode"/> within a <see cref="QueryNode"/> /// </summary> /// <param name="node">The node to extract the ResourceRangeVariableReferenceNode.</param> /// <returns>The extracted ResourceRangeVariableReferenceNode.</returns> private ResourceRangeVariableReferenceNode GetResourceRangeVariableReferenceNode(QueryNode node) { if (node == null) { return(null); } switch (node.Kind) { case QueryNodeKind.SingleValuePropertyAccess: SingleValuePropertyAccessNode singleValuePropertyAccessNode = node as SingleValuePropertyAccessNode; return(GetResourceRangeVariableReferenceNode(singleValuePropertyAccessNode.Source)); case QueryNodeKind.Convert: ConvertNode convertNode = node as ConvertNode; return(GetResourceRangeVariableReferenceNode(convertNode.Source)); case QueryNodeKind.Any: AnyNode anyNode = node as AnyNode; return(GetResourceRangeVariableReferenceNode(anyNode.Source)); case QueryNodeKind.SingleValueFunctionCall: SingleValueFunctionCallNode singleValueFunctionCallNode = node as SingleValueFunctionCallNode; return(GetResourceRangeVariableReferenceNode(singleValueFunctionCallNode.Parameters.First())); case QueryNodeKind.ResourceRangeVariableReference: return(node as ResourceRangeVariableReferenceNode); case QueryNodeKind.SingleValueOpenPropertyAccess: SingleValueOpenPropertyAccessNode singleValueOpenPropertyAccessNode = node as SingleValueOpenPropertyAccessNode; return(GetResourceRangeVariableReferenceNode(singleValueOpenPropertyAccessNode.Source)); case QueryNodeKind.SingleComplexNode: SingleComplexNode singleComplexNode = node as SingleComplexNode; return(GetResourceRangeVariableReferenceNode(singleComplexNode.Source)); case QueryNodeKind.CollectionComplexNode: CollectionComplexNode collectionComplexNode = node as CollectionComplexNode; return(GetResourceRangeVariableReferenceNode(collectionComplexNode.Source)); case QueryNodeKind.CollectionNavigationNode: CollectionNavigationNode collectionNavigationNode = node as CollectionNavigationNode; return(GetResourceRangeVariableReferenceNode(collectionNavigationNode.Source)); case QueryNodeKind.SingleNavigationNode: SingleNavigationNode singleNavigationNode = node as SingleNavigationNode; return(GetResourceRangeVariableReferenceNode(singleNavigationNode.Source)); case QueryNodeKind.CollectionResourceFunctionCall: CollectionResourceFunctionCallNode collectionResourceFunctionCallNode = node as CollectionResourceFunctionCallNode; return(GetResourceRangeVariableReferenceNode(collectionResourceFunctionCallNode.Source)); case QueryNodeKind.SingleResourceFunctionCall: SingleResourceFunctionCallNode singleResourceFunctionCallNode = node as SingleResourceFunctionCallNode; return(GetResourceRangeVariableReferenceNode(singleResourceFunctionCallNode.Source)); } return(null); }
/// <summary> /// Translate a SingleComplexNode. /// </summary> /// <param name="nodeIn">The node to be translated.</param> /// <returns>The translated node.</returns> public override QueryNode Visit(SingleComplexNode nodeIn) { Contract.Assert(nodeIn != null); return(new SingleComplexNode( (SingleResourceNode)nodeIn.Source.Accept(this), nodeIn.Property)); }
private GroupByTransformationNode BindGroupByToken(GroupByToken token) { List <GroupByPropertyNode> properties = new List <GroupByPropertyNode>(); foreach (EndPathToken propertyToken in token.Properties) { QueryNode bindResult = this.bindMethod(propertyToken); SingleValuePropertyAccessNode property = bindResult as SingleValuePropertyAccessNode; SingleComplexNode complexProperty = bindResult as SingleComplexNode; if (property != null) { RegisterProperty(properties, ReversePropertyPath(property)); } else if (complexProperty != null) { RegisterProperty(properties, ReversePropertyPath(complexProperty)); } else { SingleValueOpenPropertyAccessNode openProperty = bindResult as SingleValueOpenPropertyAccessNode; if (openProperty != null) { IEdmTypeReference type = GetTypeReferenceByPropertyName(openProperty.Name); properties.Add(new GroupByPropertyNode(openProperty.Name, openProperty, type)); } else { throw new ODataException( ODataErrorStrings.ApplyBinder_GroupByPropertyNotPropertyAccessValue(propertyToken.Identifier)); } } } var newProperties = new HashSet <EndPathToken>(((GroupByToken)token).Properties); TransformationNode aggregate = null; if (token.Child != null) { if (token.Child.Kind == QueryTokenKind.Aggregate) { aggregate = BindAggregateToken((AggregateToken)token.Child); aggregateExpressionsCache = ((AggregateTransformationNode)aggregate).AggregateExpressions; newProperties.UnionWith(aggregateExpressionsCache.Select(statement => new EndPathToken(statement.Alias, null))); } else { throw new ODataException(ODataErrorStrings.ApplyBinder_UnsupportedGroupByChild(token.Child.Kind)); } } state.AggregatedPropertyNames = newProperties; // TODO: Determine source return(new GroupByTransformationNode(properties, aggregate, null)); }
/// <summary> /// Writes single complex property node to string. /// </summary> /// <param name="node">Node to write to string</param> /// <returns>String representation of node.</returns> private static string ToString(SingleComplexNode node) { return(tabHelper.Prefix + "SingleComplexNode" + tabHelper.Indent(() => tabHelper.Prefix + "Property = " + node.Property.Name + tabHelper.Prefix + "TypeReference = " + node.TypeReference + tabHelper.Prefix + "Source = " + ToString(node.Source) )); }
/// <summary> /// Binds a <see cref="SingleComplexNode"/> to create a LINQ <see cref="Expression"/> that /// represents the semantics of the <see cref="SingleComplexNode"/>. /// </summary> /// <param name="singleComplexNode">The node to bind.</param> /// <returns>The LINQ <see cref="Expression"/> created.</returns> public virtual Expression BindSingleComplexNode(SingleComplexNode singleComplexNode) { if (singleComplexNode == null) { throw Error.ArgumentNull(nameof(singleComplexNode)); } Expression source = Bind(singleComplexNode.Source); return(CreatePropertyAccessExpression(source, singleComplexNode.Property, GetFullPropertyPath(singleComplexNode))); }
public override ImmutableList <string> Visit(SingleComplexNode nodeIn) { if (nodeIn.Source is SingleComplexNode) { return(nodeIn.Source.Accept(this).Add(nodeIn.Property.Name)); } else { return(ImmutableList.Create(nodeIn.Property.Name)); } }
/// <summary> /// Translate a SingleComplexNode. /// </summary> /// <param name="nodeIn">The node to be translated.</param> /// <returns>The translated node.</returns> public override QueryNode Visit(SingleComplexNode nodeIn) { if (nodeIn == null) { throw Error.ArgumentNull(nameof(nodeIn)); } return(new SingleComplexNode( (SingleResourceNode)nodeIn.Source.Accept(this), nodeIn.Property)); }
private static List <string> GetPathFromSource(SingleComplexNode node) { if (!(node.Source is SingleComplexNode)) { return(new List <string> { node.Property.Name }); } var sources = GetPathFromSource((SingleComplexNode)node.Source); sources.Add(node.Property.Name); return(sources); }
public override SingleValueNode Visit(SingleComplexNode nodeIn) { if (EdmLibHelpers.IsNotSortable(nodeIn.Property, _property, _structuredType, _model, _enableOrderBy)) { return(nodeIn); } if (nodeIn.Source != null) { return(nodeIn.Source.Accept(this)); } return(null); }
/// <summary> /// Override this method to validate single complex property accessor. /// </summary> /// <remarks> /// This method is intended to be called from method overrides in subclasses. This method also supports unit-testing scenarios and is not intended to be called from user code. /// Call the Validate method to validate a <see cref="FilterQueryOption"/> instance. /// </remarks> /// <param name="singleComplexNode"></param> /// <param name="settings"></param> protected virtual void ValidateSingleComplexNode(SingleComplexNode singleComplexNode, ODataValidationSettings settings) { Contract.Assert(singleComplexNode != null); Contract.Assert(settings != null); // Check whether the property is filterable. IEdmProperty property = singleComplexNode.Property; if (EdmHelpers.IsNotFilterable(property, _property, _structuredType, _model, _defaultQuerySettings.EnableFilter)) { throw new ODataException(Error.Format(SRResources.NotFilterablePropertyUsedInFilter, property.Name)); } ValidateQueryNode(singleComplexNode.Source, settings); }
/// <summary> /// Override this method to validate property accessor. /// </summary> /// <remarks> /// This method is intended to be called from method overrides in subclasses. This method also supports unit-testing scenarios and is not intended to be called from user code. /// Call the Validate method to validate a <see cref="FilterQueryOption"/> instance. /// </remarks> /// <param name="propertyAccessNode"></param> /// <param name="settings"></param> public virtual void ValidateSingleValuePropertyAccessNode(SingleValuePropertyAccessNode propertyAccessNode, ODataValidationSettings settings) { if (propertyAccessNode == null) { throw Error.ArgumentNull(nameof(propertyAccessNode)); } if (settings == null) { throw Error.ArgumentNull(nameof(settings)); } // Check whether the property is filterable. IEdmProperty property = propertyAccessNode.Property; bool notFilterable = false; if (propertyAccessNode.Source != null) { if (propertyAccessNode.Source.Kind == QueryNodeKind.SingleNavigationNode) { SingleNavigationNode singleNavigationNode = propertyAccessNode.Source as SingleNavigationNode; notFilterable = EdmHelpers.IsNotFilterable(property, singleNavigationNode.NavigationProperty, singleNavigationNode.NavigationProperty.ToEntityType(), _model, _defaultQuerySettings.EnableFilter); } else if (propertyAccessNode.Source.Kind == QueryNodeKind.SingleComplexNode) { SingleComplexNode singleComplexNode = propertyAccessNode.Source as SingleComplexNode; notFilterable = EdmHelpers.IsNotFilterable(property, singleComplexNode.Property, property.DeclaringType, _model, _defaultQuerySettings.EnableFilter); } else { notFilterable = EdmHelpers.IsNotFilterable(property, _property, _structuredType, _model, _defaultQuerySettings.EnableFilter); } } if (notFilterable) { throw new ODataException(Error.Format(SRResources.NotFilterablePropertyUsedInFilter, property.Name)); } ValidateQueryNode(propertyAccessNode.Source, settings); }
private static List <string> GetPathFromSource(SingleComplexNode node) { if (node.Source is ResourceRangeVariableReferenceNode referenceNode) { var path = GetPathFromSource(referenceNode); path.Add(node.Property.Name); return(path); } if (!(node.Source is SingleComplexNode)) { return(new List <string> { node.Property.Name }); } var sources = GetPathFromSource((SingleComplexNode)node.Source); sources.Add(node.Property.Name); return(sources); }
/// <summary> /// Override this method to validate single complex property accessor. /// </summary> /// <remarks> /// This method is intended to be called from method overrides in subclasses. This method also supports unit-testing scenarios and is not intended to be called from user code. /// Call the Validate method to validate a <see cref="FilterQueryOption"/> instance. /// </remarks> /// <param name="singleComplexNode"></param> /// <param name="settings"></param> public virtual void ValidateSingleComplexNode(SingleComplexNode singleComplexNode, ODataValidationSettings settings) { if (singleComplexNode == null) { throw Error.ArgumentNull("singleComplexNode"); } if (settings == null) { throw Error.ArgumentNull("settings"); } // Check whether the property is filterable. IEdmProperty property = singleComplexNode.Property; if (EdmHelpers.IsNotFilterable(property, _property, _structuredType, _model, _defaultQuerySettings.EnableFilter)) { throw new ODataException(Error.Format(SRResources.NotFilterablePropertyUsedInFilter, property.Name)); } ValidateQueryNode(singleComplexNode.Source, settings); }
/// <summary> /// Translates a <see cref="SingleComplexNode"/> into a corresponding <see cref="String"/>. /// </summary> /// <param name="node">The node to translate.</param> /// <returns>The translated String.</returns> public override String Visit(SingleComplexNode node) { ExceptionUtils.CheckArgumentNotNull(node, "node"); return(this.TranslatePropertyAccess(node.Source, node.Property.Name)); }
public override T Visit(SingleComplexNode nodeIn) => DebuggerBreakVisited(nodeIn);
public override QueryNode Visit(SingleComplexNode nodeIn) { SingleResourceNode?source = nodeIn.Source == null ? null : (SingleResourceNode)Visit(nodeIn.Source); return(new SingleComplexNode(source, nodeIn.Property)); }
private static void VerifySingleComplexNodeAreEqual(SingleComplexNode expected, SingleComplexNode actual, AssertionHandler assert) { VerifyQueryNodesAreEqual(expected.Source, actual.Source, assert); QueryTestUtils.VerifyPropertiesAreEqual(expected.Property, actual.Property, assert); }
public override void ValidateSingleComplexNode(SingleComplexNode singleComplexNode, ODataValidationSettings settings) { IncrementCount("ValidateSingleComplexNode"); base.ValidateSingleComplexNode(singleComplexNode, settings); }
/// <summary> /// Translate a SingleComplexNode. /// </summary> /// <param name="nodeIn">The node to be translated.</param> /// <returns>The translated node.</returns> public override QueryNode Visit(SingleComplexNode nodeIn) { return(new SingleComplexNode( (SingleResourceNode)nodeIn.Source.Accept(this), nodeIn.Property)); }
/// <summary> /// Visit an SingleComplexNode /// </summary> /// <param name="nodeIn">the node to visit</param> /// <returns>The translated expression</returns> public override Expression Visit(SingleComplexNode nodeIn) { this.CheckArgumentNull(nodeIn, "node"); return(this.TranslatePropertyAccess(nodeIn.Source, nodeIn.Property)); }
/// <summary> /// Binds a <see cref="SingleComplexNode"/> to create a LINQ <see cref="Expression"/> that /// represents the semantics of the <see cref="SingleComplexNode"/>. /// </summary> /// <param name="singleComplexNode">The node to bind.</param> /// <returns>The LINQ <see cref="Expression"/> created.</returns> public virtual Expression BindSingleComplexNode(SingleComplexNode singleComplexNode) { Expression source = Bind(singleComplexNode.Source); return(CreatePropertyAccessExpression(source, singleComplexNode.Property, GetFullPropertyPath(singleComplexNode))); }
/// <inheritdoc /> public override string Visit(SingleComplexNode node) { return(GetNavigationPath(node)); }
public override string Visit(SingleComplexNode nodeIn) => $"{nodeIn.Property.Name}{nodeIn.Source.Accept(this)}"; // return base.Visit(nodeIn);