/// <summary> /// /// </summary> /// <param name="myStore"></param> /// <param name="myVertexID"></param> /// <param name="myVertexTypeID"></param> /// <param name="myEdition"></param> /// <param name="myComment"></param> /// <param name="myEdges"></param> /// <param name="myStructuredProperties"></param> /// <param name="myUnstructuredProperties"></param> private static IVertex Store( IVertexStore myStore, VertexInformation mySource, String myComment, Int64 myCreationDate, IDictionary<Tuple<Int64, Int64>, VertexInformation> mySingleEdges, IDictionary<Tuple<Int64, Int64>, IEnumerable<VertexInformation>> myHyperEdges, IDictionary<Int64, IComparable> myStructuredProperties, IDictionary<String, Object> myUnstructuredProperties, SecurityToken mySecurity, TransactionToken myTransaction) { VertexAddDefinition def = new VertexAddDefinition( mySource.VertexID, mySource.VertexTypeID, mySource.VertexEditionName, CreateHyperEdgeDefinitions(myHyperEdges, mySource, myCreationDate), CreateSingleEdgeDefinitions(mySingleEdges, mySource, myCreationDate), null, null, myComment, myCreationDate, myCreationDate, myStructuredProperties, myUnstructuredProperties); return myStore.AddVertex(mySecurity, myTransaction, def); }
public IVertex AddVertex(SecurityToken mySecurityToken, TransactionToken myTransactionToken, VertexAddDefinition myVertexDefinition, Int64 myVertexRevisionID = 0L, bool myCreateIncomingEdges = true) { return _vertexStore.AddVertex(mySecurityToken, myTransactionToken, myVertexDefinition, myVertexRevisionID, myCreateIncomingEdges); }
private void AddEdgesToVertex(VertexAddDefinition myVertexDefinition, InMemoryVertex myVertex, Dictionary<Int64, IEdge> myEdges) { SingleEdge singleEdge; InMemoryVertex targetVertex; #region single edges //create the single edges if (myVertexDefinition.OutgoingSingleEdges != null) { foreach (var aSingleEdgeDefinition in myVertexDefinition.OutgoingSingleEdges) { targetVertex = GetOrCreateTargetVertex(aSingleEdgeDefinition.TargetVertexInformation.VertexTypeID, aSingleEdgeDefinition.TargetVertexInformation.VertexID); //create the new Edge singleEdge = new SingleEdge(aSingleEdgeDefinition.EdgeTypeID, myVertex, targetVertex, aSingleEdgeDefinition.Comment, aSingleEdgeDefinition.CreationDate, aSingleEdgeDefinition.ModificationDate, aSingleEdgeDefinition.StructuredProperties, aSingleEdgeDefinition.UnstructuredProperties); CreateOrUpdateIncomingEdgesOnVertex( targetVertex, myVertexDefinition.VertexTypeID, aSingleEdgeDefinition.PropertyID, myVertex); myEdges.Add(aSingleEdgeDefinition.PropertyID, singleEdge); } } #endregion #region hyper edges if (myVertexDefinition.OutgoingHyperEdges != null) { foreach (var aHyperEdgeDefinition in myVertexDefinition.OutgoingHyperEdges) { var containedSingleEdges = new HashSet<SingleEdge>(); foreach (var aSingleEdgeDefinition in aHyperEdgeDefinition.ContainedSingleEdges) { targetVertex = GetOrCreateTargetVertex(aSingleEdgeDefinition.TargetVertexInformation.VertexTypeID, aSingleEdgeDefinition.TargetVertexInformation.VertexID); singleEdge = new SingleEdge(aSingleEdgeDefinition.EdgeTypeID, myVertex, targetVertex, aSingleEdgeDefinition.Comment, aSingleEdgeDefinition.CreationDate, aSingleEdgeDefinition.ModificationDate, aSingleEdgeDefinition.StructuredProperties, aSingleEdgeDefinition.UnstructuredProperties); CreateOrUpdateIncomingEdgesOnVertex( targetVertex, myVertexDefinition.VertexTypeID, aHyperEdgeDefinition.PropertyID, myVertex); containedSingleEdges.Add(singleEdge); } //create the new edge myEdges.Add( aHyperEdgeDefinition.PropertyID, new HyperEdge( containedSingleEdges, aHyperEdgeDefinition.EdgeTypeID, myVertex, aHyperEdgeDefinition.Comment, aHyperEdgeDefinition.CreationDate, aHyperEdgeDefinition.ModificationDate, aHyperEdgeDefinition.StructuredProperties, aHyperEdgeDefinition.UnstructuredProperties)); } } #endregion }
/* /// <summary> /// The entry point for the execution of an <GQL> tag. /// </summary> /// <param name="myGQLReader">An XmlReader, that is positioned before an <GQL> tag.</param> private void ExecuteGql(XmlReader myGQLReader) { _logger.Log(Level.FINE, "ExecuteGql started."); // if no xml is available, we have nothing to do. if (myGQLReader == null) //TODO: log something; return; try { myGQLReader.MoveToContent(); if (!CheckIsGqlElement(myGQLReader)) return ; String gql = null; while (myGQLReader.MoveToNextAttribute()) { switch (myGQLReader.LocalName) { case "Query": gql = myGQLReader.ReadContentAsString(); break; default: //TODO: log something break; } } if (gql == null) //TODO log something; return; var result = _ql.Query(_security, _transaction, gql); } finally { if (!_closed) myGQLReader.Close(); _logger.Log(Level.FINE, "ExecuteGql finished."); } } /// <summary> /// Logs the result of the import as Info. /// </summary> /// <param name="myResult"></param> private void logQueryResult(IQueryResult myResult) { throw new NotImplementedException(); } */ /// <summary> /// The entry point for the execution of an <Insert> tag. /// </summary> /// <param name="myInsertReader">An XmlReader, that is positioned before an <Insert> tag.</param> private void ExecuteInsert(XmlReader myInsertReader) { _logger.Log(Level.FINE, "ExecuteInsert started."); // if no xml is available, we have nothing to do. if (myInsertReader == null) //TODO: log something; return; try { myInsertReader.MoveToContent(); if (!CheckIsInsertElement(myInsertReader)) return; String vertexTypeName = null; long? id = null; while (myInsertReader.MoveToNextAttribute()) { switch (myInsertReader.LocalName) { case VertexTypeAttribute: vertexTypeName = myInsertReader.ReadContentAsString(); break; case VertexIDAttribute: id = myInsertReader.ReadContentAsLong(); break; default: //TODO: log something break; } } if (vertexTypeName == null) //TODO: log something; return; if (!id.HasValue) //TODO: log something; return; IDictionary<String, String> values = new Dictionary<String, String>(); List<SingleLink> singleLinks = new List<SingleLink>(); List<MultiLink> multiLinks = new List<MultiLink>(); while (!_closed && myInsertReader.Read()) { if (CheckIsElement(myInsertReader)) { var nextReader = myInsertReader.ReadSubtree(); switch (myInsertReader.LocalName) { case SetValueTag: var value = ExecuteSetValue(nextReader); if (value.HasValue) values.Add(value.Value); break; case SingleLinkTag: var singleLink = ExecuteSingleLink(nextReader); if (singleLink != null) singleLinks.Add(singleLink); break; case MultiLinkTag: var multiLink = ExecuteMultiLink(nextReader); if (multiLink != null) multiLinks.Add(multiLink); break; default: //TODO: log something break; } } } var vertextype = RetrieveVertexType(vertexTypeName); var vertexTypeID = vertextype.ID; var vertexID = id.Value; var edition = ExtractEdition(values); var comment = ExtractComment(values); var creation = ExtractCreationDate(values); var modification = ExtractModificationDate(values); var structured = ConvertStructuredProperties(values, vertextype); var unstructured = ConvertUnstructuredProperties(values); var source = new VertexInformation(vertexTypeID, vertexID); var hyper = ConvertOutgoingEdges(multiLinks, vertextype, source); var single = ConvertSingleEdges(singleLinks, vertextype, source); var forResultingFS = new VertexAddDefinition(vertexID, vertexTypeID, edition, hyper, single, null, null, comment, creation, modification, structured, unstructured); if(!_autoCreateIncomingEdges) AddEdgesToSorter(hyper, single); _resultingFS.AddVertex(_security, _transaction, forResultingFS, myCreateAutoIncomingEdges: _autoCreateIncomingEdges); } catch (Exception ex) { IXmlLineInfo info = myInsertReader as IXmlLineInfo; if (info != null && info.HasLineInfo()) { var line = info.LineNumber; var pos = info.LinePosition; _logger.Log(Level.INFO, "Exception thrown while reading line {0} position {1}.", line, pos); } #if DEBUG for (var current = ex; current != null; current = current.InnerException) { _logger.Log(Level.SEVERE, "An exception was thrown:{0}\n{1}", current.GetType().FullName, current.StackTrace.ToString()); } #else _logger.Log(Level.SEVERE, "An exception was thrown:\n{0}", ex); #endif } finally { _logger.Log(Level.FINE, "ExecuteGql finished."); if (!_closed) myInsertReader.Close(); } }
public IVertex AddVertex( SecurityToken mySecurityToken, Int64 myTransactionID, VertexAddDefinition myVertexDefinition, Int64 myVertexRevisionID = 0L, Boolean myCreateIncomingEdges = true) { #region create vertex type entry //check for vertex type if (!_vertexStore.ContainsKey(myVertexDefinition.VertexTypeID)) { _vertexStore.TryAdd(myVertexDefinition.VertexTypeID, new ConcurrentDictionary<long, InMemoryVertex>()); } #endregion #region create new vertex var vertexRevisionID = 0L; Dictionary<Int64, Stream> binaryProperties; if (myVertexDefinition.BinaryProperties == null) { binaryProperties = null; } else { binaryProperties = myVertexDefinition.BinaryProperties.ToDictionary(key => key.PropertyID, value => value.Stream); } Boolean addEdges = myVertexDefinition.OutgoingSingleEdges != null || myVertexDefinition.OutgoingHyperEdges != null; #endregion #region store the new vertex InMemoryVertex createdVertex = null; _vertexStore[myVertexDefinition.VertexTypeID]. AddOrUpdate(myVertexDefinition.VertexID, (anotherLong) => { Dictionary<long, IEdge> newEdge = null; if (addEdges) { newEdge = new Dictionary<long, IEdge>(); } InMemoryVertex toBeAddedVertex = new InMemoryVertex( myVertexDefinition.VertexID, myVertexDefinition.VertexTypeID, vertexRevisionID, myVertexDefinition.Edition, binaryProperties, newEdge, myVertexDefinition.Comment, myVertexDefinition.CreationDate, myVertexDefinition.ModificationDate, myVertexDefinition.StructuredProperties, myVertexDefinition.UnstructuredProperties); if (addEdges) { AddEdgesToVertex(myVertexDefinition, toBeAddedVertex, newEdge); } createdVertex = toBeAddedVertex; return toBeAddedVertex; }, (id, oldVertex) => { if (!oldVertex.IsBulkVertex) { throw new VertexAlreadyExistException(myVertexDefinition.VertexTypeID, myVertexDefinition.VertexID); } Dictionary<long, IEdge> oldEdge = null; if (addEdges) { oldEdge = new Dictionary<long, IEdge>(); } oldVertex.Activate( binaryProperties, oldEdge, myVertexDefinition.Comment, myVertexDefinition.CreationDate, myVertexDefinition.ModificationDate, myVertexDefinition.StructuredProperties, myVertexDefinition.UnstructuredProperties); if (addEdges) { AddEdgesToVertex(myVertexDefinition, oldVertex, oldEdge); } createdVertex = oldVertex; return oldVertex; }); #endregion return createdVertex; }