public override QueryResult Execute(IGraphDB myGraphDB, IGraphQL myGraphQL, GQLPluginManager myPluginManager, String myQuery, SecurityToken mySecurityToken, TransactionToken myTransactionToken)
{
_query = myQuery;
var vertexType = myGraphDB.GetVertexType<IVertexType>(
mySecurityToken,
myTransactionToken,
new RequestGetVertexType(_typeName),
(stats, vType) => vType);
_WhereExpression.Validate(myPluginManager, myGraphDB, mySecurityToken, myTransactionToken, vertexType);
var expressionGraph = _WhereExpression.Calculon(myPluginManager, myGraphDB, mySecurityToken,
myTransactionToken,
new CommonUsageGraph(myGraphDB, mySecurityToken,
myTransactionToken));
var toBeDeletedVertices =
expressionGraph.Select(
new LevelKey(vertexType.ID, myGraphDB, mySecurityToken, myTransactionToken),
null, true);
//TODO: do sth that is better than that: ew RequestDelete(new RequestGetVertices(_typeName, toBeDeletedVertices.Select(_ => _.VertexID))).
return myGraphDB.Delete<QueryResult>(
mySecurityToken,
myTransactionToken,
new RequestDelete(new RequestGetVertices(_typeName, toBeDeletedVertices.Select(_ => _.VertexID))).AddAttributes(_toBeDeletedAttributes),
CreateQueryResult);
}
public override QueryResult Execute(IGraphDB myGraphDB, IGraphQL myGraphQL, GQLPluginManager myPluginManager, String myQuery, SecurityToken mySecurityToken, TransactionToken myTransactionToken)
{
var sw = Stopwatch.StartNew();
QueryResult result = null;
if (_DumpFormat.ToString().ToUpper().Equals("GQL"))
{
var plugin = myPluginManager.GetAndInitializePlugin<IGraphDBExport>("GQLEXPORT");
if (plugin != null)
{
result = plugin.Export(_DumpDestination, _DumpableGrammar, myGraphDB, myGraphQL, mySecurityToken, myTransactionToken, _TypesToDump, _DumpType);
}
}
sw.Stop();
if (result != null)
{
return new QueryResult(myQuery, _DumpFormat.ToString(), (ulong)sw.ElapsedMilliseconds, result.TypeOfResult, result.Vertices, result.Error);
}
else
return null;
}
public override QueryResult Execute(IGraphDB myGraphDB, IGraphQL myGraphQL, GQLPluginManager myPluginManager, String myQuery, SecurityToken mySecurityToken, TransactionToken myTransactionToken)
{
Query = myQuery;
var indexDef = new IndexPredefinition(_IndexName);
indexDef.SetIndexType(_IndexType);
indexDef.SetVertexType(_DBType);
indexDef.SetEdition(_IndexEdition);
//to be indices attributes
foreach (var aIndexedProperty in _AttributeList)
{
indexDef.AddProperty(aIndexedProperty.IndexAttribute.ContentString);
}
//options for the index
if (_options != null)
{
foreach (var aKV in _options)
{
indexDef.AddOption(aKV.Key, aKV.Value);
}
}
return myGraphDB.CreateIndex<QueryResult>(mySecurityToken, myTransactionToken, new RequestCreateIndex(indexDef), GenerateResult);
}
public override QueryResult Execute(IGraphDB myGraphDB,
IGraphQL myGraphQL,
GQLPluginManager myPluginManager,
String myQuery,
SecurityToken mySecurityToken,
Int64 myTransactionToken)
{
_queryString = myQuery;
QueryResult result;
try
{
result = myGraphDB.Insert<QueryResult>(
mySecurityToken,
myTransactionToken,
CreateRequest(myPluginManager,
myGraphDB,
mySecurityToken,
myTransactionToken),
CreateQueryResult);
}
catch (ASonesException e)
{
result = new QueryResult(_queryString, SonesGQLConstants.GQL, 0, ResultType.Failed, null, e);
}
return result;
}
public override QueryResult GetResult(
GQLPluginManager myPluginManager,
IGraphDB myGraphDB,
SecurityToken mySecurityToken,
TransactionToken myTransactionToken)
{
var resultingVertices = new List<IVertexView>();
ASonesException error = null;
#region Specific index
var request = new RequestDescribeIndex(_TypeName, _IndexName, _IndexEdition);
var indices = myGraphDB.DescribeIndex<IEnumerable<IIndexDefinition>>(mySecurityToken, myTransactionToken, request, (stats, definitions) => definitions);
if (indices == null)
{
error = new IndexTypeDoesNotExistException(_TypeName, _IndexName);
}
if (String.IsNullOrEmpty(_IndexEdition))
{
//_IndexEdition = DBConstants.DEFAULTINDEX;
}
resultingVertices = new List<IVertexView>() { GenerateOutput(indices, _IndexName) };
#endregion
if(error != null)
return new QueryResult("", SonesGQLConstants.GQL, 0L, ResultType.Failed, resultingVertices, error);
else
return new QueryResult("", SonesGQLConstants.GQL, 0L, ResultType.Successful, resultingVertices);
}
public override QueryResult GetResult( GQLPluginManager myPluginManager,
IGraphDB myGraphDB,
SecurityToken mySecurityToken,
Int64 myTransactionToken)
{
var resultingVertices = new List<IVertexView>();
ASonesException error = null;
if (!String.IsNullOrEmpty(_EdgeName))
{
#region Specific edge
var request = new RequestGetEdgeType(_EdgeName);
var edge = myGraphDB.GetEdgeType<IEdgeType>(mySecurityToken,
myTransactionToken,
request,
(stats, edgeType) => edgeType);
if (edge != null)
{
resultingVertices = new List<IVertexView>() { GenerateOutput(edge, _EdgeName) };
}
else
{
error = new EdgeTypeDoesNotExistException(_EdgeName);
}
#endregion
}
else
{
#region All edges
var resultingReadouts = new List<IVertexView>();
var request = new RequestGetAllEdgeTypes();
foreach (var edge in myGraphDB.GetAllEdgeTypes<IEnumerable<IEdgeType>>(mySecurityToken,
myTransactionToken,
request,
(stats, edgeTypes) => edgeTypes))
{
resultingReadouts.Add(GenerateOutput(edge, edge.Name));
}
#endregion
}
if(error != null)
return new QueryResult("", SonesGQLConstants.GQL, 0L, ResultType.Failed, resultingVertices, error);
else
return new QueryResult("", SonesGQLConstants.GQL, 0L, ResultType.Successful, resultingVertices);
}
public override QueryResult Execute(IGraphDB myGraphDB, IGraphQL myGraphQL, GQLPluginManager myPluginManager, String myQuery, SecurityToken mySecurityToken, Int64 myTransactionToken)
{
_query = myQuery;
return myGraphDB.AlterVertexType<QueryResult>(
mySecurityToken,
myTransactionToken,
CreateNewRequest(myGraphDB, myPluginManager, mySecurityToken, myTransactionToken),
CreateOutput);
}
public override IEnumerable<IVertexView> GetResult(
GQLPluginManager myPluginManager,
IGraphDB myGraphDB,
SecurityToken mySecurityToken,
Int64 myTransactionToken)
{
var resultingVertices = new List<IVertexView>();
if (!String.IsNullOrEmpty(_EdgeName))
{
#region Specific edge
var request = new RequestGetEdgeType(_EdgeName);
var edge = myGraphDB.GetEdgeType<IEdgeType>(mySecurityToken,
myTransactionToken,
request,
(stats, edgeType) => edgeType);
if (edge != null)
{
resultingVertices = new List<IVertexView>() { GenerateOutput(edge, _EdgeName) };
}
else
{
throw new EdgeTypeDoesNotExistException(_EdgeName);
}
#endregion
}
else
{
#region All edges
var resultingReadouts = new List<IVertexView>();
var request = new RequestGetAllEdgeTypes();
foreach (var edge in myGraphDB.GetAllEdgeTypes<IEnumerable<IEdgeType>>(mySecurityToken,
myTransactionToken,
request,
(stats, edgeTypes) => edgeTypes))
{
resultingReadouts.Add(GenerateOutput(edge, edge.Name));
}
#endregion
}
return resultingVertices;
}
public override QueryResult Execute(IGraphDB myGraphDB, IGraphQL myGraphQL, GQLPluginManager myPluginManager, String myQuery, SecurityToken mySecurityToken, Int64 myTransactionToken)
{
var sw = Stopwatch.StartNew();
QueryResult result = null;
_query = myQuery;
String myAction = "";
IEnumerable<IVertex> myToBeUpdatedVertices = null;
//prepare
var vertexType = myGraphDB.GetVertexType<IVertexType>(
mySecurityToken,
myTransactionToken,
new RequestGetVertexType(_Type),
(stats, vtype) => vtype);
if (_WhereExpression != null)
{
//validate
_WhereExpression.Validate(myPluginManager, myGraphDB, mySecurityToken, myTransactionToken, vertexType);
//calculate
var expressionGraph = _WhereExpression.Calculon(myPluginManager, myGraphDB, mySecurityToken, myTransactionToken, new CommonUsageGraph(myGraphDB, mySecurityToken, myTransactionToken), false);
//extract
myToBeUpdatedVertices = expressionGraph.Select(new LevelKey(vertexType.ID, myGraphDB, mySecurityToken, myTransactionToken), null, true).ToList();
}
if (myToBeUpdatedVertices != null && myToBeUpdatedVertices.Count() > 0)
{
//update
result = ProcessUpdate(myToBeUpdatedVertices, myGraphDB, myPluginManager, mySecurityToken, myTransactionToken);
myAction = "Updated";
}
else
{
//insert
result = ProcessInsert(myGraphDB, myPluginManager, mySecurityToken, myTransactionToken);
myAction = "Inserted";
}
if (result.Error != null)
throw result.Error;
sw.Stop();
return GenerateResult(sw.Elapsed.TotalMilliseconds, result, myAction);
}
public override IQueryResult Execute(IGraphDB myGraphDB, IGraphQL myGraphQL, GQLPluginManager myPluginManager, String myQuery, SecurityToken mySecurityToken, Int64 myTransactionToken)
{
try
{
var request = new RequestRebuildIndices(_Types);
return myGraphDB.RebuildIndices<IQueryResult>(mySecurityToken, myTransactionToken, request, _=> GenerateOutput(myQuery, _));
}
catch (ASonesException ex)
{
return QueryResult.Failure(myQuery, SonesGQLConstants.GQL, ex);
}
}
public override IQueryResult Execute(IGraphDB myGraphDB, IGraphQL myGraphQL, GQLPluginManager myPluginManager, String myQuery, SecurityToken mySecurityToken, Int64 myTransactionToken)
{
try
{
var stat = myGraphDB.Truncate(mySecurityToken, myTransactionToken, new RequestTruncate(_TypeName), (stats) => stats);
return QueryResult.Success(myQuery, SonesGQLConstants.GQL, null, Convert.ToUInt64(stat.ExecutionTime.Milliseconds));
}
catch(ASonesException e)
{
return QueryResult.Failure(myQuery, SonesGQLConstants.GQL, e);
}
}
public override IQueryResult Execute(IGraphDB myGraphDB,
IGraphQL myGraphQL,
GQLPluginManager myPluginManager,
String myQuery,
SecurityToken mySecurityToken,
Int64 myTransactionToken)
{
_query = myQuery;
return myGraphDB.DropEdgeType(mySecurityToken,
myTransactionToken,
new RequestDropEdgeType(_TypeName),
GenerateOutput);
}
/// <summary>
/// <seealso cref=" ADescribeDefinition"/>
/// </summary>
public override QueryResult GetResult(GQLPluginManager myPluginManager,
IGraphDB myGraphDB,
SecurityToken mySecurityToken,
TransactionToken myTransactionToken)
{
var resultingVertices = new List<IVertexView>();
ASonesException error = null;
if (!String.IsNullOrEmpty(_TypeName))
{
#region Specific type
var request = new RequestGetVertexType(_TypeName);
var type = myGraphDB.GetVertexType<IVertexType>(mySecurityToken, myTransactionToken, request, (stats, vertexType) => vertexType);
if (type != null)
{
resultingVertices = new List<IVertexView>() { (GenerateOutput(type, 1)) };
}
else
{
error = new VertexTypeDoesNotExistException(_TypeName, "");
}
#endregion
}
else
{
#region All types
foreach (var type in myGraphDB.GetAllVertexTypes<IEnumerable<IVertexType>>(mySecurityToken,
myTransactionToken,
new RequestGetAllVertexTypes(),
(stats, vertexTypes) => vertexTypes))
{
resultingVertices.Add(GenerateOutput(type));
}
#endregion
}
if (error != null)
return new QueryResult("", SonesGQLConstants.GQL, 0L, ResultType.Failed, resultingVertices, error);
else
return new QueryResult("", SonesGQLConstants.GQL, 0L, ResultType.Successful, resultingVertices);
}
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 override QueryResult Execute(IGraphDB myGraphDB, IGraphQL myGraphQL, GQLPluginManager myPluginManager, String myQuery, SecurityToken mySecurityToken, TransactionToken myTransactionToken)
{
QueryResult result = new QueryResult(myQuery, SonesGQLConstants.GQL, 0L, ResultType.Failed);
try
{
var stat = myGraphDB.Truncate(mySecurityToken, myTransactionToken, new RequestTruncate(_TypeName), (stats) => stats);
result = new QueryResult(myQuery, SonesGQLConstants.GQL, Convert.ToUInt64(stat.ExecutionTime.Milliseconds), ResultType.Successful);
}
catch(ASonesException e)
{
result = new QueryResult(myQuery, SonesGQLConstants.GQL, 0, ResultType.Failed, null, e);
}
return result;
}
/// <summary>
/// <seealso cref=" ADescribeDefinition"/>
/// </summary>
public override IEnumerable<IVertexView> GetResult(GQLPluginManager myPluginManager,
IGraphDB myGraphDB,
SecurityToken mySecurityToken,
Int64 myTransactionToken)
{
var resultingVertices = new List<IVertexView>();
if (!String.IsNullOrEmpty(_TypeName))
{
#region Specific type
var request = new RequestGetVertexType(_TypeName);
var type = myGraphDB.GetVertexType<IVertexType>(mySecurityToken, myTransactionToken, request, (stats, vertexType) => vertexType);
if (type != null)
{
resultingVertices = new List<IVertexView>() { (GenerateOutput(type, 1)) };
}
else
{
throw new VertexTypeDoesNotExistException(_TypeName, "");
}
#endregion
}
else
{
#region All types
foreach (var type in myGraphDB.GetAllVertexTypes<IEnumerable<IVertexType>>(mySecurityToken,
myTransactionToken,
new RequestGetAllVertexTypes(),
(stats, vertexTypes) => vertexTypes))
{
resultingVertices.Add(GenerateOutput(type));
}
#endregion
}
return resultingVertices;
}
public override QueryResult Execute(IGraphDB myGraphDB, IGraphQL myGraphQL, GQLPluginManager myPluginManager, String myQuery, SecurityToken mySecurityToken, TransactionToken myTransactionToken)
{
QueryResult qresult = null;
ASonesException error = null;
try
{
var stat = myGraphDB.DropIndex(mySecurityToken, myTransactionToken, new RequestDropIndex(_TypeName, _IndexName, _IndexEdition), (stats) => stats);
qresult = new QueryResult(myQuery, "sones.gql", Convert.ToUInt64(stat.ExecutionTime.Milliseconds), ResultType.Successful);
}
catch (ASonesException e)
{
error = e;
}
return new QueryResult(myQuery, "sones.gql", qresult.Duration, qresult.TypeOfResult, qresult.Vertices, error);
}
public override QueryResult Execute(IGraphDB myGraphDB, IGraphQL myGraphQL, GQLPluginManager myPluginManager, String myQuery, SecurityToken mySecurityToken, TransactionToken myTransactionToken)
{
QueryResult qresult = null;
Query = myQuery;
try
{
var request = new RequestRebuildIndices(_Types);
qresult = myGraphDB.RebuildIndices<QueryResult>(mySecurityToken, myTransactionToken, request, GenerateOutput);
}
catch (ASonesException e)
{
qresult.Error = e;
}
return qresult;
}
public override QueryResult Execute(IGraphDB myGraphDB, IGraphQL myGraphQL, GQLPluginManager myPluginManager, String myQuery, SecurityToken mySecurityToken, Int64 myTransactionToken)
{
var sw = Stopwatch.StartNew();
QueryResult qresult = null;
ASonesException error = null;
try
{
qresult = _DescribeDefinition.GetResult(myPluginManager, myGraphDB, mySecurityToken, myTransactionToken);
}
catch (ASonesException e)
{
error = e;
}
sw.Stop();
return new QueryResult(myQuery, "sones.gql", (ulong)sw.ElapsedMilliseconds, qresult != null ? qresult.TypeOfResult : ResultType.Failed, qresult != null ? qresult.Vertices : new IVertexView[0], error);
}
public override QueryResult Execute(IGraphDB myGraphDB, IGraphQL myGraphQL, GQLPluginManager myPluginManager, String myQuery, SecurityToken mySecurityToken, TransactionToken myTransactionToken)
{
_query = myQuery;
QueryResult result;
try
{
result = myGraphDB.CreateVertexTypes<QueryResult>(
mySecurityToken,
myTransactionToken,
new RequestCreateVertexTypes(GenerateVertexTypePredefinitions()),
CreateQueryResult);
}
catch (ASonesException e)
{
result = new QueryResult(_query, SonesGQLConstants.GQL, 0, ResultType.Failed, null, e);
}
return result;
}
public override IEnumerable<IVertexView> GetResult(
GQLPluginManager myPluginManager,
IGraphDB myGraphDB,
SecurityToken mySecurityToken,
Int64 myTransactionToken)
{
IEnumerable<IVertexView> resultingVertices = new List<IVertexView>();
#region Specific index
var request = new RequestDescribeIndex(_TypeName, _IndexName, _IndexEdition);
IEnumerable<IIndexDefinition> indices = null;
if (request.IndexName == String.Empty && request.TypeName == String.Empty && request.Edition == String.Empty)
{
indices = myGraphDB.DescribeIndices<IEnumerable<IIndexDefinition>>(mySecurityToken, myTransactionToken, request, (stats, definitions) => definitions);
}
else
{
indices = myGraphDB.DescribeIndex<IEnumerable<IIndexDefinition>>(mySecurityToken, myTransactionToken, request, (stats, definitions) => definitions);
}
if (indices == null)
{
throw new IndexTypeDoesNotExistException(_TypeName, _IndexName);
}
if (String.IsNullOrEmpty(_IndexEdition))
{
//_IndexEdition = DBConstants.DEFAULTINDEX;
}
resultingVertices = GenerateOutput(indices, _IndexName);
return resultingVertices;
#endregion
}
public override IQueryResult Execute(IGraphDB myGraphDB,
IGraphQL myGraphQL,
GQLPluginManager myPluginManager,
String myQuery,
SecurityToken mySecurityToken,
Int64 myTransactionToken)
{
var sw = Stopwatch.StartNew();
try
{
var result = _DescribeDefinition.GetResult(myPluginManager,
myGraphDB,
mySecurityToken,
myTransactionToken);
return QueryResult.Success(myQuery, SonesGQLConstants.GQL, result, Convert.ToUInt64(sw.ElapsedMilliseconds));
}
catch (ASonesException ex)
{
return QueryResult.Failure(myQuery, SonesGQLConstants.GQL, ex);
}
}
public override QueryResult Execute(IGraphDB myGraphDB, IGraphQL myGraphQL, GQLPluginManager myPluginManager, String myQuery, SecurityToken mySecurityToken, Int64 myTransactionToken)
{
_query = myQuery;
//prepare
var vertexType = myGraphDB.GetVertexType<IVertexType>(
mySecurityToken,
myTransactionToken,
new RequestGetVertexType(_TypeName),
(stats, vtype) => vtype);
//validate
_whereExpression.Validate(myPluginManager, myGraphDB, mySecurityToken, myTransactionToken, vertexType);
//calculate
var expressionGraph = _whereExpression.Calculon(myPluginManager, myGraphDB, mySecurityToken, myTransactionToken, new CommonUsageGraph(myGraphDB, mySecurityToken, myTransactionToken), false);
//extract
var myToBeUpdatedVertices = expressionGraph.Select(new LevelKey(vertexType.ID, myGraphDB, mySecurityToken, myTransactionToken), null, true).ToList();
switch (myToBeUpdatedVertices.Count)
{
case 0:
//insert
throw new ReplaceException("There are no vertices that match the where expression, so it's not possible to execute a Replace statement. Try using InsertOrUpdate.");
case 1:
//delete
ProcessDelete(myToBeUpdatedVertices[0], myGraphDB, myPluginManager, mySecurityToken, myTransactionToken);
//insert
return ProcessInsert(myGraphDB, myPluginManager, mySecurityToken, myTransactionToken);
default:
//error
throw new NotImplementedQLException("It's currenty not implemented to InsertOrReplace more than one vertex");
}
}
private void ProcessUpdate(IVertexType vertexType, GQLPluginManager myPluginManager, IGraphDB myGraphDB, SecurityToken mySecurityToken, TransactionToken myTransactionToken, AAttributeAssignOrUpdateOrRemove aUpdate, ref RequestUpdate result)
{
if (aUpdate is AttributeAssignOrUpdateValue)
{
ProcessAttributeAssignOrUpdateValue((AttributeAssignOrUpdateValue)aUpdate, ref result);
}
else if (aUpdate is AttributeAssignOrUpdateList)
{
ProcessAttributeAssignOrUpdateList(vertexType, myPluginManager, myGraphDB, mySecurityToken, myTransactionToken, (AttributeAssignOrUpdateList)aUpdate, ref result);
}
else if (aUpdate is AttributeAssignOrUpdateSetRef)
{
ProcessAttributeAssignOrUpdateSetRef(vertexType, myPluginManager, myGraphDB, mySecurityToken, myTransactionToken, (AttributeAssignOrUpdateSetRef)aUpdate, ref result);
}
else if (aUpdate is AttributeRemove)
{
foreach (var aToBeRemovedAttribute in ((AttributeRemove)aUpdate).ToBeRemovedAttributes)
{
result.RemoveAttribute(aToBeRemovedAttribute);
}
}
else if (aUpdate is AttributeRemoveList)
{
ProcessAttributeRemoveList(vertexType, myPluginManager, myGraphDB, mySecurityToken, myTransactionToken, (AttributeRemoveList)aUpdate, ref result);
}
else
{
throw new NotImplementedQLException("");
}
}
private void ProcessListOfUpdates(IVertexType vertexType, GQLPluginManager myPluginManager, IGraphDB myGraphDB, SecurityToken mySecurityToken, TransactionToken myTransactionToken, ref RequestUpdate result)
{
foreach (var aUpdate in _listOfUpdates)
{
ProcessUpdate(vertexType, myPluginManager, myGraphDB, mySecurityToken, myTransactionToken, aUpdate, ref result);
}
}
private void ProcessAttributeRemoveList(IVertexType vertexType, GQLPluginManager myPluginManager, IGraphDB myGraphDB, SecurityToken mySecurityToken, TransactionToken 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();
}
}
private void ProcessAttributeAssignOrUpdateSetRef(IVertexType vertexType, GQLPluginManager myPluginManager, IGraphDB myGraphDB, SecurityToken mySecurityToken, TransactionToken myTransactionToken, AttributeAssignOrUpdateSetRef attributeAssignOrUpdateSetRef, ref RequestUpdate result)
{
#region SetRefNode
var edgeDefinition = new EdgePredefinition(attributeAssignOrUpdateSetRef.AttributeIDChain.ContentString);
if (attributeAssignOrUpdateSetRef.SetRefDefinition.IsREFUUID)
{
#region direct vertex ids
foreach (var aTupleElement in attributeAssignOrUpdateSetRef.SetRefDefinition.TupleDefinition)
{
if (aTupleElement.Value is ValueDefinition)
{
#region ValueDefinition
foreach (var aProperty in aTupleElement.Parameters)
{
edgeDefinition.AddUnknownProperty(aProperty.Key, aProperty.Value);
}
edgeDefinition.AddVertexID(
attributeAssignOrUpdateSetRef.SetRefDefinition.ReferencedVertexType,
Convert.ToInt64(((ValueDefinition)aTupleElement.Value).Value));
#endregion
}
else
{
throw new NotImplementedQLException("TODO");
}
}
result.UpdateEdge(edgeDefinition);
#endregion
}
else
{
#region expression
if (!vertexType.HasAttribute(attributeAssignOrUpdateSetRef.AttributeIDChain.ContentString))
{
throw new InvalidVertexAttributeException(String.Format("The vertex type {0} has no attribute named {1}.", vertexType.Name, attributeAssignOrUpdateSetRef.AttributeIDChain.ContentString));
}
IAttributeDefinition attribute = vertexType.GetAttributeDefinition(attributeAssignOrUpdateSetRef.AttributeIDChain.ContentString);
foreach (var aTupleElement in attributeAssignOrUpdateSetRef.SetRefDefinition.TupleDefinition)
{
if (aTupleElement.Value is BinaryExpressionDefinition)
{
#region BinaryExpressionDefinition
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));
}
var inneredge = new EdgePredefinition();
foreach (var aStructuredProperty in aTupleElement.Parameters)
{
edgeDefinition.AddUnknownProperty(aStructuredProperty.Key, aStructuredProperty.Value);
}
edgeDefinition.AddVertexID(vertexIDs.FirstOrDefault().VertexTypeID, vertexIDs.FirstOrDefault().VertexID);
#endregion
}
else
{
throw new NotImplementedQLException("");
}
}
#endregion
result.UpdateEdge(edgeDefinition);
return;
}
#endregion
}
private void ProcessAttributeAssignOrUpdateList(IVertexType vertexType, GQLPluginManager myPluginManager, IGraphDB myGraphDB, SecurityToken mySecurityToken, TransactionToken myTransactionToken, AttributeAssignOrUpdateList attributeAssignOrUpdateList, ref RequestUpdate result)
{
Type myRequestedType;
switch (attributeAssignOrUpdateList.CollectionDefinition.CollectionType)
{
case CollectionType.Set:
#region set
if (((TupleDefinition)attributeAssignOrUpdateList.CollectionDefinition.TupleDefinition).All(_ => _.Value is ValueDefinition))
{
#region base-set
//has to be list of comparables
SetCollectionWrapper setWrapper = new SetCollectionWrapper();
if (vertexType.HasProperty(attributeAssignOrUpdateList.AttributeIDChain.ContentString))
{
myRequestedType = ((IPropertyDefinition)vertexType.GetAttributeDefinition(attributeAssignOrUpdateList.AttributeIDChain.ContentString)).BaseType;
}
else
{
myRequestedType = typeof(String);
}
foreach (var aTupleElement in (TupleDefinition)attributeAssignOrUpdateList.CollectionDefinition.TupleDefinition)
{
setWrapper.Add(((ValueDefinition)aTupleElement.Value).Value.ConvertToIComparable(myRequestedType));
}
result.AddElementsToCollection(attributeAssignOrUpdateList.AttributeIDChain.ContentString, setWrapper);
#endregion
}
else
{
#region edge-set
EdgePredefinition edgeDefinition = new EdgePredefinition(attributeAssignOrUpdateList.AttributeIDChain.ContentString);
if (!vertexType.HasAttribute(attributeAssignOrUpdateList.AttributeIDChain.ContentString))
{
throw new InvalidVertexAttributeException(String.Format("The vertex type {0} has no attribute named {1}.", vertexType.Name, attributeAssignOrUpdateList.AttributeIDChain.ContentString));
}
IAttributeDefinition attribute = vertexType.GetAttributeDefinition(attributeAssignOrUpdateList.AttributeIDChain.ContentString);
foreach (var aTupleElement in (TupleDefinition)attributeAssignOrUpdateList.CollectionDefinition.TupleDefinition)
{
if (aTupleElement.Value is BinaryExpressionDefinition)
{
#region BinaryExpressionDefinition
var targetVertexType = ((IOutgoingEdgeDefinition)attribute).TargetVertexType;
foreach (var aVertex in ProcessBinaryExpression(
(BinaryExpressionDefinition)aTupleElement.Value,
myPluginManager, myGraphDB, mySecurityToken, myTransactionToken, targetVertexType))
{
var inneredge = new EdgePredefinition().AddVertexID(aVertex.VertexTypeID, aVertex.VertexID);
foreach (var aStructuredProperty in aTupleElement.Parameters)
{
inneredge.AddUnknownProperty(aStructuredProperty.Key, aStructuredProperty.Value);
}
edgeDefinition.AddEdge(inneredge);
}
#endregion
}
else
{
throw new NotImplementedQLException("TODO");
}
}
if (attributeAssignOrUpdateList.Assign)
{
result.UpdateEdge(edgeDefinition);
}
else
{
result.AddElementsToCollection(attributeAssignOrUpdateList.AttributeIDChain.ContentString, edgeDefinition);
}
#endregion
}
#endregion
return;
case CollectionType.List:
#region list
//has to be list of comparables
ListCollectionWrapper listWrapper = new ListCollectionWrapper();
if (vertexType.HasProperty(attributeAssignOrUpdateList.AttributeIDChain.ContentString))
{
myRequestedType = ((IPropertyDefinition)vertexType.GetAttributeDefinition(attributeAssignOrUpdateList.AttributeIDChain.ContentString)).BaseType;
}
else
{
myRequestedType = typeof(String);
}
foreach (var aTupleElement in (TupleDefinition)attributeAssignOrUpdateList.CollectionDefinition.TupleDefinition)
{
listWrapper.Add(((ValueDefinition)aTupleElement.Value).Value.ConvertToIComparable(myRequestedType));
}
result.AddElementsToCollection(attributeAssignOrUpdateList.AttributeIDChain.ContentString, listWrapper);
#endregion
return;
case CollectionType.SetOfUUIDs:
#region SetOfUUIDs
EdgePredefinition anotheredgeDefinition = new EdgePredefinition(attributeAssignOrUpdateList.AttributeIDChain.ContentString);
foreach (var aTupleElement in ((VertexTypeVertexIDCollectionNode)attributeAssignOrUpdateList.CollectionDefinition.TupleDefinition).Elements)
{
foreach (var aVertexIDTuple in aTupleElement.VertexIDs)
{
var innerEdge = new EdgePredefinition();
foreach (var aStructuredProperty in aVertexIDTuple.Item2)
{
innerEdge.AddUnknownProperty(aStructuredProperty.Key, aStructuredProperty.Value);
}
innerEdge.AddVertexID(aTupleElement.ReferencedVertexTypeName, aVertexIDTuple.Item1);
anotheredgeDefinition.AddEdge(innerEdge);
}
}
result.AddElementsToCollection(attributeAssignOrUpdateList.AttributeIDChain.ContentString, anotheredgeDefinition);
#endregion
return;
default:
return;
}
}
private RequestUpdate GenerateUpdateRequest(IGraphDB myGraphDB, GQLPluginManager myPluginManager, SecurityToken mySecurityToken, TransactionToken myTransactionToken)
{
IEnumerable<IVertex> toBeupdatedVertices = null;
//prepare
var vertexType = myGraphDB.GetVertexType<IVertexType>(
mySecurityToken,
myTransactionToken,
new RequestGetVertexType(_TypeName),
(stats, vtype) => vtype);
if (_vertexIDs == null)
{
if (_WhereExpression != null)
{
//validate
_WhereExpression.Validate(myPluginManager, myGraphDB, mySecurityToken, myTransactionToken, vertexType);
//calculate
var expressionGraph = _WhereExpression.Calculon(myPluginManager, myGraphDB, mySecurityToken, myTransactionToken, new CommonUsageGraph(myGraphDB, mySecurityToken, myTransactionToken), false);
//extract
toBeupdatedVertices = expressionGraph.Select(new LevelKey(vertexType.ID, myGraphDB, mySecurityToken, myTransactionToken), null, true);
}
else
{
toBeupdatedVertices = myGraphDB.GetVertices<IEnumerable<IVertex>>(
mySecurityToken,
myTransactionToken,
new RequestGetVertices(vertexType.ID),
(stats, vertices) => vertices);
}
}
else
{
toBeupdatedVertices = _vertexIDs;
}
var result = new RequestUpdate(new RequestGetVertices(vertexType.ID, toBeupdatedVertices.Select(_ => _.VertexID) , false));
ProcessListOfUpdates(vertexType, myPluginManager, myGraphDB, mySecurityToken, myTransactionToken, ref result);
return result;
}
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);
}
