internal ServiceAlterVertexChangeset(RequestAlterVertexType myRequestAlterVertexType) { this.NewTypeName = myRequestAlterVertexType.AlteredTypeName; this.Comment = myRequestAlterVertexType.AlteredComment; this.ToBeAddedProperties = (myRequestAlterVertexType.ToBeAddedProperties == null) ? null : myRequestAlterVertexType.ToBeAddedProperties.Select(x => new ServicePropertyPredefinition(x)).ToArray(); this.ToBeAddedIncomingEdges = (myRequestAlterVertexType.ToBeAddedIncomingEdges == null) ? null : myRequestAlterVertexType.ToBeAddedIncomingEdges.Select(x => new ServiceIncomingEdgePredefinition(x)).ToArray(); this.ToBeAddedOutgoingEdges = (myRequestAlterVertexType.ToBeAddedOutgoingEdges == null) ? null : myRequestAlterVertexType.ToBeAddedOutgoingEdges.Select(x => new ServiceOutgoingEdgePredefinition(x)).ToArray(); this.ToBeAddedIndices = (myRequestAlterVertexType.ToBeAddedIndices == null) ? null : myRequestAlterVertexType.ToBeAddedIndices.Select(x => new ServiceIndexPredefinition(x)).ToArray(); this.ToBeAddedUniques = (myRequestAlterVertexType.ToBeAddedUniques == null) ? null : myRequestAlterVertexType.ToBeAddedUniques.Select(x => new ServiceUniquePredefinition(x)).ToArray(); this.ToBeAddedMandatories = (myRequestAlterVertexType.ToBeAddedMandatories == null) ? null : myRequestAlterVertexType.ToBeAddedMandatories.Select(x => new ServiceMandatoryPredefinition(x)).ToArray(); this.ToBeRemovedProperties = (myRequestAlterVertexType.ToBeRemovedProperties == null) ? null : myRequestAlterVertexType.ToBeRemovedProperties.ToArray(); this.ToBeRemovedIncomingEdges = (myRequestAlterVertexType.ToBeRemovedIncomingEdges == null) ? null : myRequestAlterVertexType.ToBeRemovedIncomingEdges.ToArray(); this.ToBeRemovedOutgoingEdges = (myRequestAlterVertexType.ToBeRemovedOutgoingEdges == null) ? null : myRequestAlterVertexType.ToBeRemovedOutgoingEdges.ToArray(); this.ToBeRemovedIndices = myRequestAlterVertexType.ToBeRemovedIndices; this.ToBeRemovedUniques = (myRequestAlterVertexType.ToBeRemovedUniques == null) ? null : myRequestAlterVertexType.ToBeRemovedUniques.ToArray(); this.ToBeRemovedMandatories = (myRequestAlterVertexType.ToBeRemovedMandatories == null) ? null : myRequestAlterVertexType.ToBeRemovedMandatories.ToArray(); this.ToBeRenamedProperties = myRequestAlterVertexType.ToBeRenamedProperties; this.ToBeDefinedAttributes = (myRequestAlterVertexType.ToBeDefinedAttributes == null) ? null : myRequestAlterVertexType.ToBeDefinedAttributes.Select(x => new ServiceUnknownAttributePredefinition(x)).ToArray(); this.ToBeUndefinedAttributes = (myRequestAlterVertexType.ToBeUndefinedAttributes == null) ? null : myRequestAlterVertexType.ToBeUndefinedAttributes.ToArray(); }
private void ProcessUnique(AAlterTypeCommand myAlterCommand, ref RequestAlterVertexType result) { var command = (AlterType_SetUnique)myAlterCommand; foreach (var aUnique in command.UniqueAttributes) { result.AddUnique(new UniquePredefinition(aUnique)); } }
private static void CheckToBeAddedMandatory(RequestAlterVertexType myAlterVertexTypeRequest, IVertexType vertexType) { var mandatories = myAlterVertexTypeRequest.ToBeAddedMandatories; var addProperties = myAlterVertexTypeRequest.ToBeAddedProperties; if (mandatories == null) return; var attributes = vertexType.GetAttributeDefinitions(false).ToList(); foreach (var aMandatory in mandatories) { if (!attributes.Any(_ => _.Name == aMandatory.MandatoryAttribute) && !addProperties.Any(x => x.AttributeName == aMandatory.MandatoryAttribute)) { throw new AttributeDoesNotExistException(aMandatory.MandatoryAttribute, vertexType.Name); } } }
private void CheckRemoveOutgoingEdges(RequestAlterVertexType myAlterVertexTypeRequest, IVertexType myVertexType, SecurityToken mySecurityToken, TransactionToken myTransactionToken) { if (myAlterVertexTypeRequest.ToBeRemovedOutgoingEdges == null) return; #region get the list of incoming edges that will be deleted too var toBeRemovedIncomingEdgeIDs = new List<long>(); if (myAlterVertexTypeRequest.ToBeRemovedIncomingEdges != null) toBeRemovedIncomingEdgeIDs.AddRange( myAlterVertexTypeRequest.ToBeRemovedIncomingEdges.Select( _ => myVertexType.GetIncomingEdgeDefinition(_).ID)); #endregion foreach (var aOutgoingEdge in myAlterVertexTypeRequest.ToBeRemovedOutgoingEdges) { var attrDef = myVertexType.GetOutgoingEdgeDefinition(aOutgoingEdge); var vertex = _vertexManager.ExecuteManager.GetVertex((long) BaseTypes.OutgoingEdge, attrDef.ID, null, null, myTransactionToken, mySecurityToken); var incomingEdges = vertex.GetIncomingVertices((long) BaseTypes.IncomingEdge, (long) AttributeDefinitions.IncomingEdgeDotRelatedEgde); foreach (var incomingEdge in incomingEdges) { if (!toBeRemovedIncomingEdgeIDs.Contains(incomingEdge.VertexID)) { //TODO a better exception here throw new Exception( "The outgoing edge can not be removed, because there are related incoming edges."); } } } }
/// <summary> /// Adds a unique constraint /// </summary> /// <param name="myToBeAddedUniques"></param> /// <param name="myTransactionToken"></param> /// <param name="mySecurityToken"></param> private IEnumerable<IIndexDefinition> AddUniqueConstraint(RequestAlterVertexType myAlterVertexTypeRequest, TransactionToken myTransactionToken, SecurityToken mySecurityToken) { var indexDefs = new List<IIndexDefinition>(); var uniques = myAlterVertexTypeRequest.ToBeAddedUniques; if (!uniques.IsNotNullOrEmpty()) return indexDefs; foreach (var aUniqueConstraint in uniques) { var predef = new IndexPredefinition(); predef.AddProperty(aUniqueConstraint.Properties); predef.SetVertexType(myAlterVertexTypeRequest.VertexTypeName); indexDefs.Add(_indexManager.CreateIndex(predef, mySecurityToken, myTransactionToken)); } return indexDefs; }
public TResult AlterVertexType <TResult>(sones.Library.Commons.Security.SecurityToken mySecurityToken, long myTransactionID, sones.GraphDB.Request.RequestAlterVertexType myRequestAlterVertexType, sones.GraphDB.Request.Converter.AlterVertexTypeResultConverter <TResult> myOutputconverter) { Stopwatch RunningTime = Stopwatch.StartNew(); var svcVertexType = _GraphDSService.AlterVertexType(mySecurityToken, myTransactionID, new ServiceVertexType(myRequestAlterVertexType.TypeName), new ServiceAlterVertexChangeset(myRequestAlterVertexType)); var vertexType = new RemoteVertexType(svcVertexType, this); RunningTime.Stop(); return(myOutputconverter(new RequestStatistics(new TimeSpan(RunningTime.ElapsedTicks)), vertexType)); }
/// <summary> /// Reads an attribute definition from the GraphML File and stores /// it internal for later usage on vertex / edge reading. /// </summary> /// <param name='myReader'> /// XmlReader /// </param> private void ReadAttributeDefinition(XmlReader myReader) { #region data var attrId = myReader.GetAttribute(GraphMLTokens.ID); var attrFor = myReader.GetAttribute(GraphMLTokens.FOR); var attrName = myReader.GetAttribute(GraphMLTokens.ATTRIBUTE_NAME); var attrType = myReader.GetAttribute(GraphMLTokens.ATTRIBUTE_TYPE).ToLower(); string attrDefault = null; using (var readerAttribute = myReader.ReadSubtree()) { while (readerAttribute.Read()) { if (readerAttribute.Name == GraphMLTokens.DEFAULT) { attrDefault = readerAttribute.ReadElementContentAsString(); } } } // make attribute type DB conform (capitalize first letter) attrType = char.ToUpper(attrType[0]) + attrType.Substring(1).ToLower(); // and store the whole definition _AttributeDefinitions.Add(attrId, new Tuple<string, string, string, string>(attrFor, attrName, attrType, attrDefault)); // get GraphDB internal type attrType = GetInternalTypeName(attrType); #endregion #region alter vertex type with new attribute if(attrFor.Equals(GraphMLTokens.VERTEX)) { var requestAlterVertexType = new RequestAlterVertexType(_VertexTypeName); var propertyPreDefinition = new PropertyPredefinition(attrName, attrType); propertyPreDefinition.SetDefaultValue(attrDefault); requestAlterVertexType.AddProperty(propertyPreDefinition); _GraphDB.AlterVertexType(_SecurityToken, _TransactionToken, requestAlterVertexType, (stats, vType) => vType); } #endregion }
private void ProcessAddAttribute(AAlterTypeCommand myAlterCommand, ref RequestAlterVertexType result) { var command = (AlterVertexType_AddAttributes)myAlterCommand; if (command.ListOfAttributes != null && command.ListOfAttributes.Count > 0) { foreach (var aAttribute in command.ListOfAttributes) { result.AddUnknownAttribute(GenerateUnknownAttribute(aAttribute)); } } else { if (command.BackwardEdgeInformation != null && command.BackwardEdgeInformation.Count > 0) { foreach (var aIncomingEdge in command.BackwardEdgeInformation) { result.AddIncomingEdge(GenerateAIncomingEdge(aIncomingEdge)); } } } }
private void ProcessAlterCommand(AAlterTypeCommand myAlterCommand, ref RequestAlterVertexType result) { switch (myAlterCommand.AlterType) { case TypesOfAlterCmd.DropIndex: ProcessDropIndex(myAlterCommand, ref result); break; case TypesOfAlterCmd.AddIndex: ProcessAddIndex(myAlterCommand, ref result); break; case TypesOfAlterCmd.AddAttribute: ProcessAddAttribute(myAlterCommand, ref result); break; case TypesOfAlterCmd.DropAttribute: ProcessDropAttribute(myAlterCommand, ref result); break; case TypesOfAlterCmd.RenameAttribute: ProcessRenameAttribute(myAlterCommand, ref result); break; case TypesOfAlterCmd.RenameType: ProcessRenameVertexType(myAlterCommand, ref result); break; case TypesOfAlterCmd.RenameIncomingEdge: ProcessRenameIncomingEdge(myAlterCommand, ref result); break; case TypesOfAlterCmd.Unqiue: ProcessUnique(myAlterCommand, ref result); break; case TypesOfAlterCmd.DropUnqiue: ProcessDropUnique(myAlterCommand, ref result); break; case TypesOfAlterCmd.Mandatory: ProcessMandatory(myAlterCommand, ref result); break; case TypesOfAlterCmd.DropMandatory: ProcessDropMandatory(myAlterCommand, ref result); break; case TypesOfAlterCmd.ChangeComment: ProcessChangeComment(myAlterCommand, ref result); break; case TypesOfAlterCmd.DefineAttribute: ProcessDefineAttribute(myAlterCommand, ref result); break; case TypesOfAlterCmd.UndefineAttribute: ProcessUndefineAttribute(myAlterCommand, ref result); break; default: break; } }
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; }
/// <summary> /// Checks the to be renamed attributes /// </summary> /// <param name="myAlterVertexTypeRequest"></param> /// <param name="vertexType"></param> private static void CheckToBeRenamedAttributes(RequestAlterVertexType myAlterVertexTypeRequest, IVertexType vertexType) { if (myAlterVertexTypeRequest.ToBeRenamedProperties == null) return; foreach (var aToBeRenamedAttributes in myAlterVertexTypeRequest.ToBeRenamedProperties) { if (!CheckOldName(aToBeRenamedAttributes.Key, vertexType)) { throw new InvalidAlterVertexTypeException( String.Format( "It is not possible to rename {0} into {1}. The to be renamed attribute does not exist.", aToBeRenamedAttributes.Key, aToBeRenamedAttributes.Value)); } if (!CheckNewName(aToBeRenamedAttributes.Value, vertexType)) { throw new InvalidAlterVertexTypeException( String.Format( "It is not possible to rename {0} into {1}. The new attribute name already exists.", aToBeRenamedAttributes.Key, aToBeRenamedAttributes.Value)); } } }
/// <summary> /// Checks if the to be removed attributes exists on this type /// </summary> /// <param name="myAlterVertexTypeRequest"></param> /// <param name="vertexType"></param> private static void CheckToBeRemovedAttributes(RequestAlterVertexType myAlterVertexTypeRequest, IVertexType vertexType) { #region properties var attributesOfCurrentVertexType = vertexType.GetAttributeDefinitions(false).ToList(); if (myAlterVertexTypeRequest.ToBeRemovedProperties != null) { foreach (var aToBeDeletedAttribute in myAlterVertexTypeRequest.ToBeRemovedProperties) { if (!attributesOfCurrentVertexType.Any(_ => _.Name == aToBeDeletedAttribute)) { throw new VertexAttributeIsNotDefinedException(aToBeDeletedAttribute); } } } #endregion #region outgoing Edges if (myAlterVertexTypeRequest.ToBeRemovedOutgoingEdges != null) { foreach (var aToBeDeletedAttribute in myAlterVertexTypeRequest.ToBeRemovedOutgoingEdges) { if (!attributesOfCurrentVertexType.Any(_ => _.Name == aToBeDeletedAttribute)) { throw new VertexAttributeIsNotDefinedException(aToBeDeletedAttribute); } } } #endregion #region incoming edges if (myAlterVertexTypeRequest.ToBeRemovedIncomingEdges != null) { foreach (var aToBeDeletedAttribute in myAlterVertexTypeRequest.ToBeRemovedIncomingEdges) { if (!attributesOfCurrentVertexType.Any(_ => _.Name == aToBeDeletedAttribute)) { throw new VertexAttributeIsNotDefinedException(aToBeDeletedAttribute); } } } #endregion }
public override IVertexType AlterVertexType(RequestAlterVertexType myAlterVertexTypeRequest, SecurityToken mySecurityToken, TransactionToken myTransactionToken) { var vertexType = _vertexTypeManager.GetVertexType(myAlterVertexTypeRequest.VertexTypeName, myTransactionToken, mySecurityToken); if (myAlterVertexTypeRequest.ToBeAddedUnknownAttributes != null) { var toBeConverted = myAlterVertexTypeRequest.ToBeAddedUnknownAttributes.ToArray(); foreach (var unknown in toBeConverted) { if (BinaryPropertyPredefinition.TypeName.Equals(unknown.AttributeType)) { var prop = ConvertUnknownToBinaryProperty(unknown); myAlterVertexTypeRequest.AddBinaryProperty(prop); } else if (IsBaseType(unknown.AttributeType)) { var prop = ConvertUnknownToProperty(unknown); myAlterVertexTypeRequest.AddProperty(prop); } else if (unknown.AttributeType.Contains(IncomingEdgePredefinition.TypeSeparator)) { var prop = ConvertUnknownToIncomingEdge(unknown); myAlterVertexTypeRequest.AddIncomingEdge(prop); } else { var prop = ConvertUnknownToOutgoingEdge(unknown); myAlterVertexTypeRequest.AddOutgoingEdge(prop); } } myAlterVertexTypeRequest.ResetUnknown(); } if (myAlterVertexTypeRequest.ToBeRemovedUnknownAttributes != null) { foreach (var unknownProp in myAlterVertexTypeRequest.ToBeRemovedUnknownAttributes) { var attrDef = vertexType.GetAttributeDefinition(unknownProp); if (attrDef == null) throw new VertexAttributeIsNotDefinedException(unknownProp); switch (attrDef.Kind) { case AttributeType.Property: myAlterVertexTypeRequest.RemoveProperty(unknownProp); break; case AttributeType.OutgoingEdge: myAlterVertexTypeRequest.RemoveOutgoingEdge(unknownProp); break; case AttributeType.IncomingEdge: myAlterVertexTypeRequest.RemoveIncomingEdge(unknownProp); break; case AttributeType.BinaryProperty: myAlterVertexTypeRequest.RemoveBinaryProperty(unknownProp); break; default: throw new Exception("The enumeration AttributeType was changed, but not this switch statement."); } } myAlterVertexTypeRequest.ClearToBeRemovedUnknownAttributes(); } #region checks CheckToBeAddedAttributes(myAlterVertexTypeRequest, vertexType); CheckToBeRemovedAttributes(myAlterVertexTypeRequest, vertexType); CheckToBeRenamedAttributes(myAlterVertexTypeRequest, vertexType); CheckNewVertexTypeName(myAlterVertexTypeRequest.AlteredVertexTypeName, mySecurityToken, myTransactionToken); CheckToBeAddedMandatory(myAlterVertexTypeRequest, vertexType); CheckToBeAddedUniques(myAlterVertexTypeRequest, vertexType); CheckToBeRemovedMandatoryAndUnique(myAlterVertexTypeRequest.ToBeRemovedMandatories, myAlterVertexTypeRequest.ToBeRemovedUniques, vertexType); CheckToBeAddedIndices(myAlterVertexTypeRequest.ToBeAddedIndices, vertexType); CheckToBeRemovedIndices(myAlterVertexTypeRequest.ToBeRemovedIndices, vertexType); #endregion return null; }
private static void CheckToBeAddedUniques(RequestAlterVertexType myAlterVertexTypeRequest, IVertexType vertexType) { var uniques = myAlterVertexTypeRequest.ToBeAddedUniques; var addProperties = myAlterVertexTypeRequest.ToBeAddedProperties; if (uniques == null) return; var attributes = vertexType.GetAttributeDefinitions(false).ToList(); foreach (var aUnique in uniques) { foreach (var aAttribute in aUnique.Properties) { if (!attributes.Any(_ => _.Name == aAttribute) && !addProperties.Any(x => x.AttributeName == aAttribute)) { throw new AttributeDoesNotExistException(aAttribute, vertexType.Name); } } } }
private void ProcessRenameAttribute(AAlterTypeCommand myAlterCommand, ref RequestAlterVertexType result) { var command = (AlterType_RenameAttribute)myAlterCommand; result.RenameAttribute(command.OldName, command.NewName); }
private void ProcessDropAttribute(AAlterTypeCommand myAlterCommand, ref RequestAlterVertexType result) { var command = (AlterType_DropAttributes)myAlterCommand; foreach (var aAttribute in command.ListOfAttributes) { result.RemoveUnknownAttribute(aAttribute); } }
private void ProcessDropIndex(AAlterTypeCommand myAlterCommand, ref RequestAlterVertexType result) { var command = (AlterType_DropIndices)myAlterCommand; foreach (var aIndex in command.IdxDropList) { result.RemoveIndex(aIndex.Key, aIndex.Value); } }
private void ProcessUndefineAttribute(AAlterTypeCommand myAlterCommand, ref RequestAlterVertexType result) { var command = (AlterType_UndefineAttributes)myAlterCommand; if (command.ListOfAttributes != null && command.ListOfAttributes.Count > 0) { foreach (var aAttribute in command.ListOfAttributes) { result.UndefineAttribute(aAttribute); } } }
private void ProcessAddIndex(AAlterTypeCommand myAlterCommand, ref RequestAlterVertexType result) { var command = (AlterType_AddIndices)myAlterCommand; foreach (var aIndexDefinition in command.IdxDefinitionList) { result.AddIndex(GenerateIndex(aIndexDefinition)); } }
public abstract IVertexType AlterVertexType(RequestAlterVertexType myAlterVertexTypeRequest, SecurityToken mySecurityToken, TransactionToken myTransactionToken);
private void ProcessChangeComment(AAlterTypeCommand myAlterCommand, ref RequestAlterVertexType result) { var command = (AlterType_ChangeComment)myAlterCommand; result.SetComment(command.NewComment); }
public static RequestAlterVertexType MakeRequestAlterVertexType(ServiceVertexType myVertexType, ServiceAlterVertexChangeset myChangeset) { var Request = new RequestAlterVertexType(myVertexType.Name); #region Add Attributes if (myChangeset.ToBeAddedProperties != null) { foreach (var toAdd in myChangeset.ToBeAddedProperties) { Request.AddProperty(toAdd.ToPropertyPredefinition()); } } if (myChangeset.ToBeAddedIncomingEdges != null) { foreach (var toAdd in myChangeset.ToBeAddedIncomingEdges) { Request.AddIncomingEdge(toAdd.ToIncomingEdgePredefinition()); } } if (myChangeset.ToBeAddedOutgoingEdges != null) { foreach (var toAdd in myChangeset.ToBeAddedOutgoingEdges) { Request.AddOutgoingEdge(toAdd.ToOutgoingEdgePredefinition()); } } if (myChangeset.ToBeAddedUniques != null) { foreach (var toAdd in myChangeset.ToBeAddedUniques) { Request.AddUnique(toAdd.ToUniquePredefinition()); } } if (myChangeset.ToBeAddedMandatories != null) { foreach (var toAdd in myChangeset.ToBeAddedMandatories) { Request.AddMandatory(toAdd.ToMandatoryPredefinition()); } } if (myChangeset.ToBeAddedIndices != null) { foreach (var toAdd in myChangeset.ToBeAddedIndices) { Request.AddIndex(toAdd.ToIndexPredefinition()); } } #endregion #region Remove Attributes if (myChangeset.ToBeRemovedProperties != null) { foreach (var toDel in myChangeset.ToBeRemovedProperties) { Request.RemoveProperty(toDel); } } if (myChangeset.ToBeRemovedIncomingEdges != null) { foreach (var toDel in myChangeset.ToBeRemovedIncomingEdges) { Request.RemoveIncomingEdge(toDel); } } if (myChangeset.ToBeRemovedOutgoingEdges != null) { foreach (var toDel in myChangeset.ToBeRemovedOutgoingEdges) { Request.RemoveOutgoingEdge(toDel); } } if (myChangeset.ToBeRemovedUniques != null) { foreach (var toDel in myChangeset.ToBeRemovedUniques) { Request.RemoveUnique(toDel); } } if (myChangeset.ToBeRemovedMandatories != null) { foreach (var toDel in myChangeset.ToBeRemovedMandatories) { Request.RemoveMandatory(toDel); } } if (myChangeset.ToBeRemovedIndices != null) { foreach (var toDel in myChangeset.ToBeRemovedIndices) { Request.RemoveIndex(toDel.Key, toDel.Value); } } #endregion #region define / undefine if (myChangeset.ToBeDefinedAttributes != null) { foreach (var toDefine in myChangeset.ToBeDefinedAttributes) { Request.DefineAttribute(toDefine.ToUnknownAttributePredefinition()); } } if (myChangeset.ToBeUndefinedAttributes != null) { foreach (var toUndefine in myChangeset.ToBeUndefinedAttributes) { Request.UndefineAttribute(toUndefine); } } #endregion #region Rename Task if (myChangeset.ToBeRenamedProperties != null) { foreach (var toRename in myChangeset.ToBeRenamedProperties) { Request.RenameAttribute(toRename.Key, toRename.Value); } } #endregion if (myChangeset.Comment != null) Request.SetComment(myChangeset.Comment); if (myChangeset.NewTypeName != null) Request.RenameType(myChangeset.NewTypeName); //todo add unknown attribute return Request; }
private void ProcessDropMandatory(AAlterTypeCommand myAlterCommand, ref RequestAlterVertexType result) { var command = (AlterType_DropMandatory)myAlterCommand; result.RemoveMandatory(command.DroppedMandatory); }
public override IVertexType AlterVertexType(RequestAlterVertexType myAlterVertexTypeRequest, SecurityToken mySecurityToken, TransactionToken myTransactionToken) { var vertexType = GetVertexType(myAlterVertexTypeRequest.VertexTypeName, myTransactionToken, mySecurityToken); #region remove stuff CheckRemoveOutgoingEdges(myAlterVertexTypeRequest, vertexType, mySecurityToken, myTransactionToken); //done RemoveMandatoryConstraint(myAlterVertexTypeRequest.ToBeRemovedMandatories, vertexType, myTransactionToken, mySecurityToken); //done RemoveUniqueConstraint(myAlterVertexTypeRequest.ToBeRemovedUniques, vertexType, myTransactionToken, mySecurityToken); //done RemoveIndices(myAlterVertexTypeRequest.ToBeRemovedIndices, vertexType, myTransactionToken, mySecurityToken); //done RemoveAttributes(myAlterVertexTypeRequest.ToBeRemovedIncomingEdges, myAlterVertexTypeRequest.ToBeRemovedOutgoingEdges, myAlterVertexTypeRequest.ToBeRemovedProperties, vertexType, myTransactionToken, mySecurityToken); #endregion #region add stuff //done AddAttributes(myAlterVertexTypeRequest.ToBeAddedBinaryProperties, myAlterVertexTypeRequest.ToBeAddedIncomingEdges, myAlterVertexTypeRequest.ToBeAddedOutgoingEdges, myAlterVertexTypeRequest.ToBeAddedProperties, vertexType, myTransactionToken, mySecurityToken); //get altered type vertexType = GetVertexType(myAlterVertexTypeRequest.VertexTypeName, myTransactionToken, mySecurityToken); //done AddMandatoryConstraint(myAlterVertexTypeRequest.ToBeAddedMandatories, vertexType, myTransactionToken, mySecurityToken); //done var indexDefinitions = AddUniqueConstraint(myAlterVertexTypeRequest, myTransactionToken, mySecurityToken); //done AddIndices(myAlterVertexTypeRequest.ToBeAddedIndices, vertexType, myTransactionToken, mySecurityToken); //done RenameAttributes(myAlterVertexTypeRequest.ToBeRenamedProperties, vertexType, myTransactionToken, mySecurityToken); #endregion var info = new TypeInfo(); info.VertexInfo = new VertexInformation((long)BaseTypes.VertexType, vertexType.ID); ConnectVertexToUniqueIndex(info, indexDefinitions, mySecurityToken, myTransactionToken); #region misc //done ChangeCommentOnVertexType(vertexType, myAlterVertexTypeRequest.AlteredComment, myTransactionToken,mySecurityToken); //done RenameVertexType(vertexType, myAlterVertexTypeRequest.AlteredVertexTypeName, myTransactionToken, mySecurityToken); #endregion CleanUpTypes(); _indexManager.RebuildIndices((long)BaseTypes.VertexType, myTransactionToken, mySecurityToken); return GetVertexType(vertexType.ID, myTransactionToken, mySecurityToken); }
private void ProcessMandatory(AAlterTypeCommand myAlterCommand, ref RequestAlterVertexType result) { var command = (AlterType_SetMandatory)myAlterCommand; foreach (var aMandatory in command.MandatoryAttributes) { result.AddMandatory(new MandatoryPredefinition(aMandatory)); } }
private void ProcessDropUnique(AAlterTypeCommand myAlterCommand, ref RequestAlterVertexType result) { var command = (AlterType_DropUnique)myAlterCommand; result.RemoveUnique(command.DroppedUnique); }
/// <summary> /// Checks if the to be added attributes exist in the given vertex type or derived oness /// </summary> /// <param name="myAlterVertexTypeRequest"></param> /// <param name="vertexType"></param> private static void CheckToBeAddedAttributes(RequestAlterVertexType myAlterVertexTypeRequest, IVertexType vertexType) { foreach (var aVertexType in vertexType.GetDescendantVertexTypesAndSelf()) { var attributesOfCurrentVertexType = aVertexType.GetAttributeDefinitions(false).ToList(); #region binary properties if (myAlterVertexTypeRequest.ToBeAddedBinaryProperties != null) { foreach (var aToBeAddedAttribute in myAlterVertexTypeRequest.ToBeAddedBinaryProperties) { if (attributesOfCurrentVertexType.Any(_ => _.Name == aToBeAddedAttribute.AttributeName)) { throw new VertexAttributeAlreadyExistsException(aToBeAddedAttribute.AttributeName); } } } #endregion #region outgoing edges if (myAlterVertexTypeRequest.ToBeAddedOutgoingEdges != null) { foreach (var aToBeAddedAttribute in myAlterVertexTypeRequest.ToBeAddedOutgoingEdges) { if (attributesOfCurrentVertexType.Any(_ => _.Name == aToBeAddedAttribute.AttributeName)) { throw new VertexAttributeAlreadyExistsException(aToBeAddedAttribute.AttributeName); } } } #endregion #region Incoming edges if (myAlterVertexTypeRequest.ToBeAddedIncomingEdges != null) { foreach (var aToBeAddedAttribute in myAlterVertexTypeRequest.ToBeAddedIncomingEdges) { if (attributesOfCurrentVertexType.Any(_ => _.Name == aToBeAddedAttribute.AttributeName)) { throw new VertexAttributeAlreadyExistsException(aToBeAddedAttribute.AttributeName); } } } #endregion #region property if (myAlterVertexTypeRequest.ToBeAddedProperties != null) { foreach (var aToBeAddedAttribute in myAlterVertexTypeRequest.ToBeAddedProperties) { if (attributesOfCurrentVertexType.Any(_ => _.Name == aToBeAddedAttribute.AttributeName)) { throw new VertexAttributeAlreadyExistsException(aToBeAddedAttribute.AttributeName); } } } #endregion #region unknown attributes if (myAlterVertexTypeRequest.ToBeAddedUnknownAttributes != null) { foreach (var aToBeAddedAttribute in myAlterVertexTypeRequest.ToBeAddedUnknownAttributes) { if (attributesOfCurrentVertexType.Any(_ => _.Name == aToBeAddedAttribute.AttributeName)) { throw new VertexAttributeAlreadyExistsException(aToBeAddedAttribute.AttributeName); } } } #endregion } }