/// <summary>
/// This is the update method which will change some <paramref name="myDBObjects"/> an behalf of the <paramref name="myListOfUpdates"/>
/// </summary>
/// <param name="myDBObjects">Some dbobjects</param>
/// <param name="myListOfUpdates">The list of update tasks (assign, delete, etc)</param>
/// <param name="dbObjectCache"></param>
/// <returns></returns>
public QueryResult Update(IEnumerable<Exceptional<DBObjectStream>> myDBObjects, IEnumerable<AAttributeAssignOrUpdateOrRemove> myListOfUpdates, DBContext myDBContext, GraphDBType myGraphDBType)
{
#region Data
var queryResultContent = new List<Vertex>();
var queryResult = new QueryResult();
Warning_UndefinedAttribute undefAttrWarning = null;
#endregion
#region check for undefined attributes setting
var undefAttrSetting = myDBContext.DBSettingsManager.GetSetting(SettingUndefAttrBehaviour.UUID, myDBContext, TypesSettingScope.DB);
if (!undefAttrSetting.Success())
{
return new QueryResult(undefAttrSetting);
}
var undefSettingVal = ((SettingUndefAttrBehaviour)undefAttrSetting.Value).Behaviour;
#endregion
#region Validate attributes
foreach (var updateOrAssign in myListOfUpdates)
{
System.Diagnostics.Debug.Assert(updateOrAssign != null);
if (updateOrAssign is AAttributeAssignOrUpdateOrRemove && !(updateOrAssign is AttributeRemove))
{
var result = (updateOrAssign as AAttributeAssignOrUpdateOrRemove).AttributeIDChain.Validate(myDBContext, true);
if (updateOrAssign.IsUndefinedAttributeAssign)
{
switch (undefSettingVal)
{
case UndefAttributeBehaviour.disallow:
return new QueryResult(new Error_UndefinedAttributes());
case UndefAttributeBehaviour.warn:
if (undefAttrWarning == null)
{
undefAttrWarning = new Warning_UndefinedAttribute();
}
queryResult.PushIWarning(undefAttrWarning);
break;
}
}
if (result.Failed())
{
return new QueryResult(result);
}
}
}
//var undefinedAttributeAssignments = myListOfUpdates.Where(a => a.IsUndefinedAttributeAssign);
var definedAttributeAssignments = myListOfUpdates.Where(a => !a.IsUndefinedAttributeAssign);
#endregion
#region check unique constraint - refactor!!
if (definedAttributeAssignments.CountIsGreater(0))
{
Exceptional<Boolean> CheckConstraint = null;
IEnumerable<GraphDBType> parentTypes = myDBContext.DBTypeManager.GetAllParentTypes(myGraphDBType, true, false);
Dictionary<AttributeUUID, IObject> ChkForUnique = new Dictionary<AttributeUUID, IObject>();
foreach (var entry in myDBObjects)
{
//all attributes, that are going to be changed
var attrsToCheck = entry.Value.GetAttributes().Where(item => definedAttributeAssignments.Select(updAttrs => GetAttributesToCheckForUnique(updAttrs)).Contains(item.Key));
foreach (var attrValue in attrsToCheck)
{
if (!ChkForUnique.ContainsKey(attrValue.Key))
ChkForUnique.Add(attrValue.Key, attrValue.Value);
}
CheckConstraint = myDBContext.DBIndexManager.CheckUniqueConstraint(myGraphDBType, parentTypes, ChkForUnique);
ChkForUnique.Clear();
if (CheckConstraint.Failed())
return new QueryResult(CheckConstraint.IErrors);
}
}
#endregion
#region regular update
foreach (var aDBO in myDBObjects)
{
//key: attribute name
//value: TypeAttribute, NewValue
Dictionary<String, Tuple<TypeAttribute, IObject>> attrsForResult = new Dictionary<String, Tuple<TypeAttribute, IObject>>();
if (aDBO.Failed())
{
return new QueryResult(aDBO);
}
#region data
Boolean sthChanged = false;
#endregion
#region iterate tasks
//Exceptional<Boolean> partialResult;
foreach (var attributeUpdateOrAssign in myListOfUpdates)
{
var updateResult = attributeUpdateOrAssign.Update(myDBContext, aDBO.Value, myGraphDBType);
if (updateResult.Failed())
{
return new QueryResult(updateResult);
}
if (updateResult.Value.Count > 0)
{
sthChanged = true;
attrsForResult.AddRange(updateResult.Value);
}
}
#endregion
if (sthChanged)
{
var definedAttributes = ExtractDefinedAttributes(attrsForResult, myDBContext.DBTypeManager);
#region update Idx
foreach (var _AttributeIndex in myGraphDBType.GetAllAttributeIndices())
{
if(definedAttributes.Exists(item => _AttributeIndex.IndexKeyDefinition.IndexKeyAttributeUUIDs.Contains(item.Key.Definition.UUID)))
{
//execute update
_AttributeIndex.Update(aDBO.Value, myGraphDBType, myDBContext);
}
}
#endregion
#region update dbobjects on fs
var flushResult = myDBContext.DBObjectManager.FlushDBObject(aDBO.Value);
if (!flushResult.Success())
{
return new QueryResult(flushResult);
}
#endregion
var resultSet = GetManipulationResultSet(myDBContext, aDBO, myGraphDBType, undefinedAttributes: ExtractUndefindedAttributes(attrsForResult), attributes: definedAttributes);
if (!resultSet.Success())
{
/*
what should happen now
this should not break the update
*/
}
queryResultContent.Add(resultSet.Value);
}
}
#endregion
#region Return all affected dbObjectUUIDs
queryResult.Vertices = queryResultContent;
return queryResult;
#endregion
}
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;
}
