public void BindApplyWithAggregateAndFilterShouldReturnApplyClause()
{
IEnumerable <QueryToken> tokens = _parser.ParseApply("aggregate(StockQuantity with sum as TotalPrice)/filter(TotalPrice eq 100)");
MetadataBinder metadataBiner = new MetadataBinder(_bindingState);
ApplyBinder binder = new ApplyBinder(metadataBiner.Bind, _bindingState);
ApplyClause actual = binder.BindApply(tokens);
Assert.NotNull(actual);
Assert.Equal(2, actual.Transformations.Count());
List <TransformationNode> transformations = actual.Transformations.ToList();
Assert.NotNull(transformations[1]);
FilterTransformationNode filter = Assert.IsType <FilterTransformationNode>(transformations[1]);
Assert.Equal(TransformationNodeKind.Filter, filter.Kind);
FilterClause filterClause = filter.FilterClause;
Assert.NotNull(filterClause.Expression);
BinaryOperatorNode binaryOperation = Assert.IsType <BinaryOperatorNode>(filterClause.Expression);
Assert.NotNull(binaryOperation.Left);
ConvertNode propertyConvertNode = Assert.IsType <ConvertNode>(binaryOperation.Left);
Assert.NotNull(propertyConvertNode.Source);
SingleValueOpenPropertyAccessNode propertyAccess = Assert.IsType <SingleValueOpenPropertyAccessNode>(propertyConvertNode.Source);
Assert.Equal("TotalPrice", propertyAccess.Name);
}
public void BindApplyWithAggregateAndFilterShouldReturnApplyClause()
{
IEnumerable <QueryToken> tokens = _parser.ParseApply("aggregate(StockQuantity with sum as TotalPrice)/filter(TotalPrice eq 100)");
MetadataBinder metadataBiner = new MetadataBinder(_bindingState);
ApplyBinder binder = new ApplyBinder(metadataBiner.Bind, _bindingState);
ApplyClause actual = binder.BindApply(tokens);
actual.Should().NotBeNull();
actual.Transformations.Should().HaveCount(2);
List <TransformationNode> transformations = actual.Transformations.ToList();
FilterTransformationNode filter = transformations[1] as FilterTransformationNode;
filter.Should().NotBeNull();
filter.Kind.Should().Be(TransformationNodeKind.Filter);
FilterClause filterClause = filter.FilterClause;
filterClause.Expression.Should().NotBeNull();
BinaryOperatorNode binaryOperation = filterClause.Expression as BinaryOperatorNode;
binaryOperation.Should().NotBeNull();
ConvertNode propertyConvertNode = binaryOperation.Left as ConvertNode;
propertyConvertNode.Should().NotBeNull();
SingleValueOpenPropertyAccessNode propertyAccess = propertyConvertNode.Source as SingleValueOpenPropertyAccessNode;
propertyAccess.Should().NotBeNull();
propertyAccess.Name.Should().Be("TotalPrice");
}
private void TestOpenProperty <TParam, TReturn>(SingleValueNode source, string propertyName, Expression <Func <TParam, TReturn> > expectedExpression)
{
QueryNode node = new SingleValueOpenPropertyAccessNode(source, propertyName);
var result = this.testSubject.TranslateNode(node);
CompareExpressions(expectedExpression.Body, result);
}
/// <summary>
/// Bind $it to the <see cref="QueryNode"/> translated string.
/// </summary>
/// <param name="node">node to bind.</param>
/// <param name="filterClauseRangeVariable">The <see cref="FilterClause"/> range variable.</param>
/// <returns>The translated string with $it binding.</returns>
private string BindNode(QueryNode node, ResourceRangeVariable filterClauseRangeVariable)
{
BinaryOperatorNode binaryNode = node as BinaryOperatorNode;
InNode inNode = node as InNode;
AnyNode anyNode = node as AnyNode;
SingleValueFunctionCallNode singleValueFunctionCallNode = node as SingleValueFunctionCallNode;
SingleValueOpenPropertyAccessNode singleValueOpenPropertyAccessNode = node as SingleValueOpenPropertyAccessNode;
if (binaryNode != null)
{
return(BindBinaryOperatorNode(binaryNode, filterClauseRangeVariable));
}
else if (inNode != null)
{
return(BindInNode(inNode, filterClauseRangeVariable));
}
else if (anyNode != null)
{
return(BindAnyNode(anyNode, filterClauseRangeVariable));
}
else if (singleValueFunctionCallNode != null)
{
return(BindSingleValueFunctionCallNode(singleValueFunctionCallNode, filterClauseRangeVariable));
}
else if (singleValueOpenPropertyAccessNode != null)
{
return(BindSingleValueOpenPropertyAccess(singleValueOpenPropertyAccessNode, filterClauseRangeVariable));
}
else
{
return(this.TranslateNode(node));
}
}
/// <summary>
/// Binds a <see cref="SingleValueOpenPropertyAccessNode"/> to create a LINQ <see cref="Expression"/> that
/// represents the semantics of the <see cref="SingleValueOpenPropertyAccessNode"/>.
/// </summary>
/// <param name="openNode">The node to bind.</param>
/// <returns>The LINQ <see cref="Expression"/> created.</returns>
public virtual Expression BindDynamicPropertyAccessQueryNode(SingleValueOpenPropertyAccessNode openNode)
{
if (EdmLibHelpers.IsDynamicTypeWrapper(_filterType))
{
return(GetFlattenedPropertyExpression(openNode.Name) ?? Expression.Property(Bind(openNode.Source), openNode.Name));
}
PropertyInfo prop = GetDynamicPropertyContainer(openNode);
var propertyAccessExpression = BindPropertyAccessExpression(openNode, prop);
var readDictionaryIndexerExpression = Expression.Property(propertyAccessExpression,
DictionaryStringObjectIndexerName, Expression.Constant(openNode.Name));
var containsKeyExpression = Expression.Call(propertyAccessExpression,
propertyAccessExpression.Type.GetMethod("ContainsKey"), Expression.Constant(openNode.Name));
var nullExpression = Expression.Constant(null);
if (QuerySettings.HandleNullPropagation == HandleNullPropagationOption.True)
{
var dynamicDictIsNotNull = Expression.NotEqual(propertyAccessExpression, Expression.Constant(null));
var dynamicDictIsNotNullAndContainsKey = Expression.AndAlso(dynamicDictIsNotNull, containsKeyExpression);
return(Expression.Condition(
dynamicDictIsNotNullAndContainsKey,
readDictionaryIndexerExpression,
nullExpression));
}
else
{
return(Expression.Condition(
containsKeyExpression,
readDictionaryIndexerExpression,
nullExpression));
}
}
public override Expression BindDynamicPropertyAccessQueryNode(SingleValueOpenPropertyAccessNode openNode)
{
string fieldPath = openNode.Name;
if (!fieldPath.StartsWith("$."))
{
fieldPath = $"$.{fieldPath}";
}
fieldPath = fieldPath.Replace("__", ".");
//add JSON_VALUE support to open types
PropertyInfo prop = GetDynamicPropertyContainer(openNode);
//get parameter expression
var source = Bind(openNode.Source);
var propertyExp = Expression.Property(source, prop);
//call JSON_VALUE function on this open property with user selected key
var jsonEXP = Expression.Call(
typeof(DbJsonValueExtensions).GetMethod(
nameof(DbJsonValueExtensions.JSON_VALUE),
new Type[] { typeof(string), typeof(string) }),
Expression.Convert(propertyExp, typeof(string)),
Expression.Constant(fieldPath));
return(jsonEXP);
}
/// <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 SingleValueOpenPropertyAccessNode.
/// </summary>
/// <param name="nodeIn">The node to be translated.</param>
/// <returns>The translated node.</returns>
public override QueryNode Visit(SingleValueOpenPropertyAccessNode nodeIn)
{
Contract.Assert(nodeIn != null);
return(new SingleValueOpenPropertyAccessNode(
(SingleValueNode)nodeIn.Source.Accept(this),
nodeIn.Name));
}
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));
}
private IEdmTypeReference CreateAggregateExpressionTypeReference(SingleValueNode expression, AggregationMethodDefinition method)
{
IEdmTypeReference expressionType = expression.TypeReference;
if (expressionType == null && aggregateExpressionsCache != null)
{
SingleValueOpenPropertyAccessNode openProperty = expression as SingleValueOpenPropertyAccessNode;
if (openProperty != null)
{
expressionType = GetTypeReferenceByPropertyName(openProperty.Name);
}
}
switch (method.MethodKind)
{
case AggregationMethod.Average:
EdmPrimitiveTypeKind expressionPrimitiveKind = expressionType.PrimitiveKind();
switch (expressionPrimitiveKind)
{
case EdmPrimitiveTypeKind.Int32:
case EdmPrimitiveTypeKind.Int64:
case EdmPrimitiveTypeKind.Double:
return(EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Double, expressionType.IsNullable));
case EdmPrimitiveTypeKind.Decimal:
return(EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Decimal, expressionType.IsNullable));
case EdmPrimitiveTypeKind.Single:
return(EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Single, expressionType.IsNullable));
case EdmPrimitiveTypeKind.None:
return(expressionType);
default:
throw new ODataException(
ODataErrorStrings.ApplyBinder_AggregateExpressionIncompatibleTypeForMethod(expression,
expressionPrimitiveKind));
}
case AggregationMethod.VirtualPropertyCount:
case AggregationMethod.CountDistinct:
// Issue #758: CountDistinct and $Count should return type Edm.Decimal with Scale="0" and sufficient Precision.
return(EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Int64, false));
case AggregationMethod.Max:
case AggregationMethod.Min:
case AggregationMethod.Sum:
return(expressionType);
default:
// Only the EdmModel knows which type the custom aggregation methods returns.
// Since we do not have a reference for it, right now we are assuming that all custom aggregation methods returns Doubles
// TODO: find a appropriate way of getting the return type.
return(EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Double, expressionType.IsNullable));
}
}
public override QueryNode Visit(SingleValueOpenPropertyAccessNode nodeIn)
{
SingleValueNode?source = nodeIn.Source == null ? null : (SingleValueNode)Visit(nodeIn.Source);
if (nodeIn.Source != source)
{
nodeIn = new SingleValueOpenPropertyAccessNode(source, nodeIn.Name);
}
return(nodeIn);
}
/// <summary>
/// Translate a SingleValueOpenPropertyAccessNode.
/// </summary>
/// <param name="nodeIn">The node to be translated.</param>
/// <returns>The translated node.</returns>
public override QueryNode Visit(SingleValueOpenPropertyAccessNode nodeIn)
{
if (nodeIn == null)
{
throw Error.ArgumentNull(nameof(nodeIn));
}
return(new SingleValueOpenPropertyAccessNode(
(SingleValueNode)nodeIn.Source.Accept(this),
nodeIn.Name));
}
public void EqualsOnEntityAndNullIsSupported()
{
IEdmTypeReference left = HardCodedTestModel.GetPersonTypeReference();
IEdmTypeReference right = null;
SingleValueNode leftNode = new SingleValuePropertyAccessNode(new ConstantNode(null) /*parent*/, new EdmStructuralProperty(new EdmEntityType("MyNamespace", "MyEntityType"), "myPropertyName", left));
SingleValueNode rightNode = new SingleValueOpenPropertyAccessNode(new ConstantNode(null) /*parent*/, "myOpenPropertyname"); // open property's TypeReference is null
var result = TypePromotionUtils.PromoteOperandTypes(BinaryOperatorKind.Equal, leftNode, rightNode, out left, out right);
result.Should().BeTrue();
left.ShouldBeEquivalentTo(HardCodedTestModel.GetPersonTypeReference());
right.ShouldBeEquivalentTo(HardCodedTestModel.GetPersonTypeReference());
}
public void NotEqualsOnNullAndComplexIsSupported()
{
IEdmTypeReference left = null;
IEdmTypeReference right = HardCodedTestModel.GetPersonAddressProp().Type;
SingleValueNode leftNode = new SingleValueOpenPropertyAccessNode(new ConstantNode(null)/*parent*/, "myOpenPropertyname"); // open property's TypeReference is null
SingleValueNode rightNode = new SingleValuePropertyAccessNode(new ConstantNode(null)/*parent*/, new EdmStructuralProperty(new EdmEntityType("MyNamespace", "MyEntityType"), "myPropertyName", right));
var result = TypePromotionUtils.PromoteOperandTypes(BinaryOperatorKind.NotEqual, leftNode, rightNode, out left, out right);
result.Should().BeTrue();
left.ShouldBeEquivalentTo(HardCodedTestModel.GetPersonAddressProp().Type);
right.ShouldBeEquivalentTo(HardCodedTestModel.GetPersonAddressProp().Type);
}
/// <summary>
/// Bind $it to the <see cref="SingleValueOpenPropertyAccessNode"/> translated string.
/// </summary>
/// <param name="node">node to bind.</param>
/// <param name="filterClauseRangeVariable">The <see cref="FilterClause"/> range variable.</param>
/// <returns>The translated string with $it binding.</returns>
private string BindSingleValueOpenPropertyAccess(SingleValueOpenPropertyAccessNode node, ResourceRangeVariable filterClauseRangeVariable)
{
string translatedNode = this.TranslateNode(node);
ResourceRangeVariableReferenceNode rangeVariableNode = GetResourceRangeVariableReferenceNode(node);
if (rangeVariableNode != null && IsDifferentSource(filterClauseRangeVariable, rangeVariableNode))
{
translatedNode = ExpressionConstants.It + ExpressionConstants.SymbolForwardSlash + translatedNode;
}
return(translatedNode);
}
public override Expression Visit(SingleValueOpenPropertyAccessNode nodeIn)
{
Expression source = TranslateNode(nodeIn.Source);
if (TuplePropertyMapper == null)
{
return(Expression.Property(source, nodeIn.Name));
}
else
{
return(TuplePropertyMapper(source, nodeIn.Name));
}
}
private Expression BindPropertyAccessExpression(SingleValueOpenPropertyAccessNode openNode, PropertyInfo prop)
{
var source = Bind(openNode.Source);
Expression propertyAccessExpression;
if (QuerySettings.HandleNullPropagation == HandleNullPropagationOption.True &&
IsNullable(source.Type) && source != _lambdaParameters[ODataItParameterName])
{
propertyAccessExpression = Expression.Property(RemoveInnerNullPropagation(source), prop.Name);
}
else
{
propertyAccessExpression = Expression.Property(source, prop.Name);
}
return(propertyAccessExpression);
}
/// <summary>
/// Gets property for dynamic properties dictionary.
/// </summary>
/// <param name="openNode"></param>
/// <returns>Returns CLR property for dynamic properties container.</returns>
protected PropertyInfo GetDynamicPropertyContainer(SingleValueOpenPropertyAccessNode openNode)
{
IEdmStructuredType edmStructuredType;
IEdmTypeReference edmTypeReference = openNode.Source.TypeReference;
if (edmTypeReference.IsEntity())
{
edmStructuredType = edmTypeReference.AsEntity().EntityDefinition();
}
else if (edmTypeReference.IsComplex())
{
edmStructuredType = edmTypeReference.AsComplex().ComplexDefinition();
}
else
{
throw Error.NotSupported(SRResources.QueryNodeBindingNotSupported, openNode.Kind, typeof(FilterBinder).Name);
}
return(EdmLibHelpers.GetDynamicPropertyDictionary(edmStructuredType, Model));
}
/// <summary>
/// Bind the parent of the LambdaToken
/// </summary>
/// <param name="queryToken">the parent token</param>
/// <returns>the bound parent node</returns>
private CollectionNode BindParentToken(QueryToken queryToken)
{
QueryNode parentNode = this.bindMethod(queryToken);
CollectionNode parentCollectionNode = parentNode as CollectionNode;
if (parentCollectionNode == null)
{
SingleValueOpenPropertyAccessNode parentOpenPropertyNode =
parentNode as SingleValueOpenPropertyAccessNode;
if (parentOpenPropertyNode == null)
{
throw new ODataException(ODataErrorStrings.MetadataBinder_LambdaParentMustBeCollection);
}
// support open collection properties
return(new CollectionOpenPropertyAccessNode(parentOpenPropertyNode.Source, parentOpenPropertyNode.Name));
}
return(parentCollectionNode);
}
/// <summary>
/// Bind the parent of the LambdaToken
/// </summary>
/// <param name="queryToken">the parent token</param>
/// <returns>the bound parent node</returns>
private CollectionNode BindParentToken(QueryToken queryToken)
{
QueryNode parentNode = this.bindMethod(queryToken);
CollectionNode parentCollectionNode = parentNode as CollectionNode;
if (parentCollectionNode == null)
{
SingleValueOpenPropertyAccessNode parentOpenPropertyNode =
parentNode as SingleValueOpenPropertyAccessNode;
if (parentOpenPropertyNode == null)
{
throw new ODataException(ODataErrorStrings.MetadataBinder_LambdaParentMustBeCollection);
}
// TODO: Add support for open collection properties here by replacing
// with something like an OpenCollectionNode.
throw new ODataException(ODataErrorStrings.MetadataBinder_CollectionOpenPropertiesNotSupportedInThisRelease);
}
return(parentCollectionNode);
}
private Expression CreateOpenPropertyAccessExpression(SingleValueOpenPropertyAccessNode openNode)
{
Expression sourceAccessor = BindAccessor(openNode.Source);
// First check that property exists in source
// It's the case when we are apply transformation based on earlier transformation
if (sourceAccessor.Type.GetProperty(openNode.Name) != null)
{
return(Expression.Property(sourceAccessor, openNode.Name));
}
// Property doesn't exists go for dynamic properties dictionary
PropertyInfo prop = GetDynamicPropertyContainer(openNode);
MemberExpression propertyAccessExpression = Expression.Property(sourceAccessor, prop.Name);
IndexExpression readDictionaryIndexerExpression = Expression.Property(propertyAccessExpression,
DictionaryStringObjectIndexerName, Expression.Constant(openNode.Name));
MethodCallExpression containsKeyExpression = Expression.Call(propertyAccessExpression,
propertyAccessExpression.Type.GetMethod("ContainsKey"), Expression.Constant(openNode.Name));
ConstantExpression nullExpression = Expression.Constant(null);
if (QuerySettings.HandleNullPropagation == HandleNullPropagationOption.True)
{
var dynamicDictIsNotNull = Expression.NotEqual(propertyAccessExpression, Expression.Constant(null));
var dynamicDictIsNotNullAndContainsKey = Expression.AndAlso(dynamicDictIsNotNull, containsKeyExpression);
return(Expression.Condition(
dynamicDictIsNotNullAndContainsKey,
readDictionaryIndexerExpression,
nullExpression));
}
else
{
return(Expression.Condition(
containsKeyExpression,
readDictionaryIndexerExpression,
nullExpression));
}
}
/// <summary>
/// Translates a <see cref="SingleValueOpenPropertyAccessNode"/> into a corresponding <see cref="String"/>.
/// </summary>
/// <param name="node">The node to translate.</param>
/// <returns>The translated String.</returns>
public override String Visit(SingleValueOpenPropertyAccessNode node)
{
ExceptionUtils.CheckArgumentNotNull(node, "node");
return(this.TranslatePropertyAccess(node.Source, node.Name));
}
/// <summary>
/// Translates a <see cref="SingleValueOpenPropertyAccessNode"/> into a corresponding <see cref="string"/>.
/// </summary>
/// <param name="node">The node to translate.</param>
/// <returns>The translated string.</returns>
public override string Visit(SingleValueOpenPropertyAccessNode node)
{
return(this.TranslatePropertyAccess(node.Source, node.Name));
}
/// <summary>
/// Visit a SingleValueOpenPropertyAccessNode
/// </summary>
/// <param name="nodeIn">The node to visit</param>
/// <returns>The translated expression</returns>
public override Expression Visit(SingleValueOpenPropertyAccessNode nodeIn)
{
this.CheckArgumentNull(nodeIn, "SingleValueOpenPropertyAccessNode");
return(this.TranslateOpenPropertyAccess(nodeIn.Source, nodeIn.Name));
}
public SingleValueOpenPropertyAccessNodeTests()
{
this.sourceNode = new ConstantNode(null);
this.node = new SingleValueOpenPropertyAccessNode(this.sourceNode, ExpectedPropertyName);
}
/// <summary>
/// Translate a SingleValueOpenPropertyAccessNode.
/// </summary>
/// <param name="nodeIn">The node to be translated.</param>
/// <returns>The translated node.</returns>
public override QueryNode Visit(SingleValueOpenPropertyAccessNode nodeIn)
{
return(new SingleValueOpenPropertyAccessNode(
(SingleValueNode)nodeIn.Source.Accept(this),
nodeIn.Name));
}
public override ImmutableList <string> Visit(SingleValueOpenPropertyAccessNode nodeIn)
{
return(nodeIn.Source.Accept(this).Add(nodeIn.Name));
}
private bool Visit(SingleValueOpenPropertyAccessNode node1, SingleValueOpenPropertyAccessNode node2)
{
return(node1.Name == node2.Name &&
node1.TypeReference.IsEqual(node2.TypeReference) &&
Compare(node1.Source, node2.Source));
}
public override int Visit(SingleValueOpenPropertyAccessNode nodeIn)
{
return(CombineHashCodes(TranslateNode(nodeIn.Source), nodeIn.Name.GetHashCode()));
}
public override object Visit(SingleValueOpenPropertyAccessNode nodeIn)
{
return(null);
}
public void TestInitialize()
{
this.sourceNode = new ConstantNode(null);
this.node = new SingleValueOpenPropertyAccessNode(this.sourceNode, ExpectedPropertyName);
}
/// <summary>
/// Visit a SingleValueOpenPropertyAccessNode
/// </summary>
/// <param name="nodeIn">the node to visit</param>
/// <returns>Defined by the implementer</returns>
public virtual T Visit(SingleValueOpenPropertyAccessNode nodeIn)
{
throw new NotImplementedException();
}
public override string Visit(SingleValueOpenPropertyAccessNode nodeIn)
{
return(WrapWithIdent(string.Format("OpenProperty:[{0}]", nodeIn.Name)));
}
