private QueryResult ExecuteAsParallel(IEnumerable<String> myLines, IGraphDBSession myIGraphDBSession, GraphQLQuery myGQLQuery, VerbosityTypes verbosityTypes, UInt32 parallelTasks = 1, IEnumerable<String> comments = null)
{
var queryResult = new QueryResult();
var aggregatedResults = new List<IEnumerable<Vertex>>();
#region Create parallel options
var parallelOptions = new ParallelOptions()
{
MaxDegreeOfParallelism = (int)parallelTasks
};
#endregion
Int64 numberOfLine = 0;
Parallel.ForEach(myLines, parallelOptions, (line, state) =>
{
if (!IsComment(line, comments))
{
Interlocked.Add(ref numberOfLine, 1L);
if (!IsComment(line, comments)) // Skip comments
{
var qresult = ExecuteQuery(line, myIGraphDBSession, myGQLQuery);
#region VerbosityTypes.Full: Add result
if (verbosityTypes == VerbosityTypes.Full)
{
lock (aggregatedResults)
{
aggregatedResults.Add(qresult.Vertices);
}
}
#endregion
#region !VerbosityTypes.Silent: Add errors and break execution
if (qresult.ResultType != ResultType.Successful && verbosityTypes != VerbosityTypes.Silent)
{
lock (queryResult)
{
queryResult.PushIErrors(new[] { new Errors.Error_ImportFailed(line, numberOfLine) });
queryResult.PushIErrors(qresult.Errors);
queryResult.PushIWarnings(qresult.Warnings);
}
state.Break();
}
#endregion
}
}
});
//add the results of each query into the queryResult
queryResult.Vertices = AggregateListOfListOfVertices(aggregatedResults);
return queryResult;
}
/// <summary>
///
/// </summary>
/// <param name="myWhereExpression"></param>
/// <param name="_dbContext"></param>
/// <param name="myTypeWithUndefAttrs">Type, List of undef attrs</param>
/// <param name="myDBTypeAttributeToDelete">Type, List of attributes</param>
/// <param name="myReferenceTypeLookup">reference, _graphDBType</param>
/// <returns></returns>
public QueryResult Delete(BinaryExpressionDefinition myWhereExpression, Dictionary<GraphDBType, List<string>> myTypeWithUndefAttrs, Dictionary<GraphDBType, List<TypeAttribute>> myDBTypeAttributeToDelete, Dictionary<String, GraphDBType> myReferenceTypeLookup)
{
QueryResult result = new QueryResult();
try
{
#region get UUIDs
if (myWhereExpression != null)
{
#region _WhereExpression
myWhereExpression.Validate(_dbContext);
if (myWhereExpression.ValidateResult.Failed())
{
return new QueryResult(myWhereExpression.ValidateResult);
}
var resultGraph = myWhereExpression.Calculon(_dbContext, new CommonUsageGraph(_dbContext), false);
if (resultGraph.Failed())
{
return new QueryResult(resultGraph.IErrors);
}
IEnumerable<Exceptional<DBObjectStream>> _dbobjects;
#region undefined attributes
foreach (var type in myTypeWithUndefAttrs)
{
_dbobjects = resultGraph.Value.Select(new LevelKey(type.Key, _dbContext.DBTypeManager), null, false);
foreach (var dbObj in _dbobjects)
{
foreach (var undefAttr in type.Value)
{
var removeExcept = _dbContext.DBObjectManager.RemoveUndefinedAttribute(undefAttr, dbObj.Value);
if (removeExcept.Failed())
return new QueryResult(removeExcept.IErrors);
}
}
}
#endregion
#region TypeAttributes to delete
Boolean generateLevel = true;
foreach (var aToBeDeletedAttribute in myDBTypeAttributeToDelete)
{
if (!resultGraph.Value.ContainsRelevantLevelForType(aToBeDeletedAttribute.Key))
{
generateLevel = false;
}
else
{
generateLevel = true;
}
var deleteResult = DeleteDBObjects(aToBeDeletedAttribute.Key, aToBeDeletedAttribute.Value, resultGraph.Value.Select(new LevelKey(aToBeDeletedAttribute.Key, _dbContext.DBTypeManager), null, generateLevel));
if (deleteResult.Failed())
{
return new QueryResult(deleteResult.IErrors);
}
else
{
if (!deleteResult.Success())
{
result.PushIWarnings(deleteResult.IWarnings);
}
result.Vertices = deleteResult.Value;
}
}
#endregion
#region expressionGraph error handling
result.PushIWarnings(resultGraph.Value.GetWarnings());
#endregion
#endregion
}
else
{
if (myDBTypeAttributeToDelete.Count == 0)
{
#region delete only undefined attributes of types
foreach (var type in myTypeWithUndefAttrs)
{
var listOfAffectedDBObjects = _dbContext.DBObjectCache.SelectDBObjectsForLevelKey(new LevelKey(type.Key, _dbContext.DBTypeManager), _dbContext);
RemoveUndefAttrs(listOfAffectedDBObjects, type.Value);
}
#endregion
}
else
{
#region get guids via guid-idx
foreach (var attributeToDelete in myDBTypeAttributeToDelete)
{
var listOfAffectedDBObjects = _dbContext.DBObjectCache.SelectDBObjectsForLevelKey(new LevelKey(attributeToDelete.Key, _dbContext.DBTypeManager), _dbContext).ToList();
if (myTypeWithUndefAttrs.ContainsKey(attributeToDelete.Key))
RemoveUndefAttrs(listOfAffectedDBObjects, myTypeWithUndefAttrs[attributeToDelete.Key]);
List<TypeAttribute> attributes = new List<TypeAttribute>();
foreach (var attr in attributeToDelete.Value)
{
attributes.Add(attr);
}
var Result = DeleteDBObjects(attributeToDelete.Key, attributes, listOfAffectedDBObjects);
if (Result.Failed())
{
return new QueryResult(Result.IErrors);
}
}
#endregion
}
}
#endregion
}
catch (GraphDBException gdbEx)
{
return new QueryResult(gdbEx.GraphDBErrors);
}
catch (Exception e)
{
return new QueryResult(new Error_UnknownDBError(e));
}
return result;
}
private QueryResult ExecuteAsSingleThread(IEnumerable<String> myLines, IGraphDBSession myIGraphDBSession, GraphQLQuery myGQLQuery, VerbosityTypes verbosityTypes, IEnumerable<String> comments = null)
{
var queryResult1 = new QueryResult();
Int64 numberOfLine = 0;
var query = String.Empty;
var aggregatedResults = new List<IEnumerable<Vertex>>();
foreach (var _Line in myLines)
{
numberOfLine++;
#region Skip comments
if (IsComment(_Line, comments))
{
continue;
}
#endregion
query += _Line;
var qresult = ExecuteQuery(query, myIGraphDBSession, myGQLQuery);
#region VerbosityTypes.Full: Add result
if (verbosityTypes == VerbosityTypes.Full)
{
aggregatedResults.Add(qresult.Vertices);
}
#endregion
#region !VerbosityTypes.Silent: Add errors and break execution
if (qresult.ResultType == ResultType.Failed)
{
if (qresult.Errors.Any(e => (e is Error_GqlSyntax) && (e as Error_GqlSyntax).SyntaxErrorMessage.Equals("Mal-formed string literal - cannot find termination symbol.")))
{
Debug.WriteLine("Query at line [" + numberOfLine + "] [" + query + "] failed with " + qresult.GetIErrorsAsString() + " add next line...");
continue;
}
if (verbosityTypes != VerbosityTypes.Silent)
{
queryResult1.PushIError(new Error_ImportFailed(query, numberOfLine));
queryResult1.PushIErrors(qresult.Errors);
queryResult1.PushIWarnings(qresult.Warnings);
}
break;
}
else if (qresult.ResultType == ResultType.PartialSuccessful && verbosityTypes != VerbosityTypes.Silent)
{
queryResult1.PushIWarning(new Warning_ImportWarning(query, numberOfLine));
queryResult1.PushIWarnings(qresult.Warnings);
}
#endregion
query = String.Empty;
}
//add the results of each query into the queryResult
queryResult1.Vertices = AggregateListOfListOfVertices(aggregatedResults);
return queryResult1;
}
