public void DirectInit(ParsingContext context, ParseTreeNode parseNode)
        {
            var idChain         = ((IDNode)parseNode.ChildNodes[2].AstNode).IDChainDefinition;
            var tupleDefinition = ((TupleNode)parseNode.ChildNodes[3].AstNode).TupleDefinition;
            var AttrName        = parseNode.ChildNodes[2].FirstChild.FirstChild.Token.ValueString;

            ToBeRemovedList = new AttributeRemoveList(idChain, AttrName, tupleDefinition);
        }
        public void DirectInit(ParsingContext context, ParseTreeNode parseNode)
        {
            var idChain    = ((IDNode)parseNode.ChildNodes[0].AstNode).IDChainDefinition;
            var AttrName   = parseNode.ChildNodes[0].FirstChild.Token.ValueString;
            var definition = ((RemoveFromListAttrUpdateScopeNode)parseNode.ChildNodes[1].AstNode).TupleDefinition;

            AttributeRemoveList = new AttributeRemoveList(idChain, AttrName, definition);
        }
예제 #3
0
        private void ProcessAttributeRemoveList(IVertexType vertexType,
                                                GQLPluginManager myPluginManager,
                                                IGraphDB myGraphDB,
                                                SecurityToken mySecurityToken,
                                                Int64 myTransactionToken,
                                                AttributeRemoveList attributeRemoveList,
                                                ref RequestUpdate result)
        {
            if (attributeRemoveList.TupleDefinition is VertexTypeVertexIDCollectionNode)
            {
                #region setofUUIDs

                var edgedef = new EdgePredefinition(attributeRemoveList.AttributeName);

                List <EdgePredefinition> toBeRemovedEdges = new List <EdgePredefinition>();

                foreach (var aTupleElement in ((VertexTypeVertexIDCollectionNode)attributeRemoveList.TupleDefinition).Elements)
                {
                    foreach (var aVertexIDTuple in aTupleElement.VertexIDs)
                    {
                        var innerEdge = new EdgePredefinition();

                        innerEdge.AddVertexID(aTupleElement.ReferencedVertexTypeName, aVertexIDTuple.Item1);

                        edgedef.AddEdge(innerEdge);
                    }
                }

                result.RemoveElementsFromCollection(attributeRemoveList.AttributeName, edgedef);

                #endregion
            }
            else if (attributeRemoveList.TupleDefinition is TupleDefinition)
            {
                if (((TupleDefinition)attributeRemoveList.TupleDefinition).All(_ => _.Value is ValueDefinition))
                {
                    #region base-set

                    //has to be list of comparables
                    ListCollectionWrapper listWrapper = new ListCollectionWrapper();
                    Type myRequestedType;
                    if (vertexType.HasProperty(attributeRemoveList.AttributeIDChain.ContentString))
                    {
                        myRequestedType = ((IPropertyDefinition)vertexType.GetAttributeDefinition(attributeRemoveList.AttributeIDChain.ContentString)).BaseType;
                    }
                    else
                    {
                        myRequestedType = typeof(String);
                    }

                    foreach (var aTupleElement in (TupleDefinition)attributeRemoveList.TupleDefinition)
                    {
                        listWrapper.Add(((ValueDefinition)aTupleElement.Value).Value.ConvertToIComparable(myRequestedType));
                    }

                    result.RemoveElementsFromCollection(attributeRemoveList.AttributeIDChain.ContentString, listWrapper);

                    #endregion
                }
                else
                {
                    #region binaryExpression

                    Dictionary <String, EdgePredefinition> toBeRemovedEdges = new Dictionary <String, EdgePredefinition>();

                    foreach (var aTupleElement in ((TupleDefinition)attributeRemoveList.TupleDefinition))
                    {
                        if (aTupleElement.Value is BinaryExpressionDefinition)
                        {
                            #region BinaryExpressionDefinition

                            if (!vertexType.HasAttribute(attributeRemoveList.AttributeName))
                            {
                                throw new InvalidVertexAttributeException(String.Format("The vertex type {0} has no attribute named {1}.", vertexType.Name, attributeRemoveList.AttributeName));
                            }

                            IAttributeDefinition attribute = vertexType.GetAttributeDefinition(attributeRemoveList.AttributeName);

                            var targetVertexType = ((IOutgoingEdgeDefinition)attribute).TargetVertexType;

                            var vertexIDs = ProcessBinaryExpression(
                                (BinaryExpressionDefinition)aTupleElement.Value,
                                myPluginManager, myGraphDB, mySecurityToken, myTransactionToken, targetVertexType).ToList();

                            if (vertexIDs.Count > 1)
                            {
                                throw new ReferenceAssignmentExpectedException(String.Format("It is not possible to create a single edge pointing to {0} vertices", vertexIDs.Count));
                            }

                            EdgePredefinition outValue = null;

                            if (toBeRemovedEdges.TryGetValue(attributeRemoveList.AttributeName, out outValue))
                            {
                                foreach (var aVertex in vertexIDs)
                                {
                                    outValue.AddEdge(new EdgePredefinition().AddVertexID(aVertex.VertexTypeID, aVertex.VertexID));
                                }
                            }
                            else
                            {
                                EdgePredefinition edge = new EdgePredefinition(attributeRemoveList.AttributeName);

                                foreach (var aVertex in vertexIDs)
                                {
                                    edge.AddEdge(new EdgePredefinition().AddVertexID(aVertex.VertexTypeID, aVertex.VertexID));
                                }

                                toBeRemovedEdges.Add(attributeRemoveList.AttributeName, edge);
                            }

                            #endregion
                        }
                        else
                        {
                            throw new NotImplementedQLException("");
                        }
                    }

                    foreach (var item in toBeRemovedEdges)
                    {
                        result.RemoveElementsFromCollection(item.Key, item.Value);
                    }

                    #endregion
                }
            }
            else
            {
                throw new NotImplementedException();
            }
        }