/// <summary> /// Execute the removal of attribute indices /// <seealso cref=" AAlterTypeCommand"/> /// </summary> public override Exceptional Execute(DBContext myDBContext, GraphDBType myGraphDBType) { var retExceptional = new Exceptional(); foreach (var index in _IdxDropList) { var dropIdxExcept = myGraphDBType.RemoveIndex(index.Key, index.Value, myDBContext); if (!dropIdxExcept.Success()) { retExceptional.PushIExceptional(dropIdxExcept); } } return retExceptional; }
/// <summary> /// Executes the removal of certain myAttributes. /// <seealso cref=" AAlterTypeCommand"/> /// </summary> public override Exceptional Execute(DBContext myDBContext, GraphDBType myGraphDBType) { Exceptional result = new Exceptional(); foreach (String aAttributeName in _ListOfAttributes) { var attr = myGraphDBType.GetTypeAttributeByName(aAttributeName); if (attr != null) { var idxs = new List<Indices.AAttributeIndex>(myGraphDBType.GetAttributeIndices(myDBContext, attr.UUID)); foreach (var item in idxs) { var remIdxResult = myGraphDBType.RemoveIndex(item.IndexName, item.IndexEdition, myDBContext); if (remIdxResult.Failed()) { result.PushIExceptional(remIdxResult); } } } else { result.PushIError(new Error_AttributeIsNotDefined(aAttributeName)); return result; } //Hack: remove myAttributes in DBObjects var aTempResult = myDBContext.DBTypeManager.RemoveAttributeFromType(myGraphDBType.Name, aAttributeName, myDBContext.DBTypeManager); if (aTempResult.Failed()) { result.PushIExceptional(aTempResult); return result; } } return result; }
public override Exceptional Execute(DBContext dbContext, GraphDBType graphDBType) { var listOfTypeAttributes = new Dictionary<TypeAttribute, GraphDBType>(); var retExcept = new Exceptional(); var existingTypeAttributes = graphDBType.GetAllAttributes(dbContext); foreach (var attr in _ListOfAttributes) { var createExcept = attr.CreateTypeAttribute(dbContext); if (!createExcept.Success()) { retExcept.PushIExceptional(createExcept); } if (existingTypeAttributes.Exists(item => item.Name == createExcept.Value.Name)) { retExcept.PushIExceptional(new Exceptional(new Error_AttributeAlreadyExists(createExcept.Value.Name))); } var attrType = dbContext.DBTypeManager.GetTypeByName(attr.AttributeType.Name); if (attrType == null) { retExcept.PushIExceptional(new Exceptional(new Error_TypeDoesNotExist(attr.AttributeType.Name))); return retExcept; } if (attrType.IsUserDefined) { retExcept.PushIExceptional(new Exceptional(new Error_InvalidReferenceAssignmentOfUndefAttr())); return retExcept; } createExcept.Value.DBTypeUUID = attrType.UUID; createExcept.Value.RelatedGraphDBTypeUUID = graphDBType.UUID; graphDBType.AddAttribute(createExcept.Value, dbContext.DBTypeManager, true); var flushExcept = dbContext.DBTypeManager.FlushType(graphDBType); if (!flushExcept.Success()) { retExcept.PushIExceptional(flushExcept); } listOfTypeAttributes.Add(createExcept.Value, attrType); } var dbobjects = dbContext.DBObjectCache.SelectDBObjectsForLevelKey(new LevelKey(graphDBType, dbContext.DBTypeManager), dbContext); foreach (var item in dbobjects) { if (!item.Success()) { retExcept.PushIExceptional(item); } else { var undefAttrExcept = item.Value.GetUndefinedAttributePayload(dbContext.DBObjectManager); if (!undefAttrExcept.Success()) { retExcept.PushIExceptional(undefAttrExcept); } foreach (var attr in listOfTypeAttributes) { IObject value; if (undefAttrExcept.Value.TryGetValue(attr.Key.Name, out value)) { var typeOfOperator = GraphDBTypeMapper.ConvertGraph2CSharp(attr.Value.Name); if (GraphDBTypeMapper.IsAValidAttributeType(attr.Value, typeOfOperator, dbContext, value)) { item.Value.AddAttribute(attr.Key.UUID, value); var removeExcept = item.Value.RemoveUndefinedAttribute(attr.Key.Name, dbContext.DBObjectManager); if (!removeExcept.Success()) { retExcept.PushIExceptional(removeExcept); } var flushExcept = dbContext.DBObjectManager.FlushDBObject(item.Value); if (!flushExcept.Success()) { retExcept.PushIExceptional(flushExcept); } } else { retExcept.PushIExceptional(new Exceptional(new Error_InvalidUndefAttrType(attr.Key.Name, attr.Value.Name))); } } } } } return Exceptional.OK; }
public Exceptional<QueryResult> AlterType(DBContext dbInnerContext, GraphDBType atype, AAlterTypeCommand alterTypeCommand) { var result = alterTypeCommand.Execute(dbInnerContext, atype); if (!result.Success()) { var retVal = new Exceptional<QueryResult>(result); return retVal; } else { var resultReadout = alterTypeCommand.CreateVertex(dbInnerContext, atype); if (resultReadout != null) { var retVal = new Exceptional<QueryResult>(new QueryResult(resultReadout)); retVal.PushIExceptional(result); return retVal; } return new Exceptional<QueryResult>(result); } }
internal Exceptional SetBackwardEdges(Dictionary<AttributeUUID, IObject> userdefinedAttributes, ObjectUUID reference) { var returnVal = new Exceptional(); #region process attributes foreach (var aUserDefinedAttribute in userdefinedAttributes) { #region Data GraphDBType typeOFAttribute = null; TypeAttribute attributesOfType = null; #endregion #region get GraphType of Attribute //attributesOfType = _graphDBType.Attributes[aUserDefinedAttribute.Key]; attributesOfType = _graphDBType.GetTypeAttributeByUUID(aUserDefinedAttribute.Key); typeOFAttribute = _dbContext.DBTypeManager.GetTypeByUUID(attributesOfType.DBTypeUUID); #endregion /* The DBO independent version */ var beEdge = new EdgeKey(_graphDBType.UUID, attributesOfType.UUID); var runMT = DBConstants.RunMT; runMT = false; if (runMT) { #region The parallel version /**/ /* The parallel version */ Parallel.ForEach(((IReferenceEdge)aUserDefinedAttribute.Value).GetAllReferenceIDs(), (uuid) => { var addExcept = _dbContext.DBObjectManager.AddBackwardEdge(uuid, attributesOfType.DBTypeUUID, beEdge, reference); if (!addExcept.Success()) { returnVal.PushIExceptional(addExcept); } }); if (!returnVal.Success()) { return returnVal; } /**/ #endregion } else { #region Single thread foreach (var uuid in ((IReferenceEdge)aUserDefinedAttribute.Value).GetAllReferenceIDs()) { var addExcept = _dbContext.DBObjectManager.AddBackwardEdge(uuid, attributesOfType.DBTypeUUID, beEdge, reference); if (addExcept.Failed()) { return new Exceptional(addExcept); } } #endregion } } #endregion return Exceptional.OK; } private Exceptional AddMandatoryAttributes(DBContext myDBContext, GraphDBType myGraphDBType, ManipulationAttributes myManipulationAttributes) { Boolean mandatoryDefaults = (Boolean)myDBContext.DBSettingsManager.GetSettingValue((new SettingDefaultsOnMandatory()).ID, myDBContext, TypesSettingScope.TYPE, myGraphDBType).Value.Value; TypeAttribute typeAttr = null; GraphDBType typeOfAttr = null; var typeMandatoryAttribs = myGraphDBType.GetMandatoryAttributesUUIDs(myDBContext.DBTypeManager); if ((myManipulationAttributes.MandatoryAttributes.Count < typeMandatoryAttribs.Count()) && !mandatoryDefaults) return new Exceptional(new Error_MandatoryConstraintViolation(myGraphDBType.Name)); foreach (var attrib in typeMandatoryAttribs) { if (!myManipulationAttributes.MandatoryAttributes.Contains(attrib)) { //if we have mandatory attributes in _graphDBType but not in the current statement and USE_DEFAULTS_ON_MANDATORY is true then do this if (mandatoryDefaults) { typeAttr = myGraphDBType.GetTypeAttributeByUUID(attrib); if (typeAttr == null) return new Exceptional(new Error_AttributeIsNotDefined(myGraphDBType.Name, typeAttr.Name)); typeOfAttr = myDBContext.DBTypeManager.GetTypeByUUID(typeAttr.DBTypeUUID); IObject defaultValue = typeAttr.DefaultValue; if (defaultValue == null) defaultValue = typeAttr.GetDefaultValue(myDBContext); myManipulationAttributes.Attributes.Add(new TypeAndAttributeDefinition(typeAttr, typeOfAttr), defaultValue); } else { return new Exceptional(new Error_MandatoryConstraintViolation("Attribute \"" + myGraphDBType.GetTypeAttributeByUUID(attrib).Name + "\" of Type \"" + myGraphDBType.Name + "\" is mandatory.")); } } } return Exceptional.OK; } private Exceptional<Boolean> DeleteObjectReferences(ObjectUUID myObjectUUID, BackwardEdgeStream myObjectBackwardEdges) { foreach (var item in myObjectBackwardEdges) { var type = _dbContext.DBTypeManager.GetTypeByUUID(item.Key.TypeUUID); if (type == null) { return new Exceptional<Boolean>(new Error_TypeDoesNotExist("")); } foreach (var objID in item.Value.GetAllEdgeDestinations(_dbContext.DBObjectCache)) { if (objID.Failed()) { return new Exceptional<Boolean>(objID); } var attr = objID.Value.GetAttribute(item.Key.AttrUUID); if (attr is IReferenceEdge) { var removeResult = ((IReferenceEdge)attr).RemoveUUID(myObjectUUID); if (removeResult) { #region Sucessfully removed the single edge ref - so remove the attribute if (attr is ASingleReferenceEdgeType) { objID.Value.RemoveAttribute(item.Key.AttrUUID); } #endregion } else { return new Exceptional<bool>(new Error_NotImplemented(new System.Diagnostics.StackTrace(true))); } } var flushExcept = _dbContext.DBObjectManager.FlushDBObject(objID.Value); if (!flushExcept.Success()) return new Exceptional<bool>(flushExcept.IErrors.First()); } } return new Exceptional<bool>(true); } private Dictionary<TypeAndAttributeDefinition, IObject> ExtractDefinedAttributes(Dictionary<string, Tuple<TypeAttribute, IObject>> attrsForResult, DBTypeManager myTypeManager) { return attrsForResult.Where(item => !(item.Value.Item1 is UndefinedTypeAttribute)).ToDictionary(key => new TypeAndAttributeDefinition(key.Value.Item1, key.Value.Item1.GetDBType(myTypeManager)), value => value.Value.Item2); } private Dictionary<string, IObject> ExtractUndefindedAttributes(Dictionary<string, Tuple<TypeAttribute, IObject>> attrsForResult) { return attrsForResult.Where(item => (item.Value.Item1 is UndefinedTypeAttribute)).ToDictionary(key => key.Key, value => value.Value.Item2); } private AttributeUUID GetAttributesToCheckForUnique(AAttributeAssignOrUpdateOrRemove myAAttributeAssignOrUpdateOrRemove) { if (myAAttributeAssignOrUpdateOrRemove is AAttributeRemove) return null; if (myAAttributeAssignOrUpdateOrRemove.AttributeIDChain.IsUndefinedAttribute) { return null; } if (myAAttributeAssignOrUpdateOrRemove is AAttributeAssignOrUpdate) { return ((AAttributeAssignOrUpdate)myAAttributeAssignOrUpdateOrRemove).AttributeIDChain.LastAttribute.UUID; } if (myAAttributeAssignOrUpdateOrRemove is AttributeAssignOrUpdateList) return ((AttributeAssignOrUpdateList)myAAttributeAssignOrUpdateOrRemove).AttributeIDChain.LastAttribute.UUID; throw new GraphDBException(new Error_NotImplemented(new System.Diagnostics.StackTrace(true))); } /// <summary> /// Create a readout based on the passed <paramref name="attributes"/>, <paramref name="undefinedAttributes"/>, <paramref name="specialTypeAttributes"/> which are all optional /// </summary> /// <param name="myDBObjectStreamExceptional"></param> /// <param name="attributes"></param> /// <param name="undefinedAttributes"></param> /// <param name="specialTypeAttributes"></param> /// <returns></returns> private Exceptional<Vertex> GetManipulationResultSet(Exceptional<DBObjectStream> myDBObjectStreamExceptional, Dictionary<TypeAndAttributeDefinition, IObject> attributes = null, Dictionary<String, IObject> undefinedAttributes = null, Dictionary<ASpecialTypeAttribute, Object> specialTypeAttributes = null) { Vertex _Vertex = null; #region Return inserted attributes #region attributes if (!attributes.IsNullOrEmpty()) { _Vertex = new Vertex(attributes.ToDictionary(key => key.Key.Definition.Name, value => value.Value.GetReadoutValue())); } else { _Vertex = new Vertex(); } #endregion #region UndefinedAttributes if (!undefinedAttributes.IsNullOrEmpty()) { foreach (var undefAttr in undefinedAttributes) { _Vertex.AddAttribute(undefAttr.Key, undefAttr.Value.GetReadoutValue()); } } #endregion #region SpecialTypeAttributes if (!specialTypeAttributes.IsNullOrEmpty()) { foreach (var specAttr in specialTypeAttributes) { _Vertex.AddAttribute(specAttr.Key.Name, specAttr.Value); } } #endregion #region UUID if (!_Vertex.HasAttribute(SpecialTypeAttribute_UUID.AttributeName)) { var extractedValue = new SpecialTypeAttribute_UUID().ExtractValue(myDBObjectStreamExceptional.Value, _graphDBType, _dbContext); if (extractedValue.Failed()) { return new Exceptional<Vertex>(extractedValue); } _Vertex.AddAttribute(SpecialTypeAttribute_UUID.AttributeName, extractedValue.Value.GetReadoutValue()); } #endregion #region REVISION if (!_Vertex.HasAttribute(SpecialTypeAttribute_REVISION.AttributeName)) // If it was updated by SpecialTypeAttributes we do not need to add them again { var extractedValue = new SpecialTypeAttribute_REVISION().ExtractValue(myDBObjectStreamExceptional.Value, _graphDBType, _dbContext); if (extractedValue.Failed()) { return new Exceptional<Vertex>(extractedValue); } _Vertex.AddAttribute(SpecialTypeAttribute_REVISION.AttributeName, extractedValue.Value.GetReadoutValue()); } #endregion #endregion return new Exceptional<Vertex>(_Vertex); } /// <summary> /// Get attribute assignments for new DBObjects. /// </summary> /// <param name="myAttributeAssigns">The interesting ParseTreeNode.</param> /// <param name="typeManager">The TypeManager of the GraphDB.</param> /// <returns>A Dictionary of AttributeAssignments</returns> private Exceptional<ManipulationAttributes> GetRecursiveAttributes(List<AAttributeAssignOrUpdate> myAttributeAssigns, DBContext myDBContext, GraphDBType myGraphDBType) { #region Data var manipulationAttributes = new ManipulationAttributes(); var resultExcept = new Exceptional<ManipulationAttributes>(); if (myAttributeAssigns == null) { return new Exceptional<ManipulationAttributes>(manipulationAttributes); } TypeAttribute attr; ADBBaseObject typedAttributeValue; BasicType correspondingCSharpType; Warning_UndefinedAttribute undefAttrWarning = null; var typeMandatoryAttribs = myGraphDBType.GetMandatoryAttributesUUIDs(myDBContext.DBTypeManager); var setExcept = myDBContext.DBSettingsManager.GetSetting(SettingUndefAttrBehaviour.UUID, myDBContext, TypesSettingScope.DB); if (!setExcept.Success()) { return new Exceptional<ManipulationAttributes>(setExcept); } var undefAttrBehave = (SettingUndefAttrBehaviour)setExcept.Value; #endregion #region get Data #region proceed list foreach (var aAttributeAssign in myAttributeAssigns) { var validateResult = aAttributeAssign.AttributeIDChain.Validate(myDBContext, true); if (validateResult.Failed()) { return new Exceptional<ManipulationAttributes>(validateResult); } #region Undefined attributes - Refactor and add undefined logic into defined attribute AssignsOrUpdate System.Diagnostics.Debug.Assert(aAttributeAssign.AttributeIDChain != null); //in this case we have an undefined attribute if (aAttributeAssign.AttributeIDChain.IsUndefinedAttribute) { var UndefAttrName = aAttributeAssign.AttributeIDChain.UndefinedAttribute; switch (undefAttrBehave.Behaviour) { case UndefAttributeBehaviour.disallow: return new Exceptional<ManipulationAttributes>(new Error_UndefinedAttributes()); case UndefAttributeBehaviour.warn: resultExcept.PushIWarning(new Warning_UndefinedAttribute(aAttributeAssign.AttributeIDChain)); break; } if (aAttributeAssign is AttributeAssignOrUpdateList) { #region AttributeAssignCollection var colDefinition = (aAttributeAssign as AttributeAssignOrUpdateList).CollectionDefinition; EdgeTypeListOfBaseObjects valueList = new EdgeTypeListOfBaseObjects(); foreach (var tuple in colDefinition.TupleDefinition) { if (tuple.TypeOfValue == BasicType.Unknown) valueList.Add((tuple.Value as ValueDefinition).Value); else if (tuple.Value is ValueDefinition) valueList.Add((tuple.Value as ValueDefinition).Value); else return new Exceptional<ManipulationAttributes>(new Error_NotImplemented(new System.Diagnostics.StackTrace(true))); } if (colDefinition.CollectionType == CollectionType.Set) valueList.UnionWith(valueList); manipulationAttributes.UndefinedAttributes.Add(UndefAttrName, valueList); var undefAttr = new UndefinedAttributeDefinition() { AttributeName = UndefAttrName, AttributeValue = valueList }; var undefAttrAssign = new AttributeAssignOrUpdateUndefined((aAttributeAssign as AttributeAssignOrUpdateList).AttributeIDChain, undefAttr); manipulationAttributes.AttributeToUpdateOrAssign.Add(undefAttrAssign); #endregion } else if (aAttributeAssign is AttributeAssignOrUpdateValue) { #region AttributeAssignValue var value = GraphDBTypeMapper.GetBaseObjectFromCSharpType((aAttributeAssign as AttributeAssignOrUpdateValue).Value); manipulationAttributes.UndefinedAttributes.Add(UndefAttrName, value); var undefAttr = new UndefinedAttributeDefinition() { AttributeName = UndefAttrName, AttributeValue = value }; var undefAttrAssign = new AttributeAssignOrUpdateUndefined((aAttributeAssign as AttributeAssignOrUpdateValue).AttributeIDChain, undefAttr); manipulationAttributes.AttributeToUpdateOrAssign.Add(undefAttrAssign); #endregion } else if (aAttributeAssign is AttributeAssignOrUpdateSetRef) { return new Exceptional<ManipulationAttributes>(new Error_InvalidReferenceAssignmentOfUndefAttr()); } else { return new Exceptional<ManipulationAttributes>(new Error_InvalidUndefinedAttributeName()); } continue; } #endregion attr = aAttributeAssign.AttributeIDChain.LastAttribute; manipulationAttributes.AttributeToUpdateOrAssign.Add(aAttributeAssign); #region checks if (aAttributeAssign.AttributeIDChain.LastType != myGraphDBType) { return new Exceptional<ManipulationAttributes>(new Error_InvalidAttribute(aAttributeAssign.AttributeIDChain.ToString())); } if (attr.GetDBType(myDBContext.DBTypeManager).IsBackwardEdge) { return new Exceptional<ManipulationAttributes>(new Error_Logic("Adding values to BackwardEdges Attributes are not allowed! (" + attr.Name + ") is an BackwardEdge Attribute of GraphType \"" + myGraphDBType.Name + "\".")); } #endregion #region SpecialTypeAttribute if (attr is ASpecialTypeAttribute) { if (!(aAttributeAssign is AttributeAssignOrUpdateValue)) { return new Exceptional<ManipulationAttributes>(new Error_InvalidAttributeValue((attr as ASpecialTypeAttribute).Name, aAttributeAssign.ToString())); } manipulationAttributes.SpecialTypeAttributes.Add((attr as ASpecialTypeAttribute), (aAttributeAssign as AttributeAssignOrUpdateValue).Value); continue; } #endregion #region check & add if (aAttributeAssign.AttributeIDChain.Edges.Count > 1) { //in case of those statements: INSERT INTO Flower VALUES (Colors.Name = 'red') //Colors.Name is an IDNode with 2 Edges. This is not possible. return new Exceptional<ManipulationAttributes>(new Error_Logic("Invalid attribute assignment : " + aAttributeAssign.AttributeIDChain.ToString() + " = " + aAttributeAssign)); } if (aAttributeAssign is AttributeAssignOrUpdateList) { #region SetOfDBObjects #region Check, whether this is valid for SetOfDBObjects if (attr.KindOfType != KindsOfType.SetOfReferences) { if (attr.KindOfType != KindsOfType.ListOfNoneReferences) { if (attr.KindOfType != KindsOfType.SetOfNoneReferences) { return new Exceptional<ManipulationAttributes>(new Error_ReferenceAssignmentExpected(attr));//"Please use SETREF keyword instead of REF/REFERENCE or LISTOF.")); } } } #endregion #region list stuff #region process tuple #region process as list var collectionDefinition = ((AttributeAssignOrUpdateList)aAttributeAssign).CollectionDefinition; var dbType = attr.GetDBType(myDBContext.DBTypeManager); if (dbType.IsUserDefined) { #region List of references var uuids = collectionDefinition.GetEdge(attr, dbType, myDBContext); if (uuids.Failed()) { return new Exceptional<ManipulationAttributes>(uuids); } manipulationAttributes.Attributes.Add(new TypeAndAttributeDefinition(attr, dbType), uuids.Value); if (typeMandatoryAttribs.Contains(attr.UUID)) { manipulationAttributes.MandatoryAttributes.Add(attr.UUID); } #endregion } else { #region List of ADBBaseObjects (Integer, String, etc) var edge = (aAttributeAssign as AttributeAssignOrUpdateList).GetBasicList(myDBContext); if (edge.Failed()) { return new Exceptional<ManipulationAttributes>(edge); } // If the collection was declared as a SETOF insert if (collectionDefinition.CollectionType == CollectionType.Set) edge.Value.Distinction(); manipulationAttributes.Attributes.Add(new TypeAndAttributeDefinition(attr, attr.GetDBType(myDBContext.DBTypeManager)), edge.Value); if (typeMandatoryAttribs.Contains(attr.UUID)) { manipulationAttributes.MandatoryAttributes.Add(attr.UUID); } #endregion } #endregion #endregion #endregion #endregion } else if (aAttributeAssign is AttributeAssignOrUpdateSetRef) { #region reference var aSetRefNode = ((AttributeAssignOrUpdateSetRef)aAttributeAssign).SetRefDefinition; var singleedge = aSetRefNode.GetEdge(attr, myDBContext, attr.GetRelatedType(myDBContext.DBTypeManager)); if (singleedge.Failed()) { return new Exceptional<ManipulationAttributes>(singleedge); } if (attr.GetRelatedType(myDBContext.DBTypeManager).IsUserDefined) { //a list which carries elements of userdefined types consists of GUIDS manipulationAttributes.Attributes.Add(new TypeAndAttributeDefinition(attr, attr.GetDBType(myDBContext.DBTypeManager)), singleedge.Value); if (typeMandatoryAttribs.Contains(attr.UUID)) { manipulationAttributes.MandatoryAttributes.Add(attr.UUID); } } else { return new Exceptional<ManipulationAttributes>(new Error_UnknownDBError("Reference types cannot be basic types.")); } #endregion } else if (aAttributeAssign is AttributeAssignOrUpdateExpression) { #region Expression (aAttributeAssign as AttributeAssignOrUpdateExpression).BinaryExpressionDefinition.Validate(myDBContext); var value = (aAttributeAssign as AttributeAssignOrUpdateExpression).BinaryExpressionDefinition.ResultValue; if (value.Failed()) { return new Exceptional<ManipulationAttributes>(value.IErrors.First()); } if (value.Value is ValueDefinition) { #region AtomValue if (attr.KindOfType == KindsOfType.SetOfReferences || attr.KindOfType == KindsOfType.ListOfNoneReferences || attr.KindOfType == KindsOfType.SetOfNoneReferences) return new Exceptional<ManipulationAttributes>(new Error_InvalidTuple(aAttributeAssign.ToString())); if (!(value.Value as ValueDefinition).IsDefined) { (value.Value as ValueDefinition).ChangeType(attr.GetDBType(myDBContext.DBTypeManager).UUID); } var val = (value.Value as ValueDefinition).Value.Value; correspondingCSharpType = GraphDBTypeMapper.ConvertGraph2CSharp(attr, attr.GetDBType(myDBContext.DBTypeManager)); if (GraphDBTypeMapper.GetEmptyGraphObjectFromType(correspondingCSharpType).IsValidValue(val)) { typedAttributeValue = GraphDBTypeMapper.GetGraphObjectFromType(correspondingCSharpType, val); manipulationAttributes.Attributes.Add(new TypeAndAttributeDefinition(attr, attr.GetDBType(myDBContext.DBTypeManager)), typedAttributeValue); if (typeMandatoryAttribs.Contains(attr.UUID)) manipulationAttributes.MandatoryAttributes.Add(attr.UUID); } else { return new Exceptional<ManipulationAttributes>(new Error_InvalidAttributeValue(attr.Name, (aAttributeAssign as AttributeAssignOrUpdateValue).Value)); } #endregion } else // TupleValue! { #region TupleValue if (attr.KindOfType != KindsOfType.SetOfReferences) return new Exceptional<ManipulationAttributes>(new Error_InvalidTuple(aAttributeAssign.ToString())); if (!(attr.EdgeType is IBaseEdge)) return new Exceptional<ManipulationAttributes>(new Error_InvalidEdgeType(attr.EdgeType.GetType(), typeof(IBaseEdge))); correspondingCSharpType = GraphDBTypeMapper.ConvertGraph2CSharp(attr, attr.GetDBType(myDBContext.DBTypeManager)); if ((value.Value as TupleDefinition).TypeOfOperatorResult != correspondingCSharpType) return new Exceptional<ManipulationAttributes>(new Error_DataTypeDoesNotMatch(correspondingCSharpType.ToString(), (value.Value as TupleDefinition).TypeOfOperatorResult.ToString())); var edge = attr.EdgeType.GetNewInstance() as IBaseEdge; edge.AddRange((value.Value as TupleDefinition).Select(te => (te.Value as ValueDefinition).Value)); manipulationAttributes.Attributes.Add(new TypeAndAttributeDefinition(attr, attr.GetDBType(myDBContext.DBTypeManager)), edge as IBaseEdge); #endregion } #endregion } else if (aAttributeAssign is AttributeAssignOrUpdateValue) { #region Simple value var attrVal = aAttributeAssign as AttributeAssignOrUpdateValue; if (attr.KindOfType == KindsOfType.ListOfNoneReferences) return new Exceptional<ManipulationAttributes>(new Error_InvalidTuple(attrVal.ToString())); if (attr.KindOfType != KindsOfType.SingleNoneReference) { return new Exceptional<ManipulationAttributes>(new Error_InvalidAttributeKind(attr.KindOfType, KindsOfType.SingleNoneReference)); } correspondingCSharpType = GraphDBTypeMapper.ConvertGraph2CSharp(attr, attr.GetDBType(myDBContext.DBTypeManager)); if (GraphDBTypeMapper.GetEmptyGraphObjectFromType(correspondingCSharpType).IsValidValue(attrVal.Value)) { typedAttributeValue = GraphDBTypeMapper.GetGraphObjectFromType(correspondingCSharpType, attrVal.Value); manipulationAttributes.Attributes.Add(new TypeAndAttributeDefinition(attr, attr.GetDBType(myDBContext.DBTypeManager)), typedAttributeValue); if (typeMandatoryAttribs.Contains(attr.UUID)) manipulationAttributes.MandatoryAttributes.Add(attr.UUID); } else { return new Exceptional<ManipulationAttributes>(new Error_InvalidAttributeValue(attr.Name, attrVal.Value)); } #endregion } else { return new Exceptional<ManipulationAttributes>(new Error_NotImplemented(new System.Diagnostics.StackTrace(true))); } #endregion } #endregion #endregion resultExcept.Value = manipulationAttributes; return resultExcept; } /// <summary> /// Inserts into all indices that are affected if a DBObject is updated on a certain attibute /// </summary> /// <param name="dBObjectStream"></param> /// <param name="attributeUUID"></param> /// <param name="_dbContext"></param> /// <returns></returns> private Exceptional InsertDBObjectIntoIndex(DBObjectStream dBObjectStream, AttributeUUID attributeUUID) { foreach (var aType in _dbContext.DBTypeManager.GetAllParentTypes(_dbContext.DBTypeManager.GetTypeByUUID(dBObjectStream.TypeUUID), true, false)) { foreach (var aAttributeIdx in aType.GetAttributeIndices(_dbContext, attributeUUID)) { var result = aAttributeIdx.Insert(dBObjectStream, aType, _dbContext); if (result.Failed()) { return new Exceptional(result); } } } return new Exceptional(); } /// <summary> /// Removes index entries corresponding to a DBObject /// </summary> /// <param name="dBObjectStream"></param> /// <param name="attributeUUID"></param> /// <param name="_dbContext"></param> /// <returns></returns> private Exceptional RemoveDBObjectFromIndex(DBObjectStream dBObjectStream, AttributeUUID attributeUUID) { foreach (var aType in _dbContext.DBTypeManager.GetAllParentTypes(_dbContext.DBTypeManager.GetTypeByUUID(dBObjectStream.TypeUUID), true, false)) { foreach (var aAttributeIdx in aType.GetAttributeIndices(_dbContext, attributeUUID)) { var result = aAttributeIdx.Remove(dBObjectStream, aType, _dbContext); if (result.Failed()) { return new Exceptional(result); } } } return new Exceptional(); } private Exceptional RemoveUndefAttrs(IEnumerable<Exceptional<DBObjectStream>> myDBObjStream, List<String> myUndefAttrs) { #region delete undefined attributes foreach (var objects in myDBObjStream) { var undefAttrsStream = myUndefAttrs.Where(item => objects.Value.GetUndefinedAttributePayload(_dbContext.DBObjectManager).Value.ContainsKey(item)); foreach (var undefAttr in undefAttrsStream) { var removeExcept = _dbContext.DBObjectManager.RemoveUndefinedAttribute(undefAttr, objects.Value); if (removeExcept.Failed()) return new Exceptional(removeExcept); } } #endregion return Exceptional.OK; } /// <summary> /// setting the default value for the attribute /// </summary> /// <param name="myAttr">the attribute</param> /// <param name="myDBObjectCache">the object cache</param> /// <returns>true if the value was changed</returns> private Exceptional<Boolean> SetDefaultValue(TypeAttribute myAttr, Exceptional<DBObjectStream> myDBO) { if (myDBO.Success()) { IObject defaultValue = myAttr.DefaultValue; if (defaultValue == null) defaultValue = myAttr.GetDefaultValue(_dbContext); var alterExcept = myDBO.Value.AlterAttribute(myAttr.UUID, defaultValue); if (alterExcept.Failed()) return new Exceptional<Boolean>(alterExcept); if (!alterExcept.Value) { return new Exceptional<bool>(false); } } else { return new Exceptional<bool>(false); } return new Exceptional<bool>(true); } /// <summary> /// This is the update method which will change some <paramref name="myDBObjects"/> on 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> private QueryResult Update(IEnumerable<Exceptional<DBObjectStream>> myDBObjects, IEnumerable<AAttributeAssignOrUpdateOrRemove> myListOfUpdates) { #region Data var queryResultContent = new List<Vertex>(); var queryResult = new QueryResult(); #endregion #region check for undefined attributes setting var undefAttrSetting = _dbContext.DBSettingsManager.GetSetting(SettingUndefAttrBehaviour.UUID, _dbContext, TypesSettingScope.DB); if (!undefAttrSetting.Success()) { return new QueryResult(undefAttrSetting); } var undefSettingVal = ((SettingUndefAttrBehaviour)undefAttrSetting.Value).Behaviour; #endregion #region Validate attributes var definedAttributeAssignments = new Dictionary<AttributeUUID, AAttributeAssignOrUpdate>(); foreach (var updateOrAssign in myListOfUpdates) { System.Diagnostics.Debug.Assert(updateOrAssign != null); if (!(updateOrAssign is AttributeRemove)) { var result = updateOrAssign.AttributeIDChain.Validate(_dbContext, true); if (result.Failed()) { return new QueryResult(result); } if (updateOrAssign.IsUndefinedAttributeAssign) { #region handle undefined attributes switch (undefSettingVal) { case UndefAttributeBehaviour.disallow: return new QueryResult(new Error_UndefinedAttributes()); case UndefAttributeBehaviour.warn: queryResult.PushIWarning(new Warning_UndefinedAttribute(updateOrAssign.AttributeIDChain)); break; } #endregion } else { //here a dictionary is used, because myListOfUpdates will be traversed many times now (maybe CachedEnumerator can be used instead) if (updateOrAssign is AAttributeAssignOrUpdate) definedAttributeAssignments[GetAttributesToCheckForUnique(updateOrAssign)] = updateOrAssign as AAttributeAssignOrUpdate; } } } #endregion #region check unique constraint if (definedAttributeAssignments.CountIsGreater(0)) { Exceptional<Boolean> CheckConstraint = null; IEnumerable<GraphDBType> parentTypes = _dbContext.DBTypeManager.GetAllParentTypes(_graphDBType, true, false); foreach (var entry in myDBObjects) { //here all attributes are listed, that will change their value var changingAttributes = (from CurrentAttribute in entry.Value.GetAttributes() join Update in definedAttributeAssignments on CurrentAttribute.Key equals Update.Key where !CurrentAttribute.Value.Equals(Update.Value.GetValueForAttribute(entry.Value, _dbContext, _graphDBType).Value) select new {Key = CurrentAttribute.Key, Value = CurrentAttribute.Value}).ToDictionary(x=>x.Key, x=>x.Value); CheckConstraint = _dbContext.DBIndexManager.CheckUniqueConstraint(_graphDBType, parentTypes, changingAttributes); 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(_dbContext, aDBO.Value, _graphDBType); 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, _dbContext.DBTypeManager); #region update Idx foreach (var _AttributeIndex in _graphDBType.GetAllAttributeIndices(_dbContext)) { if(definedAttributes.Exists(item => _AttributeIndex.IndexKeyDefinition.IndexKeyAttributeUUIDs.Contains(item.Key.Definition.UUID))) { //execute update _AttributeIndex.Update(aDBO.Value, _graphDBType, _dbContext); } } #endregion #region update dbobjects on fs var flushResult = _dbContext.DBObjectManager.FlushDBObject(aDBO.Value); if (!flushResult.Success()) { return new QueryResult(flushResult); } #endregion var resultSet = GetManipulationResultSet(aDBO, undefinedAttributes: ExtractUndefindedAttributes(attrsForResult), attributes: definedAttributes); if (!resultSet.Success()) { /* what should happen now this should not break the update */ } queryResultContent.Add(resultSet.Value); } }
internal Exceptional SetBackwardEdges(GraphDBType aType, Dictionary<AttributeUUID, IObject> userdefinedAttributes, ObjectUUID reference, DBContext dbContext) { var returnVal = new Exceptional(); #region process attributes foreach (var aUserDefinedAttribute in userdefinedAttributes) { #region Data GraphDBType typeOFAttribute = null; TypeAttribute attributesOfType = null; #endregion #region get GraphType of Attribute //attributesOfType = aType.Attributes[aUserDefinedAttribute.Key]; attributesOfType = aType.GetTypeAttributeByUUID(aUserDefinedAttribute.Key); typeOFAttribute = dbContext.DBTypeManager.GetTypeByUUID(attributesOfType.DBTypeUUID); #endregion /* The DBO independent version */ var beEdge = new EdgeKey(aType.UUID, attributesOfType.UUID); var runMT = DBConstants.RunMT; runMT = false; if (runMT) { #region The parallel version /**/ /* The parallel version */ Parallel.ForEach(((IReferenceEdge)aUserDefinedAttribute.Value).GetAllReferenceIDs(), (uuid) => { var addExcept = dbContext.DBObjectManager.AddBackwardEdge(uuid, attributesOfType.DBTypeUUID, beEdge, reference); if (!addExcept.Success()) { returnVal.PushIExceptional(addExcept); } }); if (!returnVal.Success()) { return returnVal; } /**/ #endregion } else { #region Single thread foreach (var uuid in ((IReferenceEdge)aUserDefinedAttribute.Value).GetAllReferenceIDs()) { var addExcept = dbContext.DBObjectManager.AddBackwardEdge(uuid, attributesOfType.DBTypeUUID, beEdge, reference); if (addExcept.Failed()) { return new Exceptional(addExcept); } } #endregion } } #endregion return Exceptional.OK; }
/// <summary> /// Add indices to a vertex /// <seealso cref=" AAlterTypeCommand"/> /// </summary> public override Exceptional Execute(DBContext myDBContext, GraphDBType myGraphDBType) { var retExceptional = new Exceptional(); foreach (var idxDef in _IdxDefinitionList) { var checkIdx = CheckIndexTypeReference(idxDef.IndexAttributeDefinitions, myGraphDBType); if (!checkIdx.Success()) { retExceptional.PushIExceptional(checkIdx); } else { var result = myDBContext.DBIndexManager.CreateIndex(myDBContext, myGraphDBType.Name, idxDef.IndexName, idxDef.Edition, idxDef.IndexType, idxDef.IndexAttributeDefinitions); if (!result.Success()) { retExceptional.PushIExceptional(result); } } } return retExceptional; }
public override Exceptional Execute(DBContext dbContext, GraphDBType graphDBType) { var listOfTypeAttrs = new List<TypeAttribute>(); var retExcept = new Exceptional(); foreach (var attr in _ListOfAttributes) { var typeAttr = graphDBType.GetTypeAttributeByName(attr); if (typeAttr == null) { return new Exceptional(new Error_AttributeIsNotDefined(attr)); } var attrType = dbContext.DBTypeManager.GetTypeByUUID(typeAttr.DBTypeUUID); if (attrType == null) return new Exceptional(new Error_TypeDoesNotExist("")); if (attrType.IsUserDefined) return new Exceptional(new Error_InvalidReferenceAssignmentOfUndefAttr()); listOfTypeAttrs.Add(typeAttr); } var dbobjects = dbContext.DBObjectCache.SelectDBObjectsForLevelKey(new LevelKey(graphDBType, dbContext.DBTypeManager), dbContext); foreach (var item in dbobjects) { if (!item.Success()) { retExcept.PushIExceptional(item); } else { foreach (var attr in listOfTypeAttrs) { if (item.Value.HasAttribute(attr.UUID, graphDBType)) { var attrVal = item.Value.GetAttribute(attr.UUID); var addExcept = item.Value.AddUndefinedAttribute(attr.Name, attrVal, dbContext.DBObjectManager); if (!addExcept.Success()) retExcept.PushIExceptional(addExcept); item.Value.RemoveAttribute(attr.UUID); var saveExcept = dbContext.DBObjectManager.FlushDBObject(item.Value); if (!saveExcept.Success()) retExcept.PushIExceptional(saveExcept); } } } } var indices = graphDBType.GetAllAttributeIndices(); List<AAttributeIndex> idxToDelete = new List<AAttributeIndex>(); //remove attributes from type foreach (var attr in listOfTypeAttrs) { foreach (var item in indices) { var index = item.IndexKeyDefinition.IndexKeyAttributeUUIDs.Find(idx => idx == attr.UUID); if (index != null && item.IndexKeyDefinition.IndexKeyAttributeUUIDs.Count == 1) { idxToDelete.Add(item); } } //remove indices foreach (var idx in idxToDelete) { var remExcept = graphDBType.RemoveIndex(idx.IndexName, idx.IndexEdition, dbContext.DBTypeManager); if (!remExcept.Success()) { retExcept.PushIExceptional(remExcept); } } idxToDelete.Clear(); graphDBType.RemoveAttribute(attr.UUID); var flushExcept = dbContext.DBTypeManager.FlushType(graphDBType); if (!flushExcept.Success()) { retExcept.PushIExceptional(flushExcept); } } return retExcept; }
/// <summary> /// Create the GraphDML of all DBObjects in the database. /// </summary> /// <param name="myDumpFormat"></param> /// <param name="dbContext"></param> /// <param name="objectManager"></param> /// <returns></returns> public Exceptional<List<String>> ExportGraphDML(DumpFormats myDumpFormat, DBContext dbContext, IEnumerable<GraphDBType> myTypesToDump) { //var _StringBuilder = new StringBuilder(); var queries = new List<String>(); var exceptional = new Exceptional<List<String>>(); #region Go through each type foreach (var graphDBType in myTypesToDump) { var UUIDIdx = graphDBType.GetUUIDIndex(dbContext.DBTypeManager); #region Take UUID index foreach (var aDBO in dbContext.DBObjectCache.LoadListOfDBObjectStreams(graphDBType, UUIDIdx.GetAllUUIDs(graphDBType, dbContext))) { if (!aDBO.Success()) { exceptional.PushIExceptional(aDBO); } else { var gdmlExceptional = CreateGraphDMLforDBObject(myDumpFormat, dbContext, graphDBType, aDBO.Value); if (!gdmlExceptional.Success()) { exceptional.PushIExceptional(aDBO); } else { queries.Add(gdmlExceptional.Value); } } } #endregion } #endregion //_Exceptional.Value = _StringBuilder.ToString(); exceptional.Value = queries; return exceptional; }
/// <summary> /// Validates the expression (Set the TypeOfBinaryExpression, do some simplifications and validates all IDChains /// </summary> /// <param name="myDBContext"></param> /// <param name="types">This is optional, usually you wont pass any types</param> /// <returns></returns> public Exceptional Validate(DBContext myDBContext, params GraphDBType[] types) { if (IsValidated) { return ValidateResult; } ValidateResult = new Exceptional(); Operator = myDBContext.DBPluginManager.GetBinaryOperator(_OperatorSymbol); #region Left - Valid TypesOfBinaryExpression are RightComplex (left is atom) or LeftComplex (left is complex) if (_Left is ValueDefinition) { TypeOfBinaryExpression = TypesOfBinaryExpression.RightComplex; } else if (_Left is IDChainDefinition) { ValidateResult.PushIExceptional((_Left as IDChainDefinition).Validate(myDBContext, true, types)); TypeOfBinaryExpression = TypesOfBinaryExpression.LeftComplex; } else if (_Left is TupleDefinition) { #region TupleDefinition if (IsEncapsulatedBinaryExpression(_Left as TupleDefinition)) { var exceptionalResult = TryGetBinexpression((_Left as TupleDefinition).First().Value, myDBContext); if (exceptionalResult.Failed()) { return ValidateResult.PushIExceptional(exceptionalResult); } _Left = exceptionalResult.Value; TypeOfBinaryExpression = TypesOfBinaryExpression.LeftComplex; } else { var correctTuple = AssignCorrectTuple((_Left as TupleDefinition), Operator, myDBContext); if (correctTuple.Failed()) { return new Exceptional(correctTuple); } _Left = correctTuple.Value; TypeOfBinaryExpression = TypesOfBinaryExpression.RightComplex; } #endregion } else if (_Left is AggregateDefinition) { TypeOfBinaryExpression = TypesOfBinaryExpression.LeftComplex; } else if (_Left is UnaryExpressionDefinition) { TypeOfBinaryExpression = TypesOfBinaryExpression.LeftComplex; var binExprResult = (_Left as UnaryExpressionDefinition).GetBinaryExpression(myDBContext); ValidateResult.PushIExceptional(binExprResult); _Left = binExprResult.Value; } else { #region try binexpr var exceptionalResult = TryGetBinexpression(_Left, myDBContext); if (exceptionalResult.Failed()) { return ValidateResult.PushIExceptional(exceptionalResult); } _Left = exceptionalResult.Value; TypeOfBinaryExpression = TypesOfBinaryExpression.LeftComplex; #endregion } #endregion if (ValidateResult.Failed()) { return ValidateResult; } #region Right if (_Right is ValueDefinition) { if (TypeOfBinaryExpression == TypesOfBinaryExpression.RightComplex) { TypeOfBinaryExpression = TypesOfBinaryExpression.Atom; } } else if (_Right is IDChainDefinition) { ValidateResult.PushIExceptional((_Right as IDChainDefinition).Validate(myDBContext, false, types)); if (TypeOfBinaryExpression == TypesOfBinaryExpression.LeftComplex) { TypeOfBinaryExpression = TypesOfBinaryExpression.Complex; } } else if (_Right is UnaryExpressionDefinition) { if (TypeOfBinaryExpression == TypesOfBinaryExpression.LeftComplex) { TypeOfBinaryExpression = TypesOfBinaryExpression.Complex; } var binExprResult = (_Right as UnaryExpressionDefinition).GetBinaryExpression(myDBContext); ValidateResult.PushIExceptional(binExprResult); _Right = binExprResult.Value; } else if (_Right is TupleDefinition) { #region TupleDefinition if (IsEncapsulatedBinaryExpression(_Right as TupleDefinition)) { var exceptionalResult = TryGetBinexpression((_Right as TupleDefinition).First().Value, myDBContext); if (exceptionalResult.Failed()) { return ValidateResult.PushIExceptional(exceptionalResult); } _Right = exceptionalResult.Value; if (TypeOfBinaryExpression == TypesOfBinaryExpression.LeftComplex) { TypeOfBinaryExpression = TypesOfBinaryExpression.Complex; } } else { var correctTuple = AssignCorrectTuple((_Right as TupleDefinition), Operator, myDBContext); if (correctTuple.Failed()) { return new Exceptional(correctTuple); } _Right = correctTuple.Value; if (TypeOfBinaryExpression == TypesOfBinaryExpression.RightComplex) { TypeOfBinaryExpression = TypesOfBinaryExpression.Atom; } } #endregion } else if (_Right is AggregateDefinition) { if (TypeOfBinaryExpression == TypesOfBinaryExpression.LeftComplex) { TypeOfBinaryExpression = TypesOfBinaryExpression.Complex; } } else { #region try binexpr var exceptionalResult = TryGetBinexpression(_Right, myDBContext); if (exceptionalResult.Failed()) { return ValidateResult.PushIExceptional(exceptionalResult); } _Right = exceptionalResult.Value; if (TypeOfBinaryExpression == TypesOfBinaryExpression.LeftComplex) { TypeOfBinaryExpression = TypesOfBinaryExpression.Complex; } #endregion } #endregion if (ValidateResult.Failed()) { return ValidateResult; } #region try to get values from complex expr Exceptional<AOperationDefinition> leftTemp; Exceptional<AOperationDefinition> rightTemp; switch (TypeOfBinaryExpression) { case TypesOfBinaryExpression.Atom: break; case TypesOfBinaryExpression.LeftComplex: #region leftComplex leftTemp = TryGetOperationValue(_Left); if (leftTemp != null) { if (leftTemp.Failed()) { return ValidateResult.PushIExceptional(leftTemp); } TypeOfBinaryExpression = TypesOfBinaryExpression.Atom; _Left = leftTemp.Value; } #endregion break; case TypesOfBinaryExpression.RightComplex: #region rightComplex rightTemp = TryGetOperationValue(_Right); if (rightTemp != null) { if (rightTemp.Failed()) { return ValidateResult.PushIExceptional(rightTemp); } TypeOfBinaryExpression = TypesOfBinaryExpression.Atom; _Right = rightTemp.Value; } #endregion break; case TypesOfBinaryExpression.Complex: #region complex leftTemp = TryGetOperationValue(_Left); rightTemp = TryGetOperationValue(_Right); #region Check for errors if (leftTemp != null && leftTemp.Failed()) { return ValidateResult.PushIExceptional(leftTemp); } if (rightTemp != null && rightTemp.Failed()) { return ValidateResult.PushIExceptional(rightTemp); } #endregion if ((leftTemp != null) && (rightTemp != null)) { TypeOfBinaryExpression = TypesOfBinaryExpression.Atom; _Left = leftTemp.Value; _Right = rightTemp.Value; } else { if (leftTemp != null) { TypeOfBinaryExpression = TypesOfBinaryExpression.RightComplex; _Left = leftTemp.Value; } else if (rightTemp != null) { TypeOfBinaryExpression = TypesOfBinaryExpression.LeftComplex; _Right = rightTemp.Value; } } #endregion break; } #endregion #region process values if (TypeOfBinaryExpression == TypesOfBinaryExpression.Atom) { #region atomic values if ((_Left is AOperationDefinition) && (_Right is AOperationDefinition)) { var opResult = Operator.SimpleOperation(((AOperationDefinition)_Left), ((AOperationDefinition)_Right), TypeOfBinaryExpression); if (opResult.Failed()) { return ValidateResult.PushIExceptional(opResult); } ResultValue = new Exceptional<AOperationDefinition>(opResult.Value); } #endregion } else { #region some kind of complex values if (IsCombinableAble(_Left, _Right)) { #region summarize expressions //sth like (U.Age + 1) + 1 --> U.Age + 2 SimpleCombination(ref _Left, ref _Right); #endregion } else { #region tweak expressions while (IsTweakAble(_Left, _Right)) { SimpleExpressionTweak(ref _Left, ref _Right, myDBContext); } #endregion } #endregion } #endregion return ValidateResult; }
public static Exceptional<IndexKeyDefinition> CreateFromIDChainDefinitions(IEnumerable<IDChainDefinition> myIDChainDefinitions) { var indexKeyDefinition = new IndexKeyDefinition(); var retVal = new Exceptional<IndexKeyDefinition>(indexKeyDefinition); foreach (var idChainDefinition in myIDChainDefinitions) { retVal.PushIExceptional(indexKeyDefinition.AddIDChainDefinition(idChainDefinition)); } return retVal; }
public static Exceptional<IndexKeyDefinition> CreateFromIDChainDefinition(IDChainDefinition myIDChainDefinition) { var indexKeyDefinition = new IndexKeyDefinition(); var retVal = new Exceptional<IndexKeyDefinition>(indexKeyDefinition); retVal.PushIExceptional(indexKeyDefinition.AddIDChainDefinition(myIDChainDefinition)); return retVal; }
/// <summary> /// This method adds a bunch of new GraphTypeDefinitions (comes from a CREATE TYPE(S) statement) to the TypeManager. /// If a certain PType can't be added (because of some inheritance or /// attribute errors), this method tries to add it in a second /// step. /// </summary> /// <param name="TypeList">List of GraphType definitions that should /// be added to the TypeManager</param> /// <returns>List of GraphError</returns> public Exceptional<QueryResult> AddBulkTypes(List<GraphDBTypeDefinition> TypeList, DBContext currentContext) { #region Input Exceptions if (TypeList == null) { return new Exceptional<QueryResult>(new QueryResult()); } if (TypeList.Count.Equals(0)) { return new Exceptional<QueryResult>(new QueryResult()); } #endregion #region Data var errors = new List<GraphDBError>(); List<GraphDBType> addedTypes = new List<GraphDBType>(); List<AttributeUUID> uniqueAttrIDs = new List<AttributeUUID>(); QueryResult result = new QueryResult(); #endregion try { #region Create the types without attributes foreach (GraphDBTypeDefinition aTypeDef in TypeList) { #region Input validation if (String.IsNullOrEmpty(aTypeDef.Name)) return new Exceptional<QueryResult>(new Error_ArgumentNullOrEmpty("myTypeName")); if (String.IsNullOrEmpty(aTypeDef.ParentType)) return new Exceptional<QueryResult>(new Error_ArgumentNullOrEmpty("myParentType")); if (aTypeDef.Attributes == null) return new Exceptional<QueryResult>(new Error_ArgumentNullOrEmpty("myAttributes")); #endregion GraphDBType thisType = GetTypeByName(aTypeDef.Name); #region Check if the name of the type is already used if (thisType != null) { return new Exceptional<QueryResult>(new Error_TypeAlreadyExist(aTypeDef.Name)); } #endregion GraphDBType parentType = GetTypeByName(aTypeDef.ParentType); Dictionary<AttributeUUID, TypeAttribute> attributes = new Dictionary<AttributeUUID, TypeAttribute>(); #region Add type TypeUUID parentUUID = (parentType == null) ? null : parentType.UUID; #region hack GraphDBType _NewGraphType = new GraphDBType(null, new ObjectLocation(_DatabaseRootPath), aTypeDef.Name, parentUUID, attributes, true, aTypeDef.IsAbstract, aTypeDef.Comment); #endregion addedTypes.Add(_NewGraphType); _UserDefinedTypes.Add(_NewGraphType.UUID, _NewGraphType); _TypesNameLookUpTable.Add(_NewGraphType.Name, _NewGraphType); #endregion } #endregion var backwardEdgesToBeAddedAfterwards = new Dictionary<GraphDBType, List<BackwardEdgeDefinition>>(); #region Validate the previously added types and add the attributes and backwardEdges foreach (var aTypeDef in TypeList) { GraphDBType aType = addedTypes.Where(item => item.Name == aTypeDef.Name).FirstOrDefault(); #region Check and set parent GraphDBType parentType; #region Verify base type existence if (aType.ParentTypeUUID == null) { parentType = addedTypes.Where(item => item.Name == aTypeDef.ParentType).FirstOrDefault(); if (parentType == null) { RemoveRecentlyAddedTypes(addedTypes); return new Exceptional<QueryResult>(new Error_ParentTypeDoesNotExist(aTypeDef.ParentType, aTypeDef.Name)); } aType.SetParentTypeUUID(parentType.UUID); } else { parentType = aType.GetParentType(this); } #endregion #region Verify that the type inherit DBReference var parentTypeExcept = HasParentType(parentType.UUID, DBReference.UUID); if (parentTypeExcept.Failed()) { return new Exceptional<QueryResult>(parentTypeExcept); } if (!parentTypeExcept.Value) { RemoveRecentlyAddedTypes(addedTypes); return new Exceptional<QueryResult>(new Error_InvalidBaseType(parentType.Name)); } #endregion #endregion //add TypeAttributeLookuptable to current type aType.AttributeLookupTable.AddRange(parentType.AttributeLookupTable); #region check and set type of attributes UInt16 attributeCounter = 0; foreach (var attributeDef in aTypeDef.Attributes) { var attribute = attributeDef.Key.CreateTypeAttribute(currentContext, addedTypes, attributeCounter); if (attribute.Failed()) { return new Exceptional<QueryResult>(attribute); } if (attribute.Value.Name == aType.Name) { RemoveRecentlyAddedTypes(addedTypes); return new Exceptional<QueryResult>(new Error_InvalidAttributeName("The attribute " + attribute.Value.Name + " can not be added, because it has the same name as its related type.")); } GraphDBType attrType = GetTypeByName(attributeDef.Value); if (attrType == null) { attrType = addedTypes.Where(item => item.Name == attributeDef.Value).FirstOrDefault(); if (attrType == null) { RemoveRecentlyAddedTypes(addedTypes); return new Exceptional<QueryResult>(new Error_TypeDoesNotExist(attributeDef.Value)); } } attributeCounter++; TypeAttribute newAttr = attribute.Value; newAttr.DBTypeUUID = attrType.UUID; newAttr.RelatedGraphDBTypeUUID = aType.UUID; #region we had not defined a special EdgeType - for single reference attributes we need to set the EdgeTypeSingle NOW! if (newAttr.KindOfType == KindsOfType.SingleReference && attrType.IsUserDefined && newAttr.EdgeType == null) newAttr.EdgeType = new EdgeTypeSingleReference(null, newAttr.DBTypeUUID); #endregion #region Validate EdgeType in terms of List & Single if (newAttr.KindOfType == KindsOfType.SingleReference && attrType.IsUserDefined && !(newAttr.EdgeType is ASingleReferenceEdgeType)) { RemoveRecentlyAddedTypes(addedTypes); return new Exceptional<QueryResult>(new Error_InvalidEdgeType(newAttr.EdgeType.GetType(), typeof(ASingleReferenceEdgeType))); } else if (newAttr.KindOfType == KindsOfType.SetOfReferences || newAttr.KindOfType == KindsOfType.SetOfNoneReferences) { if (attrType.IsUserDefined && !(newAttr.EdgeType is ASetOfReferencesEdgeType)) { RemoveRecentlyAddedTypes(addedTypes); return new Exceptional<QueryResult>(new Error_InvalidEdgeType(newAttr.EdgeType.GetType(), typeof(ASetOfReferencesEdgeType))); } else if (!attrType.IsUserDefined && !(newAttr.EdgeType is ASetOfBaseEdgeType)) { RemoveRecentlyAddedTypes(addedTypes); return new Exceptional<QueryResult>(new Error_InvalidEdgeType(newAttr.EdgeType.GetType(), typeof(AListOfBaseEdgeType))); } } #endregion aType.AddAttribute(newAttr, this, true); } #endregion #region Set BackwardEdges if (!aTypeDef.BackwardEdgeNodes.IsNullOrEmpty()) { backwardEdgesToBeAddedAfterwards.Add(aType, aTypeDef.BackwardEdgeNodes); } #endregion } #endregion #region Add the BackwardEdges foreach (var beDefinition in backwardEdgesToBeAddedAfterwards) { var aType = beDefinition.Key; UInt16 beAttrCounter = 0; foreach (var be in beDefinition.Value) { var bedgeAttribute = CreateBackwardEdgeAttribute(be, aType, beAttrCounter); if (!bedgeAttribute.Success()) { RemoveRecentlyAddedTypes(addedTypes); return new Exceptional<QueryResult>(bedgeAttribute); } aType.AddAttribute(bedgeAttribute.Value, this, true); beAttrCounter++; } } #endregion #region Validate Attribute dependencies var _Vertices = new List<Vertex>(); foreach (var _GraphDBType in addedTypes) { foreach (var _GraphDBType2 in GetAllParentTypes(_GraphDBType, false, true)) { var _MandatoryAttributes = _GraphDBType2.GetMandatoryAttributesUUIDs(this); var _UniqueAttributes = _GraphDBType2.GetAllUniqueAttributes(false, this); foreach (var _TypeAttribute in _GraphDBType.Attributes.Values) { if (_GraphDBType2.GetTypeAttributeByName(_TypeAttribute.Name) != null) { // Todo: Use notification here RemoveRecentlyAddedTypes(addedTypes); return new Exceptional<QueryResult>(new Error_AttributeExistsInSupertype(_TypeAttribute.Name, _GraphDBType.Name)); } #region unique and mandatory attributes if (_TypeAttribute.TypeCharacteristics.IsUnique && !_UniqueAttributes.Contains(_TypeAttribute.UUID)) { //if the attrbute has been marked unique and it is not contained in uniques of super types if (!uniqueAttrIDs.Contains(_TypeAttribute.UUID)) { uniqueAttrIDs.Add(_TypeAttribute.UUID); } } if (_TypeAttribute.TypeCharacteristics.IsMandatory && !_MandatoryAttributes.Contains(_TypeAttribute.UUID)) { _GraphDBType.AddMandatoryAttribute(_TypeAttribute.UUID, this); } #endregion } } //Add the unique attribute ids for the current type var AddUniqueAttrExcept = _GraphDBType.AddUniqueAttributes(uniqueAttrIDs, currentContext); if(AddUniqueAttrExcept.Failed()) return new Exceptional<QueryResult>(AddUniqueAttrExcept); uniqueAttrIDs.Clear(); } #endregion #region Create all default directories foreach (GraphDBType aType in addedTypes) { //verzeichnisse für andere typen bei create Types wird nicht angelegt var createDefaultDirectoriesResult = AddType_CreateDefaultDirectories(aType); if (createDefaultDirectoriesResult.Failed()) { RemoveRecentlyAddedTypes(addedTypes); return new Exceptional<QueryResult>(createDefaultDirectoriesResult); } } #endregion #region Create directories and indices foreach (GraphDBType aType in addedTypes) { #region Create indices #region Create userdefined Indices var aTypeDef = TypeList.Where(item => item.Name == aType.Name).FirstOrDefault(); if (!aTypeDef.Indices.IsNullOrEmpty()) { foreach (var index in aTypeDef.Indices) { Exceptional indexErrors = new Exceptional(); if (!index.IndexAttributeDefinitions.All(node => !indexErrors.PushIExceptional(node.IndexAttribute.Validate(currentContext, false, aType)).Failed())) { RemoveRecentlyAddedTypes(addedTypes); return new Exceptional<QueryResult>(indexErrors); } var idxName = index.IndexName; if (String.IsNullOrEmpty(index.IndexName)) { idxName = index.IndexAttributeDefinitions.Aggregate(new StringBuilder(DBConstants.IndexKeyPrefix), (stringB, elem) => { stringB.Append(String.Concat(DBConstants.IndexKeySeperator, elem.IndexAttribute.LastAttribute.Name)); return stringB; }).ToString(); } //List<AttributeUUID> indexAttrs = new List<AttributeUUID>(index.IndexAttributeDefinitions.Select(node => node.IndexAttribute.LastAttribute.UUID)); var indexAttrs = index.IndexAttributeDefinitions.Select(node => node.IndexAttribute); foreach (var item in GetAllSubtypes(aType)) { var IndexKeyDefinitionExcept = IndexKeyDefinition.CreateFromIDChainDefinitions(indexAttrs); if (IndexKeyDefinitionExcept.Failed()) { RemoveRecentlyAddedTypes(addedTypes); return IndexKeyDefinitionExcept.Convert<QueryResult>(); } var CreateIdxExcept = item.CreateAttributeIndex(currentContext, idxName, IndexKeyDefinitionExcept.Value, index.Edition, index.IndexType); if (!CreateIdxExcept.Success()) { RemoveRecentlyAddedTypes(addedTypes); return new Exceptional<QueryResult>(CreateIdxExcept); } } } } #endregion //UUID index var createIndexExcept = aType.CreateUUIDIndex(_DBContext, GetUUIDTypeAttribute().UUID, _IGraphFSSession.NumberOfSpecialDirectories); if (!createIndexExcept.Success()) { RemoveRecentlyAddedTypes(addedTypes); return new Exceptional<QueryResult>(createIndexExcept); } List<AttributeUUID> UniqueIDs = aType.GetAllUniqueAttributes(true, this); if (UniqueIDs.Count() > 0) { var idxName = _DBContext.DBIndexManager.GetUniqueIndexName(UniqueIDs, aType); // UniqueIDs.Aggregate<AttributeUUID, String>("Idx", (result, item) => result = result + "_" + aType.GetTypeAttributeByUUID(item).Name); var createIdxExcept = aType.CreateUniqueAttributeIndex(currentContext, idxName, UniqueIDs, DBConstants.UNIQUEATTRIBUTESINDEX); if (!createIdxExcept.Success()) { RemoveRecentlyAddedTypes(addedTypes); return new Exceptional<QueryResult>(createIdxExcept); } } #endregion } #endregion #region flush to fs foreach (var item in addedTypes) { var createException = CreateTypeOnFS(item); if (!createException.Success()) return new Exceptional<QueryResult>(createException); #region get system attributes from type var readOut = GetVertexForType(item); if (!readOut.Success()) return new Exceptional<QueryResult>(readOut.IErrors.First()); _Vertices.Add(readOut.Value); #endregion } result.Vertices = _Vertices; #endregion } catch (GraphDBException ee) { RemoveRecentlyAddedTypes(addedTypes); var _Exceptional = new Exceptional<QueryResult>(); foreach (var _ex in ee.GraphDBErrors) _Exceptional.PushIError(_ex); return _Exceptional; } catch (GraphDBWarningException ee) { RemoveRecentlyAddedTypes(addedTypes); return new Exceptional<QueryResult>(ee.GraphDBWarning); } catch (Exception e) //finally { //if (!succeeded) //{ addedTypes.ForEach(item => { _UserDefinedTypes.Remove(item.UUID); _TypesNameLookUpTable.Remove(item.Name); }); //} return new Exceptional<QueryResult>(new Error_UnknownDBError(e)); } return new Exceptional<QueryResult>(result); }