/// <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;
}
