public void Init(ParsingContext context, ParseTreeNode parseNode) { #region get Type _TypeName = ((AstNode)parseNode.ChildNodes[1].AstNode).AsString; #endregion #region get myAttributes if (HasChildNodes(parseNode.ChildNodes[3])) { var AttrUpdateOrAssign = (AttributeUpdateOrAssignListNode)parseNode.ChildNodes[3].AstNode; _listOfUpdates = AttrUpdateOrAssign.ListOfUpdate; } #endregion #region whereClauseOpt if (parseNode.ChildNodes[4].ChildNodes != null && parseNode.ChildNodes[4].ChildNodes.Count != 0) { var tempWhereNode = (WhereExpressionNode)parseNode.ChildNodes[4].AstNode; _WhereExpression = tempWhereNode.BinaryExpressionDefinition; } #endregion }
public void Init(ParsingContext context, ParseTreeNode parseNode) { if (HasChildNodes(parseNode)) { //get type if (parseNode.ChildNodes[1] != null && parseNode.ChildNodes[1].AstNode != null) { _type = ((AstNode)(parseNode.ChildNodes[1].AstNode)).AsString; } else { throw new NotImplementedQLException(""); } if (parseNode.ChildNodes[3] != null && HasChildNodes(parseNode.ChildNodes[3])) { _attributeAssignList = (parseNode.ChildNodes[3].AstNode as AttributeAssignListNode).AttributeAssigns; } if (parseNode.ChildNodes[4] != null && ((WhereExpressionNode)parseNode.ChildNodes[4].AstNode).BinaryExpressionDefinition != null) { _whereExpression = ((WhereExpressionNode)parseNode.ChildNodes[4].AstNode).BinaryExpressionDefinition; } } }
public void Init(ParsingContext context, ParseTreeNode parseNode) { if (HasChildNodes(parseNode)) { //get type if (parseNode.ChildNodes[1] != null && parseNode.ChildNodes[1].AstNode != null) { _Type = ((AstNode)(parseNode.ChildNodes[1].AstNode)).AsString; } else { throw new NotImplementedQLException(""); } if (parseNode.ChildNodes[3] != null && HasChildNodes(parseNode.ChildNodes[3])) { _AttributeAssignList = new List <AAttributeAssignOrUpdate>((parseNode.ChildNodes[3].AstNode as AttributeUpdateOrAssignListNode).ListOfUpdate.Select(e => e as AAttributeAssignOrUpdate)); } if (parseNode.ChildNodes[4] != null && ((WhereExpressionNode)parseNode.ChildNodes[4].AstNode).BinaryExpressionDefinition != null) { _WhereExpression = ((WhereExpressionNode)parseNode.ChildNodes[4].AstNode).BinaryExpressionDefinition; } } }
private static IEnumerable <IVertex> ProcessBinaryExpression( BinaryExpressionDefinition binExpression, GQLPluginManager myPluginManager, IGraphDB myGraphDB, SecurityToken mySecurityToken, Int64 myTransactionToken, IVertexType vertexType) { //validate binExpression.Validate(myPluginManager, myGraphDB, mySecurityToken, myTransactionToken, vertexType); //calculate var expressionGraph = binExpression.Calculon(myPluginManager, myGraphDB, mySecurityToken, myTransactionToken, new CommonUsageGraph(myGraphDB, mySecurityToken, myTransactionToken), false); //extract return (expressionGraph.Select( new LevelKey(vertexType.ID, myGraphDB, mySecurityToken, myTransactionToken), null, true)); }
/// <summary> /// Creates all readouts of all types in the <paramref name="myTypeList"/> /// </summary> private List <IEnumerable <IVertexView> > CreateVertices(SecurityToken mySecurityToken, Int64 myTransactionToken, Dictionary <String, IVertexType> myTypeList, SelectResultManager mySelectResultManager, BinaryExpressionDefinition myWhereExpressionDefinition, Int64 myResolutionDepth, OrderByDefinition myOrderByDefinition, UInt64?myLimit, UInt64?myOffset) { var _ListOfListOfVertices = new List <IEnumerable <IVertexView> >(); // Create vertices for type foreach (var typeRef in myTypeList) { var _Vertices = CreateVerticesForType(mySecurityToken, myTransactionToken, typeRef, mySelectResultManager, myWhereExpressionDefinition, myResolutionDepth, myOrderByDefinition, myLimit, myOffset); // If this type did not returned any result, we wont add it to the result if (_Vertices != null) { _ListOfListOfVertices.Add(_Vertices); } } return(_ListOfListOfVertices); }
public InvalidBinaryExpressionIndexException(BinaryExpressionDefinition myBinaryExpression) { _msg = String.Format("The index {0} for the BinaryExpression {1} {2} {3} is not valid", myBinaryExpression.ExpressionIndex, myBinaryExpression.Left.ToString(), myBinaryExpression.Operator, myBinaryExpression.Right.ToString()); }
public void Init(ParsingContext context, ParseTreeNode parseNode) { if (HasChildNodes(parseNode)) { if (parseNode.ChildNodes[1].AstNode is TupleNode && (parseNode.ChildNodes[1].AstNode as TupleNode).TupleDefinition.TupleElements.Count == 1) { var tuple = (parseNode.ChildNodes[1].AstNode as TupleNode).TupleDefinition.Simplyfy(); BinaryExpressionDefinition = (tuple.TupleElements[0].Value as BinaryExpressionDefinition); } else if (parseNode.ChildNodes[1].AstNode is BinaryExpressionNode) { BinaryExpressionDefinition = ((BinaryExpressionNode)parseNode.ChildNodes[1].AstNode).BinaryExpressionDefinition; } } }
private BinaryExpressionDefinition GetConditionNode(String myOperator, BinaryExpressionDefinition myPrevNode, TupleDefinition myNodeList) { var binElem = myNodeList.FirstOrDefault(); if (binElem == null) { return(myPrevNode); } myNodeList.Remove(binElem); var binNode = new BinaryExpressionDefinition(myOperator, myPrevNode, binElem.Value); return(GetConditionNode(myOperator, binNode, myNodeList)); }
/// <summary> /// Checks the where expression, optimize it and create an IExpressionGraph /// </summary> private IExpressionGraph GetExpressionGraphFromWhere(BinaryExpressionDefinition myWhereExpressionDefinition, SecurityToken mySecurityToken, Int64 myTransactionToken) { #region interesting where #region exec expr myWhereExpressionDefinition.Validate(_pluginManager, _graphdb, mySecurityToken, myTransactionToken); var calculonResult = myWhereExpressionDefinition.Calculon(_pluginManager, _graphdb, mySecurityToken, myTransactionToken, new CommonUsageGraph(_graphdb, mySecurityToken, myTransactionToken), false); #endregion #endregion return(calculonResult); }
public void Init(ParsingContext context, ParseTreeNode parseNode) { if (HasChildNodes(parseNode)) { _TypeName = ((AstNode)(parseNode.ChildNodes[1].AstNode)).AsString; if (parseNode.ChildNodes[3] != null && HasChildNodes(parseNode.ChildNodes[3])) { _AttributeAssignList = (parseNode.ChildNodes[3].AstNode as AttributeAssignListNode).AttributeAssigns; } _whereExpression = ((BinaryExpressionNode)parseNode.ChildNodes[5].AstNode).BinaryExpressionDefinition; System.Diagnostics.Debug.Assert(_whereExpression != null); } }
public void Init(ParsingContext context, ParseTreeNode parseNode) { #region set type of binary expression _OperatorSymbol = parseNode.ChildNodes[1].FirstChild.Token.ValueString; _left = GetExpressionDefinition(parseNode.ChildNodes[0]); _right = GetExpressionDefinition(parseNode.ChildNodes[2]); if (parseNode.ChildNodes.Count > 3) { _expressionIndex = ((AstNode)parseNode.ChildNodes[4].AstNode).AsString; } #endregion BinaryExpressionDefinition = new BinaryExpressionDefinition(_OperatorSymbol, _left, _right, _expressionIndex); OriginalString += _left.ToString() + " "; OriginalString += _OperatorSymbol + " "; OriginalString += _right.ToString(); }
public void Init(ParsingContext context, ParseTreeNode parseNode) { _toBeDeletedAttributes = new List <String>(); _typeName = parseNode.ChildNodes[1].Token.ValueString; if (HasChildNodes(parseNode.ChildNodes[3])) { foreach (var _ParseTreeNode in parseNode.ChildNodes[3].ChildNodes[0].ChildNodes) { _toBeDeletedAttributes.Add(_ParseTreeNode.ChildNodes[0].Token.ValueString); } } #region whereClauseOpt if (parseNode.ChildNodes[4].ChildNodes != null && parseNode.ChildNodes[4].ChildNodes.Count != 0) { WhereExpressionNode tempWhereNode = (WhereExpressionNode)parseNode.ChildNodes[4].AstNode; _WhereExpression = tempWhereNode.BinaryExpressionDefinition; } #endregion }
/// <summary> /// Checks whether the <paramref name="myReference"/> is interesting for the <paramref name="myWhereExpressionDefinition"/> /// </summary> /// <param name="myReference">The reference defined in the FROM</param> /// <param name="myWhereExpressionDefinition"></param> /// <returns></returns> private Boolean IsInterestingWhereForReference(String myReference, BinaryExpressionDefinition myWhereExpressionDefinition) { #region check left var leftIDNode = myWhereExpressionDefinition.Left as IDChainDefinition; if (leftIDNode != null) { if (leftIDNode.Reference != null) { if (leftIDNode.Reference.Item1.Equals(myReference)) { return(true); } } } else if (myWhereExpressionDefinition.Left is BinaryExpressionDefinition) { return(IsInterestingWhereForReference(myReference, (BinaryExpressionDefinition)myWhereExpressionDefinition.Left)); } // even atom value operation needs to be evaluate. Somthing like this: // where 12 = 12 or where true // should have a valid result! else if (myWhereExpressionDefinition.Left is AOperationDefinition || myWhereExpressionDefinition.Left is AggregateDefinition) { return(true); } #endregion #region check right var rightIDNode = myWhereExpressionDefinition.Right as IDChainDefinition; if (rightIDNode != null) { if (rightIDNode.Reference != null) { if (rightIDNode.Reference.Item1.Equals(myReference) || myWhereExpressionDefinition.Left is TupleDefinition) { return(true); } } } else if (myWhereExpressionDefinition.Right is BinaryExpressionDefinition) { return(IsInterestingWhereForReference(myReference, (BinaryExpressionDefinition)myWhereExpressionDefinition.Right)); } // even atom value operation needs to be evaluate. Somthing like this: // where 12 = 12 or where true // should have a valid result! else if (myWhereExpressionDefinition.Right is AOperationDefinition || myWhereExpressionDefinition.Right is AggregateDefinition) { return(true); } #endregion return(false); }
/// <summary> /// Creates the lazy readouts for the given <paramref name="myTypeReference"/> /// </summary> private IEnumerable <IVertexView> CreateVerticesForType(SecurityToken mySecurityToken, Int64 myTransactionToken, KeyValuePair <String, IVertexType> myTypeReference, SelectResultManager mySelectResultManager, BinaryExpressionDefinition myWhereExpressionDefinition, Int64 myResolutionDepth, OrderByDefinition myOrderByDefinition, UInt64?myLimit, UInt64?myOffset) { IEnumerable <IVertexView> _Vertices = new List <IVertexView>(); #region Check groupings & aggregates mySelectResultManager.ValidateGroupingAndAggregate(myTypeReference.Key, myTypeReference.Value); #endregion #region Check, whether the type was affected by the where expressions. This will use either the Graph or the GUID index of the type Boolean isInterestingWhere = (myWhereExpressionDefinition != null && IsInterestingWhereForReference(myTypeReference.Key, myWhereExpressionDefinition)); #endregion #region Create an IEnumerable of Readouts for this typeNode var result = mySelectResultManager.Examine(myResolutionDepth, myTypeReference.Key, myTypeReference.Value, isInterestingWhere, ref _Vertices, mySecurityToken, myTransactionToken); #endregion #region If this type did not returned any result, we wont add it to the result if (!result) { return(new List <IVertexView>()); } #endregion #region If there was a result for this typeNode we will add a new SelectionListElementResult // _Vertices = mySelectResultManager.GetResult(_Vertices); #region OrderBy if (myOrderByDefinition != null) { OrderVertices(mySecurityToken, myTransactionToken, myOrderByDefinition, ref _Vertices); } #endregion #region Limit if (myLimit != null || myOffset != null) { ApplyLimitAndOffset(myLimit, myOffset, ref _Vertices); } #endregion #endregion return(_Vertices); }
public AttributeAssignOrUpdateExpression(IDChainDefinition myIDChainDefinition, BinaryExpressionDefinition binaryExpressionDefinition) : base(myIDChainDefinition) { BinaryExpressionDefinition = binaryExpressionDefinition; }
/// <summary> /// Initializes a new instance of the BinaryExpressionDefinition class. /// </summary> /// <param name="myBinaryExpression"></param> /// <param name="innerException">The exception that is the cause of the current exception, this parameter can be NULL.</param> public InvalidBinaryExpressionException(BinaryExpressionDefinition myBinaryExpression, Exception innerException = null) : base(innerException) { _msg = String.Format("The BinaryExpression is not valid: {0} {1} {2}", myBinaryExpression.Left.ToString(), myBinaryExpression.Operator, myBinaryExpression.Right.ToString()); }
public void Init(ParsingContext context, ParseTreeNode myParseTreeNode) { var _GraphQLGrammar = (SonesGQLGrammar)context.Language.Grammar; _Targets = new HashSet <AAttributeAssignOrUpdateOrRemove>(); #region FROM Sources _SourceType = ((ATypeNode)myParseTreeNode.ChildNodes[1].AstNode).ReferenceAndType.TypeName; var typeNode = _SourceType; _Sources = (myParseTreeNode.ChildNodes[2].AstNode as TupleNode).TupleDefinition; if (_Sources.Count() > 1) { var firstElement = (BinaryExpressionDefinition)_Sources.First().Value; _Sources.Remove(_Sources.First()); _Condition = GetConditionNode("OR", firstElement, _Sources); } else { _Condition = (BinaryExpressionDefinition)_Sources.First().Value; } #endregion #region Find statement "VIA Edge" IDNode _EdgeAttr = null; // Semantic Web Yoda-style... if (myParseTreeNode.ChildNodes[3].Token.KeyTerm == _GraphQLGrammar.S_VIA) { _EdgeAttr = (myParseTreeNode.ChildNodes[4].AstNode as IDNode); } else // Human language style... { if (myParseTreeNode.ChildNodes[5].Token.KeyTerm == _GraphQLGrammar.S_VIA) { _EdgeAttr = (myParseTreeNode.ChildNodes[6].AstNode as IDNode); } } #endregion #region Find statement "TO Targets" TupleDefinition tupleDef = null; // Semantic Web Yoda-style... if (myParseTreeNode.ChildNodes[5].Token.KeyTerm == _GraphQLGrammar.S_TO) { typeNode = ((ATypeNode)myParseTreeNode.ChildNodes[6].ChildNodes[0].AstNode).ReferenceAndType.TypeName; tupleDef = (myParseTreeNode.ChildNodes[6].ChildNodes[1].AstNode as TupleNode).TupleDefinition; } else // Human language style... { if (myParseTreeNode.ChildNodes[3].Token.KeyTerm == _GraphQLGrammar.S_TO) { typeNode = ((ATypeNode)myParseTreeNode.ChildNodes[4].ChildNodes[0].AstNode).ReferenceAndType.TypeName; tupleDef = (myParseTreeNode.ChildNodes[4].ChildNodes[1].AstNode as TupleNode).TupleDefinition; } } #endregion #region Processing... var tupleDefTargetType = new TupleDefinition(tupleDef.KindOfTuple); foreach (var item in tupleDef.TupleElements) { var attrName = typeNode + SonesGQLConstants.EdgeTraversalDelimiterSymbol + ((IDChainDefinition)((BinaryExpressionDefinition)item.Value).Left).ContentString; var leftNode = new IDChainDefinition(attrName, new List <TypeReferenceDefinition>() { new TypeReferenceDefinition(typeNode, typeNode) }); leftNode.AddPart(new ChainPartTypeOrAttributeDefinition(((IDChainDefinition)((BinaryExpressionDefinition)item.Value).Left).ContentString)); var rightNode = ((BinaryExpressionDefinition)item.Value).Right; var binExpression = new BinaryExpressionDefinition(((BinaryExpressionDefinition)item.Value).OperatorSymbol, leftNode, rightNode); tupleDefTargetType.AddElement(new TupleElement(binExpression)); } _Targets.Add(new AttributeAssignOrUpdateList(new CollectionDefinition(CollectionType.Set, tupleDefTargetType), _EdgeAttr.IDChainDefinition, false)); #endregion }
public void Init(ParsingContext context, ParseTreeNode parseNode) { _Sources = new HashSet <AAttributeAssignOrUpdateOrRemove>(); #region VIA edge IDNode _EdgeAttr = null; if (parseNode.ChildNodes[4].AstNode is IDNode) //Semantic Web Yoda style { _EdgeAttr = (parseNode.ChildNodes[4].AstNode as IDNode); } else //Human language style { _EdgeAttr = (parseNode.ChildNodes[6].AstNode as IDNode); } #endregion #region sources var typeNode = ((ATypeNode)parseNode.ChildNodes[1].AstNode).ReferenceAndType.TypeName; var tupleDef = (parseNode.ChildNodes[2].AstNode as TupleNode).TupleDefinition; var tupleDefSourceType = new TupleDefinition(tupleDef.KindOfTuple); _TargetType = typeNode; foreach (var item in tupleDef.TupleElements) { var attrName = typeNode + SonesGQLConstants.EdgeTraversalDelimiterSymbol + ((IDChainDefinition)((BinaryExpressionDefinition)item.Value).Left).ContentString; var leftNode = new IDChainDefinition(attrName, new List <TypeReferenceDefinition>() { new TypeReferenceDefinition(typeNode, typeNode) }); leftNode.AddPart(new ChainPartTypeOrAttributeDefinition(((IDChainDefinition)((BinaryExpressionDefinition)item.Value).Left).ContentString)); var rightNode = ((BinaryExpressionDefinition)item.Value).Right; var binExpression = new BinaryExpressionDefinition(((BinaryExpressionDefinition)item.Value).OperatorSymbol, leftNode, rightNode); tupleDefSourceType.AddElement(new TupleElement(binExpression)); } _Sources.Add(new AttributeRemoveList(_EdgeAttr.IDChainDefinition, _EdgeAttr.IDChainDefinition.ContentString, tupleDefSourceType)); #endregion #region sources FROM if (parseNode.ChildNodes[6].ChildNodes[0].AstNode is ATypeNode) //Semantic Web Yoda style { typeNode = ((ATypeNode)parseNode.ChildNodes[6].ChildNodes[0].AstNode).ReferenceAndType.TypeName; _Targets = (parseNode.ChildNodes[6].ChildNodes[1].AstNode as TupleNode).TupleDefinition; } else //Human language style { typeNode = ((ATypeNode)parseNode.ChildNodes[4].ChildNodes[0].AstNode).ReferenceAndType.TypeName; _Targets = (parseNode.ChildNodes[4].ChildNodes[1].AstNode as TupleNode).TupleDefinition; } _SourceType = typeNode; if (_Targets.Count() > 1) { var firstElement = (BinaryExpressionDefinition)_Targets.First().Value; _Targets.Remove(_Targets.First()); _Condition = GetConditionNode("OR", firstElement, _Targets); } else { _Condition = (BinaryExpressionDefinition)_Targets.First().Value; } #endregion }
public void Init(ParsingContext context, ParseTreeNode parseNode) { #region Data TypeList = new List <TypeReferenceDefinition>(); GroupByIDs = new List <IDChainDefinition>(); SelectedElements = new List <Tuple <AExpressionDefinition, string, SelectValueAssignment> >(); Limit = null; Offset = null; WhereExpressionDefinition = null; ResolutionDepth = -1; #endregion #region TypeList foreach (ParseTreeNode aNode in parseNode.ChildNodes[1].ChildNodes) { ATypeNode aType = (ATypeNode)aNode.AstNode; // use the overrides equals to check duplicated references if (!TypeList.Contains(aType.ReferenceAndType)) { TypeList.Add(aType.ReferenceAndType); } else { throw new DuplicateReferenceOccurrenceException(aType.ReferenceAndType.TypeName); } } #endregion #region selList foreach (ParseTreeNode aNode in parseNode.ChildNodes[3].ChildNodes) { SelectionListElementNode aColumnItemNode = (SelectionListElementNode)aNode.AstNode; String typeName = null; if (aColumnItemNode.SelType != TypesOfSelect.None) { foreach (var reference in GetTypeReferenceDefinitions(context)) { //SelectedElements.Add(new IDChainDefinition(new ChainPartTypeOrAttributeDefinition(reference.TypeName), aColumnItemNode.SelType, typeName), null); SelectedElements.Add(new Tuple <AExpressionDefinition, string, SelectValueAssignment>( new IDChainDefinition( new ChainPartTypeOrAttributeDefinition(reference.TypeName), aColumnItemNode.SelType, typeName), null, aColumnItemNode.ValueAssignment)); } continue; } SelectedElements.Add(new Tuple <AExpressionDefinition, string, SelectValueAssignment>( aColumnItemNode.ColumnSourceValue, aColumnItemNode.AliasId, aColumnItemNode.ValueAssignment)); } #endregion #region whereClauseOpt if (parseNode.ChildNodes[4].ChildNodes != null && parseNode.ChildNodes[4].ChildNodes.Count > 0) { WhereExpressionNode tempWhereNode = (WhereExpressionNode)parseNode.ChildNodes[4].AstNode; if (tempWhereNode.BinaryExpressionDefinition != null) { WhereExpressionDefinition = tempWhereNode.BinaryExpressionDefinition; } } #endregion #region groupClauseOpt if (HasChildNodes(parseNode.ChildNodes[5]) && HasChildNodes(parseNode.ChildNodes[5].ChildNodes[2])) { foreach (ParseTreeNode node in parseNode.ChildNodes[5].ChildNodes[2].ChildNodes) { GroupByIDs.Add(((IDNode)node.AstNode).IDChainDefinition); } } #endregion #region havingClauseOpt if (HasChildNodes(parseNode.ChildNodes[6])) { Having = ((BinaryExpressionNode)parseNode.ChildNodes[6].ChildNodes[1].AstNode).BinaryExpressionDefinition; } #endregion #region orderClauseOpt if (HasChildNodes(parseNode.ChildNodes[7])) { OrderByDefinition = ((OrderByNode)parseNode.ChildNodes[7].AstNode).OrderByDefinition; } #endregion #region Offset if (HasChildNodes(parseNode.ChildNodes[8])) { Offset = ((OffsetNode)parseNode.ChildNodes[8].AstNode).Count; } #endregion #region Limit if (HasChildNodes(parseNode.ChildNodes[9])) { Limit = ((LimitNode)parseNode.ChildNodes[9].AstNode).Count; } #endregion #region Depth if (HasChildNodes(parseNode.ChildNodes[10])) { ResolutionDepth = Convert.ToUInt16(parseNode.ChildNodes[10].ChildNodes[1].Token.Value); } #endregion #region Select Output if (HasChildNodes(parseNode.ChildNodes[11])) { _SelectOutputType = (parseNode.ChildNodes[11].AstNode as SelectOutputOptNode).SelectOutputType; } #endregion }
/// <summary> /// fast check if a given binary expression node is suitable for list integration /// </summary> /// <param name="aUniqueExpr">A BinaryExpressionNode.</param> /// <param name="myAttributes"></param> /// <returns></returns> private bool IsValidBinaryExpressionNode(BinaryExpressionDefinition aUniqueExpr, Dictionary <string, string> attributes) { switch (aUniqueExpr.TypeOfBinaryExpression) { case TypesOfBinaryExpression.LeftComplex: #region left complex return(CheckIDNode(aUniqueExpr.Left, attributes)); #endregion case TypesOfBinaryExpression.RightComplex: #region right complex return(CheckIDNode(aUniqueExpr.Right, attributes)); #endregion case TypesOfBinaryExpression.Complex: #region complex #region Data BinaryExpressionDefinition leftNode = null; BinaryExpressionDefinition rightNode = null; #endregion #region get expr #region left if (aUniqueExpr.Left is BinaryExpressionDefinition) { leftNode = (BinaryExpressionDefinition)aUniqueExpr.Left; } else { return(false); } #endregion #region right if (aUniqueExpr.Right is BinaryExpressionDefinition) { rightNode = (BinaryExpressionDefinition)aUniqueExpr.Right; } else { return(false); } #endregion #endregion #region check if ((leftNode != null) && (rightNode != null)) { if (IsValidBinaryExpressionNode(leftNode, attributes) && IsValidBinaryExpressionNode(rightNode, attributes)) { return(true); } else { return(false); } } else { return(false); } #endregion #endregion #region error cases case TypesOfBinaryExpression.Atom: default: //in this kind of node it is not allowed to use Atom or complex expressions return(false); #endregion } }