/// <summary>
/// Creates a new sones GQL instance
/// </summary>
/// <param name="myIGraphDBInstace">The graph database instance on which the gql statements are executed</param>
public SonesQueryLanguage(IGraphDB myIGraphDBInstace)
{
_IGraphDBInstance = myIGraphDBInstace;
_settings = new GraphApplicationSettings(SonesGQLConstants.ApplicationSettingsLocation);
#region plugin manager
_GQLPluginManager = new GQLPluginManager();
#endregion
#region create gql grammar and set extendable members
_GQLGrammar = new SonesGQLGrammar(myIGraphDBInstace);
SetExtendableMember(_GQLGrammar);
#endregion
//build parser
_parser = new Parser(_GQLGrammar);
//check language
if (_parser.Language.ErrorLevel != GrammarErrorLevel.Warning && _parser.Language.ErrorLevel != GrammarErrorLevel.NoError)
{
throw new IronyInitializeGrammarException(_parser.Language.Errors, "");
}
}
/// <summary>
/// The returned IQueryResult contains vertices which are null if no Int64 is created,
/// otherwise they contain a vertexview with a property dictionary, where in first position is the created Int64
/// </summary>
public override IQueryResult Execute(IGraphDB myGraphDB, IGraphQL myGraphQL, GQLPluginManager myPluginManager, String myQuery, SecurityToken mySecurityToken, Int64 myTransactionToken)
{
var sw = Stopwatch.StartNew();
var myToken = myGraphDB.BeginTransaction(mySecurityToken, IsLongRunning, Isolation);
VertexView view = null;
var readoutVals = new Dictionary <String, Object>();
readoutVals.Add("TransactionID", myToken);
readoutVals.Add("Created", TimeStamp);
readoutVals.Add("Distributed", IsDistributed);
readoutVals.Add("IsolationLevel", Isolation);
readoutVals.Add("LongRunning", IsLongRunning);
readoutVals.Add("Name", Name);
view = new VertexView(readoutVals, null);
sw.Stop();
return(QueryResult.Success(myQuery, SonesGQLConstants.GQL, new List <IVertexView> {
view
}, Convert.ToUInt64(sw.ElapsedMilliseconds)));
}
/// <summary>
/// Creates the request for the graphdb
/// </summary>
/// <returns>The created vertex</returns>
private RequestInsertVertex CreateRequest(GQLPluginManager myPluginManager,
IGraphDB myGraphDB,
SecurityToken mySecurityToken,
Int64 myTransactionToken)
{
#region data
var result = new RequestInsertVertex(_TypeName);
var vertexType = myGraphDB.GetVertexType <IVertexType>(
mySecurityToken,
myTransactionToken,
new RequestGetVertexType(_TypeName),
(stats, vtype) => vtype);
#endregion
if (_AttributeAssignList != null)
{
foreach (var aAttributeDefinition in _AttributeAssignList)
{
ProcessAAttributeDefinition(myPluginManager,
myGraphDB,
mySecurityToken,
myTransactionToken,
vertexType,
aAttributeDefinition,
ref result);
}
}
return(result);
}
private IQueryResult ProcessInsert(IGraphDB myGraphDB, GQLPluginManager myPluginManager, SecurityToken mySecurityToken, Int64 myTransactionToken)
{
InsertNode insert = new InsertNode();
insert.Init(_TypeName, _AttributeAssignList);
return(insert.Execute(myGraphDB, null, myPluginManager, _query, mySecurityToken, myTransactionToken));
}
public override IQueryResult Execute(IGraphDB myGraphDB, IGraphQL myGraphQL, GQLPluginManager myPluginManager, String myQuery, SecurityToken mySecurityToken, Int64 myTransactionToken)
{
var sw = Stopwatch.StartNew();
_query = myQuery;
//prepare
var vertexType = myGraphDB.GetVertexType <IVertexType>(
mySecurityToken,
myTransactionToken,
new RequestGetVertexType(_SourceType),
(stats, vtype) => vtype);
//validate
_Condition.Validate(myPluginManager, myGraphDB, mySecurityToken, myTransactionToken, vertexType);
//calculate
var expressionGraph = _Condition.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();
if (myToBeUpdatedVertices.Count > 0)
{
//update
ProcessUpdate(myToBeUpdatedVertices, myGraphDB, myPluginManager, mySecurityToken, myTransactionToken);
}
sw.Stop();
return(GenerateResult(sw.Elapsed.TotalMilliseconds));
}
private static void ProcessAAttributeDefinition(GQLPluginManager myPluginManager,
IGraphDB myGraphDB,
SecurityToken mySecurityToken,
Int64 myTransactionToken,
IVertexType vertexType,
AAttributeAssignOrUpdate aAttributeDefinition,
ref RequestInsertVertex result)
{
if (vertexType.HasAttribute(aAttributeDefinition.AttributeIDChain.ContentString))
{
ProcessStructuredProperty(myPluginManager,
myGraphDB,
mySecurityToken,
myTransactionToken,
vertexType,
aAttributeDefinition,
ref result);
}
else
{
ProcessUnstructuredAttribute(vertexType,
aAttributeDefinition,
ref result);
}
}
public override IQueryResult Execute(IGraphDB myGraphDB,
IGraphQL myGraphQL,
GQLPluginManager myPluginManager,
String myQuery,
SecurityToken mySecurityToken,
Int64 myTransactionToken)
{
Query = myQuery;
var indexDef = new IndexPredefinition(_IndexName, _DBType)
.SetIndexType(_IndexType)
.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 <IQueryResult>(mySecurityToken, myTransactionToken, new RequestCreateIndex(indexDef), GenerateResult));
}
/// <summary>
/// Validates the id chain if it is not already validated and returns all errors and warnings.
/// </summary>
public void Validate(GQLPluginManager myPluginManager, IGraphDB myGraphDB, SecurityToken mySecurityToken, Int64 myTransactionToken, Boolean allowUndefinedAttributes, params IVertexType[] validationTypes)
{
if (IsValidated)
{
return;
}
var listOfRefs = new Dictionary <String, IVertexType>();
if (validationTypes == null || validationTypes.Count() == 0)
{
foreach (var type in _References)
{
var vertexType = myGraphDB.GetVertexType <IVertexType>(
mySecurityToken,
myTransactionToken,
new GraphDB.Request.RequestGetVertexType(type.TypeName),
(stats, theVertexType) => theVertexType);
listOfRefs.Add(type.Reference, vertexType);
}
}
else
{
foreach (var type in validationTypes)
{
listOfRefs.Add(type.Name, type);
}
}
Validate(myPluginManager, myGraphDB, mySecurityToken, myTransactionToken, listOfRefs, allowUndefinedAttributes);
}
public override IQueryResult Execute(IGraphDB myGraphDB, IGraphQL myGraphQL, GQLPluginManager myPluginManager, String myQuery, SecurityToken mySecurityToken, Int64 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 <IQueryResult>(
mySecurityToken,
myTransactionToken,
new RequestDelete(new RequestGetVertices(_typeName, toBeDeletedVertices.Select(_ => _.VertexID))).AddAttributes(_toBeDeletedAttributes),
CreateQueryResult));
}
public virtual void Validate(GQLPluginManager myPluginManager, IGraphDB myGraphDB, SecurityToken mySecurityToken, Int64 myTransactionToken)
{
if (myPluginManager.HasPlugin <IGQLFunction>(FuncName))
{
Function = myPluginManager.GetAndInitializePlugin <IGQLFunction>(FuncName);
}
else
{
throw new AggregateOrFunctionDoesNotExistException(FuncName);
}
#region parameter exceptions
#region check number of parameters
Boolean containsVariableNumOfParams = this.Function.GetParameters().Exists(p => p.VariableNumOfParams);
if (this.Function.GetParameters().Count != Parameters.Count && (!containsVariableNumOfParams))
{
throw new FunctionParameterCountMismatchException(this.Function.PluginShortName, this.Function.GetParameters().Count, Parameters.Count);
}
else if (containsVariableNumOfParams && Parameters.Count == 0)
{
throw new FunctionParameterCountMismatchException(this.Function.PluginShortName, 1, Parameters.Count);
}
#endregion
#endregion
}
private static IEnumerable <IVertex> ProcessBinaryExpression(
BinaryExpressionDefinition binExpression,
GQLPluginManager myPluginManager,
IGraphDB myGraphDB,
SecurityToken mySecurityToken,
Int64 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 override IQueryResult Execute(IGraphDB myGraphDB, IGraphQL myGraphQL, GQLPluginManager myPluginManager, String myQuery, SecurityToken mySecurityToken, Int64 myTransactionToken)
{
var sw = Stopwatch.StartNew();
var _ReturnValues = new Dictionary <String, Object>();
if (Command_Type == CommandType.Commit)
{
myGraphDB.CommitTransaction(mySecurityToken, myTransactionToken);
}
else
{
myGraphDB.RollbackTransaction(mySecurityToken, myTransactionToken);
}
_ReturnValues.Add("TransactionID", myTransactionToken);
_ReturnValues.Add("ExecutedCommand", Command_Type);
_ReturnValues.Add("Name", Name == null ? "" : Name);
_ReturnValues.Add("ASync", ASync);
return(QueryResult.Success(myQuery, SonesGQLConstants.GQL, new List <IVertexView> {
new VertexView(_ReturnValues, null)
}, Convert.ToUInt64(sw.ElapsedMilliseconds)));
}
public override IQueryResult Execute(IGraphDB myGraphDB,
IGraphQL myGraphQL,
GQLPluginManager myPluginManager,
String myQuery,
SecurityToken mySecurityToken,
Int64 myTransactionToken)
{
_queryString = myQuery;
IQueryResult result;
try
{
result = myGraphDB.Insert <IQueryResult>(
mySecurityToken,
myTransactionToken,
CreateRequest(myPluginManager,
myGraphDB,
mySecurityToken,
myTransactionToken),
CreateQueryResult);
}
catch (ASonesException e)
{
result = new QueryResult(_queryString,
SonesGQLConstants.GQL,
0,
ResultType.Failed,
null,
e);
}
return(result);
}
private AExpressionDefinition TryGetBinexpression(AExpressionDefinition expression,
GQLPluginManager myPluginManager,
IGraphDB myGraphDB,
SecurityToken mySecurityToken,
Int64 myTransactionToken,
params IVertexType[] types)
{
if (expression is BinaryExpressionDefinition)
{
(expression as BinaryExpressionDefinition).Validate(myPluginManager, myGraphDB, mySecurityToken, myTransactionToken, types);
return(expression as BinaryExpressionDefinition);
}
else
{
//for negative values like -U.Age
if (expression is UnaryExpressionDefinition)
{
var binExpr = (expression as UnaryExpressionDefinition).GetBinaryExpression(myPluginManager, myGraphDB, mySecurityToken, myTransactionToken);
return(binExpr);
}
else
{
if (expression is TupleDefinition)
{
return(TryGetBinexpression(((TupleDefinition)expression).First().Value, myPluginManager, myGraphDB, mySecurityToken, myTransactionToken));
}
}
}
throw new NotImplementedQLException("");
}
private void ProcessDelete(IVertex toBeDeletedVertexID, IGraphDB myGraphDB, GQLPluginManager myPluginManager, SecurityToken mySecurityToken, Int64 myTransactionToken)
{
myGraphDB.Delete <bool>(
mySecurityToken,
myTransactionToken,
new RequestDelete(new RequestGetVertices(toBeDeletedVertexID.VertexTypeID, new List <long> {
toBeDeletedVertexID.VertexID
})),
(stats, attributes, vertices) => true);
}
public override IQueryResult Execute(IGraphDB myGraphDB, IGraphQL myGraphQL, GQLPluginManager myPluginManager, String myQuery, SecurityToken mySecurityToken, Int64 myTransactionToken)
{
_query = myQuery;
return(myGraphDB.AlterVertexType <IQueryResult>(
mySecurityToken,
myTransactionToken,
CreateNewRequest(myGraphDB, myPluginManager, mySecurityToken, myTransactionToken),
CreateOutput));
}
private void ProcessDelete(IVertex toBeDeletedVertexID, IGraphDB myGraphDB, GQLPluginManager myPluginManager, SecurityToken mySecurityToken, Int64 myTransactionToken)
{
//TODO: new RequestDelete(new RequestGetVertices( --> change to sth that uses the IVertex directly
var stat = myGraphDB.Delete(mySecurityToken,
myTransactionToken,
new RequestDelete(new RequestGetVertices(toBeDeletedVertexID.VertexTypeID, new List <long> {
toBeDeletedVertexID.VertexID
})),
(stats, attributes, vertices) => stats);
}
internal void ConvertToAttributeType(GQLPluginManager myPluginManager, IAttributeDefinition typeAttribute, IGraphDB myGraphDB, SecurityToken mySecurityToken, Int64 myTransactionToken)
{
var newTuple = new List <TupleElement>();
for (int i = 0; i < TupleElements.Count; i++)
{
var tupleElement = TupleElements[i].Value;
if (tupleElement is SelectDefinition)
{
#region partial select
var selectManager = new SelectManager(myGraphDB, myPluginManager);
var selectDefinition = (tupleElement as SelectDefinition);
IQueryResult qresult = selectManager.ExecuteSelect(mySecurityToken, myTransactionToken, selectDefinition, String.Empty);
if (qresult.Error != null)
{
throw qresult.Error;
}
IAttributeDefinition curAttr = ((tupleElement as SelectDefinition).SelectedElements.First().Item1 as IDChainDefinition).LastAttribute;
foreach (var _Vertex in qresult.Vertices)
{
if (!(_Vertex.HasProperty(curAttr.Name)))
{
continue;
}
if (curAttr != null)
{
var val = new ValueDefinition(_Vertex.GetProperty <Object>(curAttr.Name));
newTuple.Add(new TupleElement(val));
}
else
{
throw new NotImplementedQLException("");
}
}
#endregion
}
else if (TupleElements[i].Value is ValueDefinition)
{
newTuple.Add(new TupleElement(new ValueDefinition((TupleElements[i].Value as ValueDefinition).Value)));
}
else
{
throw new InvalidTupleException(TupleElements[i].Value.GetType().Name);
}
}
TupleElements = newTuple;
}
private RequestAlterVertexType CreateNewRequest(IGraphDB myGraphDB, GQLPluginManager myPluginManager, SecurityToken mySecurityToken, Int64 myTransactionToken)
{
RequestAlterVertexType result = new RequestAlterVertexType(_TypeName);
foreach (var aAlterCommand in _AlterTypeCommand)
{
ProcessAlterCommand(aAlterCommand, ref result);
}
return(result);
}
private void ProcessUpdate(IVertexType vertexType,
GQLPluginManager myPluginManager,
IGraphDB myGraphDB,
SecurityToken mySecurityToken,
Int64 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("");
}
}
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 IQueryResult Execute(IGraphDB myGraphDB, IGraphQL myGraphQL, GQLPluginManager myPluginManager, String myQuery, SecurityToken mySecurityToken, Int64 myTransactionToken)
{
try
{
var stat = myGraphDB.DropIndex(mySecurityToken, myTransactionToken, new RequestDropIndex(_TypeName, _IndexName, _IndexEdition), (stats) => stats);
return(QueryResult.Success(myQuery, SonesGQLConstants.GQL, null, Convert.ToUInt64(stat.ExecutionTime.Milliseconds)));
}
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 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)
{
var sw = Stopwatch.StartNew();
IQueryResult 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)
{
var selectManager = new SelectManager(myGraphDB, myPluginManager);
return(selectManager.ExecuteSelect(mySecurityToken, myTransactionToken,
new SelectDefinition(TypeList, SelectedElements,
WhereExpressionDefinition, GroupByIDs, Having, Limit,
Offset, OrderByDefinition, ResolutionDepth), myQuery));
}
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>
/// Executes the statement and returns a IQueryResult.
/// </summary>
public override IQueryResult Execute(IGraphDB myGraphDB,
IGraphQL myGraphQL,
GQLPluginManager myPluginManager,
String myQuery,
SecurityToken mySecurityToken,
Int64 myTransactionToken)
{
Query = myQuery;
return(myGraphDB.Update(mySecurityToken,
myTransactionToken,
GenerateUpdateRequest(myGraphDB,
myPluginManager,
mySecurityToken,
myTransactionToken),
GenerateOutput));
}
/// <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);
}
private void ProcessListOfUpdates(IVertexType vertexType,
GQLPluginManager myPluginManager,
IGraphDB myGraphDB,
SecurityToken mySecurityToken,
Int64 myTransactionToken,
ref RequestUpdate result)
{
foreach (var aUpdate in _listOfUpdates)
{
ProcessUpdate(vertexType,
myPluginManager,
myGraphDB,
mySecurityToken,
myTransactionToken,
aUpdate,
ref result);
}
}
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);
}
