public SelectDefinition(List<TypeReferenceDefinition> myTypeList, List<Tuple<AExpressionDefinition, string, SelectValueAssignment>> mySelectedElements, BinaryExpressionDefinition myWhereExpressionDefinition,
List<IDChainDefinition> myGroupByIDs, BinaryExpressionDefinition myHaving, ulong? myLimit, ulong? myOffset, Structures.OrderByDefinition myOrderByDefinition, long myResolutionDepth)
{
TypeList = myTypeList;
SelectedElements = mySelectedElements;
WhereExpressionDefinition = myWhereExpressionDefinition;
GroupByIDs = myGroupByIDs;
Having = myHaving;
Limit = myLimit;
Offset = myOffset;
OrderByDefinition = myOrderByDefinition;
ResolutionDepth = myResolutionDepth;
}
public override void GetContent(CompilerContext context, ParseTreeNode parseNode)
{
if (parseNode.HasChildNodes())
{
_TypeName = ((ATypeNode)(parseNode.ChildNodes[1].AstNode)).ReferenceAndType.TypeName;
if (parseNode.ChildNodes[3] != null && parseNode.ChildNodes[3].HasChildNodes())
{
_AttributeAssignList = (parseNode.ChildNodes[3].AstNode as AttrAssignListNode).AttributeAssigns;
}
_whereExpression = ((BinaryExpressionNode)parseNode.ChildNodes[5].AstNode).BinaryExpressionDefinition;
System.Diagnostics.Debug.Assert(_whereExpression != null);
}
}
/// <summary>
/// Handles the Binary Expression node
/// </summary>
/// <param name="context"></param>
/// <param name="parseNode"></param>
/// <param name="typeManager"></param>
public void GetContent(CompilerContext context, ParseTreeNode parseNode)
{
#region set type of binary expression
_OperatorSymbol = parseNode.ChildNodes[1].Term.Name;
_left = GetExpressionDefinition(parseNode.ChildNodes[0]);
_right = GetExpressionDefinition(parseNode.ChildNodes[2]);
#endregion
BinaryExpressionDefinition = new BinaryExpressionDefinition(_OperatorSymbol, _left, _right);
OriginalString += _left.ToString() + " ";
OriginalString += _OperatorSymbol + " ";
OriginalString += _right.ToString();
}
public Exceptional<BinaryExpressionDefinition> GetBinaryExpression(DBContext myDBContext)
{
AExpressionDefinition right;
var op = myDBContext.DBPluginManager.GetBinaryOperator(_OperatorSymbol);
if (op == null)
{
return new Exceptional<BinaryExpressionDefinition>(new Error_OperatorDoesNotExist(_OperatorSymbol));
}
if (op.Label == BinaryOperator.Subtraction)
right = new ValueDefinition(new DBInt32(-1));
else
right = new ValueDefinition(new DBInt32(1));
var binExpr = new BinaryExpressionDefinition("*", _Expression, right);
binExpr.Validate(myDBContext);
return new Exceptional<BinaryExpressionDefinition>(binExpr, binExpr.ValidateResult);
}
public void GetContent(CompilerContext myCompilerContext, ParseTreeNode myParseTreeNode)
{
if (myParseTreeNode.HasChildNodes())
{
if (myParseTreeNode.ChildNodes[1].AstNode is TupleNode && (myParseTreeNode.ChildNodes[1].AstNode as TupleNode).TupleDefinition.TupleElements.Count == 1)
{
var tuple = (myParseTreeNode.ChildNodes[1].AstNode as TupleNode).TupleDefinition.Simplyfy();
BinaryExpressionDefinition = (tuple.TupleElements[0].Value as BinaryExpressionDefinition);
}
else if (myParseTreeNode.ChildNodes[1].AstNode is BinaryExpressionNode)
{
BinaryExpressionDefinition = ((BinaryExpressionNode)myParseTreeNode.ChildNodes[1].AstNode).BinaryExpressionDefinition;
}
//else
//{
// throw new GraphDBException(new Errors.Error_GqlSyntax("Invalid tuple for where expression"));
//}
}
}
public QueryResult Replace(List<AAttributeAssignOrUpdate> myAttributeAssignList, BinaryExpressionDefinition myBinaryExpressionDefinition)
{
List<IWarning> warnings = new List<IWarning>();
IEnumerable<Exceptional<DBObjectStream>> _dbObjects = null;
myBinaryExpressionDefinition.Validate(_dbContext);
if (myBinaryExpressionDefinition.ValidateResult.Failed())
{
return new QueryResult(myBinaryExpressionDefinition.ValidateResult);
}
var _whereGraphResult = myBinaryExpressionDefinition.Calculon(_dbContext, new CommonUsageGraph(_dbContext), false);
if (_whereGraphResult.Success())
{
_dbObjects = _whereGraphResult.Value.Select(new LevelKey(_graphDBType, _dbContext.DBTypeManager), null, true);
}
else
{
return new QueryResult(_whereGraphResult.IErrors);
}
#region expressionGraph error handling
warnings.AddRange(_whereGraphResult.Value.GetWarnings());
#endregion
if (_dbObjects.CountIsGreater(1))
{
return new QueryResult(new Error_MultipleResults());
}
if (_dbObjects.CountIs(0))
{
warnings.Add(new Warnings.Warning_NoObjectsToReplace());
return new QueryResult(new List<IError>(), warnings);
}
IEnumerable<GraphDBType> parentTypes = _dbContext.DBTypeManager.GetAllParentTypes(_graphDBType, true, false);
Exceptional<Boolean> checkUniqueVal = null;
var attrsResult = EvaluateAttributes(myAttributeAssignList);
if (!attrsResult.Success())
{
return new QueryResult(attrsResult);
}
var assingedAttrs = attrsResult.Value.Attributes.ToDictionary(key => key.Key.Definition.UUID, value => value.Value);
checkUniqueVal = _dbContext.DBIndexManager.CheckUniqueConstraint(_graphDBType, parentTypes, assingedAttrs);
if (!checkUniqueVal.Success())
return new QueryResult(checkUniqueVal);
var DeleteResult = DeleteDBObjects(_graphDBType, null, _dbObjects);
if (!DeleteResult.Success())
{
return new QueryResult(DeleteResult);
}
var result = Insert(attrsResult.Value, false);
result.PushIWarnings(warnings);
return result;
}
public QueryResult InsertOrUpdate(List<AAttributeAssignOrUpdate> _AttributeAssignList, BinaryExpressionDefinition myBinaryExpressionDefinition = null)
{
List<IWarning> warnings = new List<IWarning>();
IEnumerable<Exceptional<DBObjectStream>> extractedDBOs = null;
var manipulationAttributes = EvaluateAttributes(_AttributeAssignList);
if (!manipulationAttributes.Success())
{
return new QueryResult(manipulationAttributes);
}
var attributeAssignOrUpdateOrRemoveList = manipulationAttributes.Value.AttributeToUpdateOrAssign;
if (myBinaryExpressionDefinition != null)
{
myBinaryExpressionDefinition.Validate(_dbContext);
if (myBinaryExpressionDefinition.ValidateResult.Failed())
{
return new QueryResult(myBinaryExpressionDefinition.ValidateResult);
}
var _whereGraphResult = myBinaryExpressionDefinition.Calculon(_dbContext, new CommonUsageGraph(_dbContext), false);
if (_whereGraphResult.Success())
{
extractedDBOs = _whereGraphResult.Value.Select(new LevelKey(_graphDBType, _dbContext.DBTypeManager), null, true);
}
else
{
return new QueryResult(_whereGraphResult.IErrors);
}
#region expressionGraph error handling
warnings.AddRange(_whereGraphResult.Value.GetWarnings());
#endregion
}
else
{
extractedDBOs = new List<Exceptional<DBObjectStream>>();
}
QueryResult result;
if (extractedDBOs.Count() == 0)
{
result = Insert(manipulationAttributes.Value, true);
}
else
{
if (extractedDBOs.Count() > 1)
return new QueryResult(new Error_MultipleResults());
result = Update(extractedDBOs, attributeAssignOrUpdateOrRemoveList);
}
result.PushIWarnings(warnings);
return result;
}
public QueryResult InsertOrReplace(List<AAttributeAssignOrUpdate> myAttributeAssignList, BinaryExpressionDefinition myBinaryExpressionDefinition = null)
{
List<IWarning> warnings = new List<IWarning>();
IEnumerable<Exceptional<DBObjectStream>> myDBObjects;
#region myBinaryExpressionDefinition
if (myBinaryExpressionDefinition != null)
{
myBinaryExpressionDefinition.Validate(_dbContext);
if (myBinaryExpressionDefinition.ValidateResult.Failed())
{
return new QueryResult(myBinaryExpressionDefinition.ValidateResult);
}
var _whereGraphResult = myBinaryExpressionDefinition.Calculon(_dbContext, new CommonUsageGraph(_dbContext), false);
if (_whereGraphResult.Success())
{
myDBObjects = _whereGraphResult.Value.Select(new LevelKey(_graphDBType, _dbContext.DBTypeManager), null, true);
}
else
{
return new QueryResult(_whereGraphResult.IErrors);
}
#region expressionGraph error handling
warnings.AddRange(_whereGraphResult.Value.GetWarnings());
#endregion
}
else
{
myDBObjects = new List<Exceptional<DBObjectStream>>();
}
#endregion
IEnumerable<GraphDBType> parentTypes = _dbContext.DBTypeManager.GetAllParentTypes(_graphDBType, true, false);
#region Get attribute assignies prior to deletion to act on errors
var attrsResult = EvaluateAttributes(myAttributeAssignList);
if (!attrsResult.Success())
{
return new QueryResult(attrsResult);
}
var assingedAttrs = attrsResult.Value.Attributes.ToDictionary(key => key.Key.Definition.UUID, value => value.Value);
var checkUniqueVal = _dbContext.DBIndexManager.CheckUniqueConstraint(_graphDBType, parentTypes, assingedAttrs);
if (checkUniqueVal.Failed())
return new QueryResult(checkUniqueVal.IErrors);
#endregion
#region Delete the object
if (myDBObjects.CountIsGreater(1))
{
return new QueryResult(new Error_MultipleResults());
}
else
{
if (myDBObjects.CountIs(1))
{
#region delete
var DeleteResult = DeleteDBObjects(_graphDBType, null, myDBObjects);
if (DeleteResult.Failed())
{
return new QueryResult(DeleteResult.IErrors);
}
#endregion
}
}
#endregion
#region Insert with new values
//Insert
var result = Insert(attrsResult.Value, false);
result.PushIWarnings(warnings);
//if there were any warnings during this process, the need to be added
#endregion
return result;
}
/// <summary>
/// Adds a having to the selection
/// </summary>
/// <param name="myHavingExpression"></param>
public void AddHavingToSelection(BinaryExpressionDefinition myHavingExpression)
{
_HavingExpression = myHavingExpression;
}
public override void GetContent(CompilerContext myCompilerContext, ParseTreeNode myParseTreeNode)
{
_IDChainDefinitions = new List<IDChainDefinition>();
_TypeReferenceDefinitions = (myParseTreeNode.ChildNodes[1].AstNode as TypeListNode).Types;
if (myParseTreeNode.ChildNodes[3].HasChildNodes())
{
IDNode tempIDNode;
foreach (var _ParseTreeNode in myParseTreeNode.ChildNodes[3].ChildNodes[0].ChildNodes)
{
if (_ParseTreeNode.AstNode is IDNode)
{
tempIDNode = (IDNode)_ParseTreeNode.AstNode;
_IDChainDefinitions.Add(tempIDNode.IDChainDefinition);
}
}
}
else
{
foreach (var type in _TypeReferenceDefinitions)
{
var def = new IDChainDefinition();
def.AddPart(new ChainPartTypeOrAttributeDefinition(type.Reference));
_IDChainDefinitions.Add(def);
}
}
#region whereClauseOpt
if (myParseTreeNode.ChildNodes[4].HasChildNodes())
{
WhereExpressionNode tempWhereNode = (WhereExpressionNode)myParseTreeNode.ChildNodes[4].AstNode;
_WhereExpression = tempWhereNode.BinaryExpressionDefinition;
}
#endregion
}
public override void GetContent(CompilerContext context, ParseTreeNode parseNode)
{
#region Data
TypeList = new List<TypeReferenceDefinition>();
GroupByIDs = new List<IDChainDefinition>();
SelectedElements = new List<Tuple<AExpressionDefinition, string, SelectValueAssignment>>();
Limit = null;
Offset = null;
WhereExpressionDefinition = null;
ResolutionDepth = -1;
#endregion
#region TypeList
foreach (ParseTreeNode aNode in parseNode.ChildNodes[1].ChildNodes)
{
ATypeNode aType = (ATypeNode)aNode.AstNode;
// use the overrides equals to check duplicated references
if (!TypeList.Contains(aType.ReferenceAndType))
{
TypeList.Add(aType.ReferenceAndType);
}
else
{
throw new GraphDBException(new Error_DuplicateReferenceOccurence(aType.ReferenceAndType));
}
}
#endregion
#region selList
foreach (ParseTreeNode aNode in parseNode.ChildNodes[3].ChildNodes)
{
SelectionListElementNode aColumnItemNode = (SelectionListElementNode)aNode.AstNode;
String typeName = null;
if (aColumnItemNode.SelType != TypesOfSelect.None)
{
if (aColumnItemNode.SelType == TypesOfSelect.Ad)
{
typeName = aColumnItemNode.TypeName;
}
foreach (var reference in GetTypeReferenceDefinitions(context))
{
//SelectedElements.Add(new IDChainDefinition(new ChainPartTypeOrAttributeDefinition(reference.TypeName), aColumnItemNode.SelType, typeName), null);
SelectedElements.Add(new Tuple<AExpressionDefinition, string, SelectValueAssignment>(
new IDChainDefinition(new ChainPartTypeOrAttributeDefinition(reference.TypeName), aColumnItemNode.SelType, typeName), null, aColumnItemNode.ValueAssignment));
}
continue;
}
SelectedElements.Add(new Tuple<AExpressionDefinition, string, SelectValueAssignment>(
aColumnItemNode.ColumnSourceValue, aColumnItemNode.AliasId, aColumnItemNode.ValueAssignment));
}
#endregion
#region whereClauseOpt
if (parseNode.ChildNodes[4].HasChildNodes())
{
WhereExpressionNode tempWhereNode = (WhereExpressionNode)parseNode.ChildNodes[4].AstNode;
if (tempWhereNode.BinaryExpressionDefinition != null)
{
WhereExpressionDefinition = tempWhereNode.BinaryExpressionDefinition;
}
}
#endregion
#region groupClauseOpt
if (parseNode.ChildNodes[5].HasChildNodes() && parseNode.ChildNodes[5].ChildNodes[2].HasChildNodes())
{
foreach (ParseTreeNode node in parseNode.ChildNodes[5].ChildNodes[2].ChildNodes)
{
GroupByIDs.Add(((IDNode)node.AstNode).IDChainDefinition);
}
}
#endregion
#region havingClauseOpt
if (parseNode.ChildNodes[6].HasChildNodes())
{
Having = ((BinaryExpressionNode)parseNode.ChildNodes[6].ChildNodes[1].AstNode).BinaryExpressionDefinition;
}
#endregion
#region orderClauseOpt
if (parseNode.ChildNodes[7].HasChildNodes())
{
OrderByDefinition = ((OrderByNode)parseNode.ChildNodes[7].AstNode).OrderByDefinition;
}
#endregion
//#region MatchingClause
//if (parseNode.ChildNodes[8].HasChildNodes())
//{
// throw new NotImplementedException();
//}
//#endregion
#region Offset
if (parseNode.ChildNodes[9].HasChildNodes())
{
Offset = ((OffsetNode)parseNode.ChildNodes[9].AstNode).Count;
}
#endregion
#region Limit
if (parseNode.ChildNodes[10].HasChildNodes())
{
Limit = ((LimitNode)parseNode.ChildNodes[10].AstNode).Count;
}
#endregion
#region Depth
if (parseNode.ChildNodes[11].HasChildNodes())
{
ResolutionDepth = Convert.ToUInt16(parseNode.ChildNodes[11].ChildNodes[1].Token.Value);
}
#endregion
#region Select Output
if (parseNode.ChildNodes[12].HasChildNodes())
{
_SelectOutputType = (parseNode.ChildNodes[12].AstNode as SelectOutputOptNode).SelectOutputType;
}
#endregion
}
public AttributeAssignOrUpdateExpression(IDChainDefinition myIDChainDefinition, BinaryExpressionDefinition binaryExpressionDefinition)
: base(myIDChainDefinition)
{
BinaryExpressionDefinition = binaryExpressionDefinition;
}
/// <summary>
/// This method
/// </summary>
/// <param name="aBinExpr"></param>
/// <param name="aDBObject"></param>
/// <param name="dbContext"></param>
protected void SubstituteAttributeNames(BinaryExpressionDefinition aBinExpr, DBObjectStream aDBObject, DBContext dbContext)
{
if (aBinExpr.Left is IDChainDefinition)
{
aBinExpr.Left = GetAtomValue((IDChainDefinition)aBinExpr.Left, aDBObject, dbContext);
switch (aBinExpr.TypeOfBinaryExpression)
{
case TypesOfBinaryExpression.LeftComplex:
aBinExpr.TypeOfBinaryExpression = TypesOfBinaryExpression.Atom;
break;
case TypesOfBinaryExpression.Complex:
aBinExpr.TypeOfBinaryExpression = TypesOfBinaryExpression.RightComplex;
break;
case TypesOfBinaryExpression.Atom:
case TypesOfBinaryExpression.RightComplex:
case TypesOfBinaryExpression.Unknown:
default:
break;
}
}
else
{
if (aBinExpr.Left is BinaryExpressionDefinition)
{
SubstituteAttributeNames((BinaryExpressionDefinition)aBinExpr.Left, aDBObject, dbContext);
}
}
if (aBinExpr.Right is IDChainDefinition)
{
aBinExpr.Right = GetAtomValue((IDChainDefinition)aBinExpr.Right, aDBObject, dbContext);
switch (aBinExpr.TypeOfBinaryExpression)
{
case TypesOfBinaryExpression.RightComplex:
aBinExpr.TypeOfBinaryExpression = TypesOfBinaryExpression.Atom;
break;
case TypesOfBinaryExpression.Complex:
aBinExpr.TypeOfBinaryExpression = TypesOfBinaryExpression.LeftComplex;
break;
case TypesOfBinaryExpression.Atom:
case TypesOfBinaryExpression.LeftComplex:
case TypesOfBinaryExpression.Unknown:
default:
break;
}
}
else
{
if (aBinExpr.Right is BinaryExpressionDefinition)
{
SubstituteAttributeNames((BinaryExpressionDefinition)aBinExpr.Right, aDBObject, dbContext);
}
}
}
/// <summary>
/// Gets the content of an UpdateStatement.
/// </summary>
/// <param name="context">CompilerContext of Irony.</param>
/// <param name="parseNode">The current ParseNode.</param>
/// <param name="typeManager">The TypeManager of the GraphDB.</param>
public override void GetContent(CompilerContext myCompilerContext, ParseTreeNode myParseTreeNode)
{
#region get Type
_TypeName = (myParseTreeNode.ChildNodes[1].AstNode as ATypeNode).ReferenceAndType.TypeName;
#endregion
#region get myAttributes
if (myParseTreeNode.ChildNodes[3].HasChildNodes())
{
var AttrUpdateOrAssign = (AttrUpdateOrAssignListNode)myParseTreeNode.ChildNodes[3].AstNode;
_listOfUpdates = AttrUpdateOrAssign.ListOfUpdate;
base.ParsingResult.PushIExceptional(AttrUpdateOrAssign.ParsingResult);
}
#endregion
#region whereClauseOpt
if (myParseTreeNode.ChildNodes[4].HasChildNodes())
{
var tempWhereNode = (WhereExpressionNode) myParseTreeNode.ChildNodes[4].AstNode;
_WhereExpression = tempWhereNode.BinaryExpressionDefinition;
}
#endregion
}
public Error_InvalidBinaryExpression(BinaryExpressionDefinition myBinaryExpression)
{
BinaryExpression = myBinaryExpression;
}
/// <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 BinaryExpressionDefinition GetConditionNode(String myOperator, BinaryExpressionDefinition myPrevNode, TupleDefinition myNodeList)
{
var binElem = myNodeList.FirstOrDefault();
if (binElem == null)
{
return myPrevNode;
}
myNodeList.Remove(binElem);
var binNode = new BinaryExpressionDefinition(myOperator, myPrevNode, binElem.Value);
return GetConditionNode(myOperator, binNode, myNodeList);
}
/// <summary>
/// This will evaluate the <paramref name="myWhereExpression"/> and add some warnings coming from
/// </summary>
/// <param name="myWhereExpression"></param>
/// <param name="myListOfUpdates"></param>
/// <returns></returns>
public QueryResult Update(IEnumerable<AAttributeAssignOrUpdateOrRemove> myListOfUpdates, BinaryExpressionDefinition myWhereExpression = null)
{
IEnumerable<Exceptional<DBObjectStream>> _dbobjects;
IEnumerable<IWarning> warnings = null;
#region get GUIDs
if (myWhereExpression != null)
{
#region get guids via where
myWhereExpression.Validate(_dbContext);
if (myWhereExpression.ValidateResult.Failed())
{
return new QueryResult(myWhereExpression.ValidateResult);
}
var _tempGraphResult = myWhereExpression.Calculon(_dbContext, new CommonUsageGraph(_dbContext), false);
if (_tempGraphResult.Failed())
{
return new QueryResult(_tempGraphResult);
}
else
{
_dbobjects = _tempGraphResult.Value.Select(new LevelKey(_graphDBType, _dbContext.DBTypeManager), null, true);
if (!_tempGraphResult.Success())
{
warnings = _tempGraphResult.IWarnings;
}
}
#endregion
}
else
{
#region get guids via guid-idx
_dbobjects = _dbContext.DBObjectCache.SelectDBObjectsForLevelKey(new LevelKey(_graphDBType, _dbContext.DBTypeManager), _dbContext);
#endregion
}
#endregion
var updateResult = Update(_dbobjects, myListOfUpdates);
#region expressionGraph error handling
if (!warnings.IsNullOrEmpty())
{
updateResult.PushIWarnings(warnings);
}
#endregion
return updateResult;
}
/// <summary>
/// fast check if a given binary expression node is suitable for list integration
/// </summary>
/// <param name="aUniqueExpr">A BinaryExpressionNode.</param>
/// <param name="myAttributes"></param>
/// <returns></returns>
private bool IsValidBinaryExpressionNode(BinaryExpressionDefinition aUniqueExpr, Dictionary<string, string> attributes)
{
switch (aUniqueExpr.TypeOfBinaryExpression)
{
case TypesOfBinaryExpression.LeftComplex:
#region left complex
return CheckIDNode(aUniqueExpr.Left, attributes);
#endregion
case TypesOfBinaryExpression.RightComplex:
#region right complex
return CheckIDNode(aUniqueExpr.Right, attributes);
#endregion
case TypesOfBinaryExpression.Complex:
#region complex
#region Data
BinaryExpressionDefinition leftNode = null;
BinaryExpressionDefinition rightNode = null;
#endregion
#region get expr
#region left
if (aUniqueExpr.Left is BinaryExpressionDefinition)
{
leftNode = (BinaryExpressionDefinition)aUniqueExpr.Left;
}
else
{
return false;
}
#endregion
#region right
if (aUniqueExpr.Right is BinaryExpressionDefinition)
{
rightNode = (BinaryExpressionDefinition)aUniqueExpr.Right;
}
else
{
return false;
}
#endregion
#endregion
#region check
if ((leftNode != null) && (rightNode != null))
{
if (IsValidBinaryExpressionNode(leftNode, attributes) && IsValidBinaryExpressionNode(rightNode, attributes))
{
return true;
}
else
{
return false;
}
}
else
{
return false;
}
#endregion
#endregion
#region error cases
case TypesOfBinaryExpression.Atom:
default:
//in this kind of node it is not allowed to use Atom or complex expressions
return false;
#endregion
}
}
public override void GetContent(CompilerContext context, ParseTreeNode parseNode)
{
if (parseNode.HasChildNodes())
{
//get type
if (parseNode.ChildNodes[1] != null && parseNode.ChildNodes[1].AstNode != null)
{
_Type = ((ATypeNode)(parseNode.ChildNodes[1].AstNode)).ReferenceAndType.TypeName;
}
else
{
throw new GraphDBException(new Error_NotImplemented(new System.Diagnostics.StackTrace(true)));
}
if (parseNode.ChildNodes[3] != null && parseNode.ChildNodes[3].HasChildNodes())
{
_AttributeAssignList = new List<AAttributeAssignOrUpdate>((parseNode.ChildNodes[3].AstNode as AttrUpdateOrAssignListNode).ListOfUpdate.Select(e => e as AAttributeAssignOrUpdate));
}
if (parseNode.ChildNodes[4] != null && ((WhereExpressionNode)parseNode.ChildNodes[4].AstNode).BinaryExpressionDefinition != null)
{
_WhereExpression = ((WhereExpressionNode)parseNode.ChildNodes[4].AstNode).BinaryExpressionDefinition;
}
}
}
private Exceptional ValidateBinaryExpression(BinaryExpressionDefinition aUniqueExpr, GraphDBType validationType, DBContext typeManager)
{
switch (aUniqueExpr.TypeOfBinaryExpression)
{
case TypesOfBinaryExpression.LeftComplex:
return ValidateBinaryExpressionInternal(aUniqueExpr.Left, validationType, typeManager);
case TypesOfBinaryExpression.RightComplex:
return ValidateBinaryExpressionInternal(aUniqueExpr.Right, validationType, typeManager);
case TypesOfBinaryExpression.Complex:
return new Exceptional()
.PushIExceptional(ValidateBinaryExpressionInternal(aUniqueExpr.Left, validationType, typeManager))
.PushIExceptional(ValidateBinaryExpressionInternal(aUniqueExpr.Right, validationType, typeManager));
case TypesOfBinaryExpression.Atom:
default:
return Exceptional.OK;
}
}
public override void GetContent(CompilerContext context, ParseTreeNode parseNode)
{
_Sources = new HashSet<AAttributeAssignOrUpdateOrRemove>();
#region VIA edge
IDNode _EdgeAttr = null;
if (parseNode.ChildNodes[4].AstNode is IDNode) //Semantic Web Yoda style
{
_EdgeAttr = (parseNode.ChildNodes[4].AstNode as IDNode);
}
else //Human language style
{
_EdgeAttr = (parseNode.ChildNodes[6].AstNode as IDNode);
}
#endregion
#region sources
var typeNode = (parseNode.ChildNodes[1].AstNode as ATypeNode);
ParsingResult.PushIExceptional(typeNode.ParsingResult);
var tupleDef = (parseNode.ChildNodes[2].AstNode as TupleNode).TupleDefinition;
var tupleDefSourceType = new TupleDefinition(tupleDef.KindOfTuple);
foreach (var item in tupleDef.TupleElements)
{
var attrName = typeNode.ReferenceAndType.TypeName + DBConstants.EdgeTraversalDelimiterSymbol + ((IDChainDefinition)((BinaryExpressionDefinition)item.Value).Left).ContentString;
var leftNode = new IDChainDefinition(attrName, new List<TypeReferenceDefinition>() { typeNode.ReferenceAndType });
leftNode.AddPart(new ChainPartTypeOrAttributeDefinition(((IDChainDefinition)((BinaryExpressionDefinition)item.Value).Left).ContentString));
var rightNode = ((BinaryExpressionDefinition)item.Value).Right;
var binExpression = new BinaryExpressionDefinition(((BinaryExpressionDefinition)item.Value).OperatorSymbol, leftNode, rightNode);
tupleDefSourceType.AddElement(new TupleElement(item.TypeOfValue, binExpression));
}
_Sources.Add(new AttributeRemoveList(_EdgeAttr.IDChainDefinition, _EdgeAttr.IDChainDefinition.TypeName, tupleDefSourceType));
#endregion
#region sources FROM
if (parseNode.ChildNodes[6].ChildNodes[0].AstNode is ATypeNode) //Semantic Web Yoda style
{
typeNode = (parseNode.ChildNodes[6].ChildNodes[0].AstNode as ATypeNode);
_Targets = (parseNode.ChildNodes[6].ChildNodes[1].AstNode as TupleNode).TupleDefinition;
}
else //Human language style
{
typeNode = (parseNode.ChildNodes[4].ChildNodes[0].AstNode as ATypeNode);
_Targets = (parseNode.ChildNodes[4].ChildNodes[1].AstNode as TupleNode).TupleDefinition;
}
ParsingResult.PushIExceptional(typeNode.ParsingResult);
_SourceType = typeNode.ReferenceAndType;
if (_Targets.Count() > 1)
{
var firstElement = (BinaryExpressionDefinition)_Targets.First().Value;
_Targets.Remove(_Targets.First());
_Condition = GetConditionNode(new OrOperator().ContraryOperationSymbol, firstElement, _Targets);
}
else
{
_Condition = (BinaryExpressionDefinition)_Targets.First().Value;
}
#endregion
}
public override void GetContent(CompilerContext myCompilerContext, ParseTreeNode myParseTreeNode)
{
var _GraphQLGrammar = GetGraphQLGrammar(myCompilerContext);
_Targets = new HashSet<AAttributeAssignOrUpdateOrRemove>();
#region FROM Sources
var typeNode = (myParseTreeNode.ChildNodes[1].AstNode as ATypeNode);
ParsingResult.PushIExceptional(typeNode.ParsingResult);
_SourceType = typeNode.ReferenceAndType;
_Sources = (myParseTreeNode.ChildNodes[2].AstNode as TupleNode).TupleDefinition;
if(_Sources.Count() > 1 )
{
var firstElement = (BinaryExpressionDefinition)_Sources.First().Value;
_Sources.Remove(_Sources.First());
_Condition = GetConditionNode(new OrOperator().ContraryOperationSymbol, firstElement, _Sources);
}
else
{
_Condition = (BinaryExpressionDefinition) _Sources.First().Value;
}
#endregion
#region Find statement "VIA Edge"
IDNode _EdgeAttr = null;
// Semantic Web Yoda-style...
if (myParseTreeNode.ChildNodes[3].Token.AsSymbol == _GraphQLGrammar.S_VIA)
{
_EdgeAttr = (myParseTreeNode.ChildNodes[4].AstNode as IDNode);
}
else // Human language style...
{
if (myParseTreeNode.ChildNodes[5].Token.AsSymbol == _GraphQLGrammar.S_VIA)
{
_EdgeAttr = (myParseTreeNode.ChildNodes[6].AstNode as IDNode);
}
}
#endregion
#region Find statement "TO Targets"
TupleDefinition tupleDef = null;
// Semantic Web Yoda-style...
if (myParseTreeNode.ChildNodes[5].Token.AsSymbol == _GraphQLGrammar.S_TO)
{
typeNode = (myParseTreeNode.ChildNodes[6].ChildNodes[0].AstNode as ATypeNode);
tupleDef = (myParseTreeNode.ChildNodes[6].ChildNodes[1].AstNode as TupleNode).TupleDefinition;
}
else // Human language style...
{
if (myParseTreeNode.ChildNodes[3].Token.AsSymbol == _GraphQLGrammar.S_TO)
{
typeNode = (myParseTreeNode.ChildNodes[4].ChildNodes[0].AstNode as ATypeNode);
tupleDef = (myParseTreeNode.ChildNodes[4].ChildNodes[1].AstNode as TupleNode).TupleDefinition;
}
}
#endregion
#region Processing...
ParsingResult.PushIExceptional(typeNode.ParsingResult);
var _TargetType = typeNode.ReferenceAndType;
var tupleDefTargetType = new TupleDefinition(tupleDef.KindOfTuple);
foreach (var item in tupleDef.TupleElements)
{
var attrName = _TargetType.TypeName + DBConstants.EdgeTraversalDelimiterSymbol + ((IDChainDefinition)((BinaryExpressionDefinition)item.Value).Left).ContentString;
var leftNode = new IDChainDefinition(attrName, new List<TypeReferenceDefinition>() { _TargetType });
leftNode.AddPart(new ChainPartTypeOrAttributeDefinition(((IDChainDefinition)((BinaryExpressionDefinition)item.Value).Left).ContentString));
var rightNode = ((BinaryExpressionDefinition)item.Value).Right;
var binExpression = new BinaryExpressionDefinition(((BinaryExpressionDefinition)item.Value).OperatorSymbol, leftNode, rightNode);
tupleDefTargetType.AddElement(new TupleElement(item.TypeOfValue, binExpression));
}
_Targets.Add(new AttributeAssignOrUpdateList(new CollectionDefinition(CollectionType.Set, tupleDefTargetType), _EdgeAttr.IDChainDefinition, false));
#endregion
}
