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 }