protected void ValidateBinaryExpression(BinaryExpressionDefinition aUniqueExpr, IVertexType validationType, GQLPluginManager myPluginManager, IGraphDB myGraphDB, SecurityToken mySecurityToken, Int64 myTransactionToken) { switch (aUniqueExpr.TypeOfBinaryExpression) { case TypesOfBinaryExpression.LeftComplex: ValidateBinaryExpressionInternal(aUniqueExpr.Left, validationType, myPluginManager, myGraphDB, mySecurityToken, myTransactionToken); break; case TypesOfBinaryExpression.RightComplex: ValidateBinaryExpressionInternal(aUniqueExpr.Right, validationType, myPluginManager, myGraphDB, mySecurityToken, myTransactionToken); break; case TypesOfBinaryExpression.Complex: ValidateBinaryExpressionInternal(aUniqueExpr.Left, validationType, myPluginManager, myGraphDB, mySecurityToken, myTransactionToken); ValidateBinaryExpressionInternal(aUniqueExpr.Right, validationType, myPluginManager, myGraphDB, mySecurityToken, myTransactionToken); break; case TypesOfBinaryExpression.Atom: default: break; } }
/// <summary> /// This method /// </summary> /// <param name="aBinExpr"></param> /// <param name="aDBObject"></param> /// <param name="dbContext"></param> protected void SubstituteAttributeNames(BinaryExpressionDefinition aBinExpr, IVertex aDBObject) { if (aBinExpr.Left is IDChainDefinition) { aBinExpr.Left = GetAtomValue((IDChainDefinition)aBinExpr.Left, aDBObject); switch (aBinExpr.TypeOfBinaryExpression) { case TypesOfBinaryExpression.LeftComplex: aBinExpr.TypeOfBinaryExpression = TypesOfBinaryExpression.Atom; break; case TypesOfBinaryExpression.Complex: aBinExpr.TypeOfBinaryExpression = TypesOfBinaryExpression.RightComplex; break; case TypesOfBinaryExpression.Atom: case TypesOfBinaryExpression.RightComplex: case TypesOfBinaryExpression.Unknown: default: break; } } else { if (aBinExpr.Left is BinaryExpressionDefinition) { SubstituteAttributeNames((BinaryExpressionDefinition)aBinExpr.Left, aDBObject); } } if (aBinExpr.Right is IDChainDefinition) { aBinExpr.Right = GetAtomValue((IDChainDefinition)aBinExpr.Right, aDBObject); switch (aBinExpr.TypeOfBinaryExpression) { case TypesOfBinaryExpression.RightComplex: aBinExpr.TypeOfBinaryExpression = TypesOfBinaryExpression.Atom; break; case TypesOfBinaryExpression.Complex: aBinExpr.TypeOfBinaryExpression = TypesOfBinaryExpression.LeftComplex; break; case TypesOfBinaryExpression.Atom: case TypesOfBinaryExpression.LeftComplex: case TypesOfBinaryExpression.Unknown: default: break; } } else { if (aBinExpr.Right is BinaryExpressionDefinition) { SubstituteAttributeNames((BinaryExpressionDefinition)aBinExpr.Right, aDBObject); } } }
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 SelectDefinition(List<TypeReferenceDefinition> myTypeList, List<Tuple<AExpressionDefinition, string, SelectValueAssignment>> mySelectedElements, BinaryExpressionDefinition myWhereExpressionDefinition, List<IDChainDefinition> myGroupByIDs, BinaryExpressionDefinition myHaving, ulong? myLimit, ulong? myOffset, OrderByDefinition myOrderByDefinition, long myResolutionDepth) { TypeList = myTypeList; SelectedElements = mySelectedElements; WhereExpressionDefinition = myWhereExpressionDefinition; GroupByIDs = myGroupByIDs; Having = myHaving; Limit = myLimit; Offset = myOffset; OrderByDefinition = myOrderByDefinition; ResolutionDepth = myResolutionDepth; }
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; } } }
public BinaryExpressionDefinition GetBinaryExpression(GQLPluginManager myPluginManager, IGraphDB myGraphDB, SecurityToken mySecurityToken, TransactionToken myTransactionToken) { AExpressionDefinition right; var op = GetOperatorBySymbol(_OperatorSymbol); if (op == null) { throw new OperatorDoesNotExistException(_OperatorSymbol); } right = new ValueDefinition(1); var binExpr = new BinaryExpressionDefinition("*", _Expression, right); binExpr.Validate(myPluginManager, myGraphDB, mySecurityToken, myTransactionToken); return binExpr; }
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]); #endregion BinaryExpressionDefinition = new BinaryExpressionDefinition(_OperatorSymbol, _left, _right); OriginalString += _left.ToString() + " "; OriginalString += _OperatorSymbol + " "; OriginalString += _right.ToString(); }
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 BinaryExpressionDefinition GetBinaryExpression(GQLPluginManager myPluginManager, IGraphDB myGraphDB, SecurityToken mySecurityToken, Int64 myTransactionToken) { AExpressionDefinition right; var op = GetOperatorBySymbol(_OperatorSymbol); if (op == null) { throw new OperatorDoesNotExistException(_OperatorSymbol); } right = new ValueDefinition(1); var binExpr = new BinaryExpressionDefinition("*", _Expression, right); binExpr.Validate(myPluginManager, myGraphDB, mySecurityToken, myTransactionToken); return(binExpr); }
public SelectDefinition(List <TypeReferenceDefinition> myTypeList, List <Tuple <AExpressionDefinition, string, SelectValueAssignment> > mySelectedElements, BinaryExpressionDefinition myWhereExpressionDefinition, List <IDChainDefinition> myGroupByIDs, BinaryExpressionDefinition myHaving, ulong?myLimit, ulong?myOffset, OrderByDefinition myOrderByDefinition, long myResolutionDepth) { TypeList = myTypeList; SelectedElements = mySelectedElements; WhereExpressionDefinition = myWhereExpressionDefinition; GroupByIDs = myGroupByIDs; Having = myHaving; Limit = myLimit; Offset = myOffset; OrderByDefinition = myOrderByDefinition; ResolutionDepth = myResolutionDepth; }
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 }
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 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 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; } } }
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> /// Adds a having to the selection /// </summary> /// <param name="myHavingExpression"></param> public void AddHavingToSelection(BinaryExpressionDefinition myHavingExpression) { _HavingExpression = myHavingExpression; }
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; } } }
/// <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 } }
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 }
private static IEnumerable<IVertex> ProcessBinaryExpression(BinaryExpressionDefinition binExpression, GQLPluginManager myPluginManager, IGraphDB myGraphDB, SecurityToken mySecurityToken, TransactionToken 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); }
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> /// returns a list of guids which match the tupleNode of the ListOfDBObjects object. /// </summary> public IEnumerable <Tuple <IVertex, Dictionary <String, object> > > GetCorrespondigDBObjectUUIDAsList(IVertexType myType, IVertexType validationType, GQLPluginManager myPluginManager, IGraphDB myGraphDB, SecurityToken mySecurityToken, Int64 myTransactionToken) { #region Evaluate tuple //ask guid-index of type foreach (TupleElement aTupleElement in TupleElements) { if (aTupleElement.Value is BinaryExpressionDefinition) { #region Binary Expression var aUniqueExpr = (BinaryExpressionDefinition)aTupleElement.Value; aUniqueExpr.Validate(myPluginManager, myGraphDB, mySecurityToken, myTransactionToken, validationType); var _graphResult = aUniqueExpr.Calculon(myPluginManager, myGraphDB, mySecurityToken, myTransactionToken, new CommonUsageGraph(myGraphDB, mySecurityToken, myTransactionToken)); foreach (var aDBO in _graphResult.Select(new LevelKey(validationType.ID, myGraphDB, mySecurityToken, myTransactionToken), null, true)) { yield return(new Tuple <IVertex, Dictionary <String, object> >(aDBO, aTupleElement.Parameters)); } #endregion } else { #region tuple node if (aTupleElement.Value is TupleDefinition) { var aTupleNode = (TupleDefinition)aTupleElement.Value; if (IsValidTupleNode(aTupleNode.TupleElements, myType, myPluginManager, myGraphDB, mySecurityToken, myTransactionToken)) { #region get partial results BinaryExpressionDefinition tempNode = null; foreach (TupleElement aElement in aTupleNode) { tempNode = (BinaryExpressionDefinition)aElement.Value; ValidateBinaryExpression(tempNode, validationType, myPluginManager, myGraphDB, mySecurityToken, myTransactionToken); var tempGraphResult = tempNode.Calculon(myPluginManager, myGraphDB, mySecurityToken, myTransactionToken, new CommonUsageGraph(myGraphDB, mySecurityToken, myTransactionToken)); foreach (var aDBO in tempGraphResult.Select(new LevelKey(validationType.ID, myGraphDB, mySecurityToken, myTransactionToken), null, true)) { yield return(new Tuple <IVertex, Dictionary <String, object> >(aDBO, aTupleElement.Parameters)); } } #endregion } } #endregion } } #endregion yield break; }