public override bool ValidateWorkingBase(IObject workingBase, DBTypeManager typeManager) { if (workingBase is DBTypeAttribute) { var workingTypeAttribute = (workingBase as DBTypeAttribute).GetValue(); if (workingTypeAttribute.TypeCharacteristics.IsBackwardEdge) { return true; } else if (workingTypeAttribute.GetDBType(typeManager).IsUserDefined) { return true; } else { return false; } } else { return false; } }
/// <summary> /// Writes all paths included in the HashSet. Every object is represented via a given attribute. /// /// example path between fry and morbo (attribute is "Name") /// /// output: /// Fry -> Leela -> Lrrr -> Morbo /// </summary> /// <param name="myPaths">An HashSet which contains Lists of UUIDs</param> /// <param name="myTypeManager">The type manager to load the DBObjects</param> /// <param name="myTypeAttribute">The Type Attribute</param> /// <param name="myAttribute">The Attribute which shall be used for output.</param> public static void ShowDBObjects(HashSet<List<ObjectUUID>> myPaths, DBTypeManager myTypeManager, TypeAttribute myTypeAttribute, String myAttribute, DBObjectCache myObjectCache) { var attributeUUID = myTypeAttribute.GetRelatedType(myTypeManager).GetTypeSpecificAttributeByName(myAttribute).UUID; foreach (var path in myPaths) { var pathString = new StringBuilder(); Exceptional<DBObjectStream> currentDBObject; foreach (var _ObjectUUID in path) { //load from DB currentDBObject = myObjectCache.LoadDBObjectStream(myTypeAttribute.GetRelatedType(myTypeManager), _ObjectUUID); if (currentDBObject.Failed()) { throw new NotImplementedException(); } pathString.Append(currentDBObject.Value.GetAttribute(attributeUUID) + " -> "); } ////_Logger.Info(pathString.ToString()); pathString.Remove(0, pathString.Length); } }
/// <summary> /// Writes an DBObject into log /// </summary> /// <param name="myObjectUUID">The UUID of the Object</param> /// <param name="myTypeManager">The corresponding type manager</param> /// <param name="myTypeAttribute">The type attribute</param> public static void ShowDBObject(ObjectUUID myObjectUUID, DBTypeManager myTypeManager, TypeAttribute myTypeAttribute, DBObjectCache myObjectCache) { var currentDBObject = myObjectCache.LoadDBObjectStream(myTypeAttribute.GetRelatedType(myTypeManager), myObjectUUID); if (currentDBObject.Failed()) throw new NotImplementedException(); }
public DBTypeManager(DBTypeManager dBTypeManager) { _DBContext = dBTypeManager._DBContext; _UserID = dBTypeManager._UserID; _DatabaseRootPath = dBTypeManager._DatabaseRootPath; _IGraphFSSession = dBTypeManager._IGraphFSSession; _ObjectLocationsOfAllUserDefinedDatabaseTypes = dBTypeManager._ObjectLocationsOfAllUserDefinedDatabaseTypes; _SystemTypes = dBTypeManager._SystemTypes; _BasicTypes = dBTypeManager._BasicTypes; _GUIDTypeAttribute = dBTypeManager._GUIDTypeAttribute; //TODO: As soon as we have serialized Indices we can recomment these sections #region As soon as we have serialized Indices we can recomment these sections //_UserDefinedTypes = dBTypeManager._UserDefinedTypes; //_TypesNameLookUpTable = dBTypeManager._TypesNameLookUpTable; foreach (GraphDBType ptype in _SystemTypes.Values) _TypesNameLookUpTable.Add(ptype.Name, ptype); foreach (GraphDBType ptype in _BasicTypes.Values) _TypesNameLookUpTable.Add(ptype.Name, ptype); LoadUserDefinedDatabaseTypes(false); #endregion }
public DBObjectCache(DBTypeManager myTypeManager, DBObjectManager objectManager, long myMaxElements) { _typeManager = myTypeManager; _DBObjectManager = objectManager; _cachedDBObjectStreams = new Dictionary<TypeUUID, ConcurrentDictionary<ObjectUUID, WeakReference>>(); _cachedBackwardEdges = new Dictionary<TypeUUID, ConcurrentDictionary<ObjectUUID, WeakReference>>(); _maxElements = myMaxElements; _currentElements = 0; }
public override bool ValidateWorkingBase(IObject workingBase, DBTypeManager typeManager) { if (workingBase != null) { return true; } else { return false; } }
public override bool ValidateWorkingBase(IObject workingBase, DBTypeManager typeManager) { if ((workingBase is DBTypeAttribute) && (workingBase as DBTypeAttribute).GetValue().EdgeType is EdgeTypeWeighted) { return true; } else { return false; } }
public LevelKey(IEnumerable<EdgeKey> myEdgeKey, DBTypeManager myTypeManager) { _edges = new List<EdgeKey>(); foreach (var aEdgeKey in myEdgeKey) { if (aEdgeKey.AttrUUID != null && aEdgeKey.AttrUUID != UndefinedTypeAttribute.AttributeUUID) { var attribute = aEdgeKey.GetTypeAndAttributeInformation(myTypeManager).Item2; if (attribute.GetDBType(myTypeManager).IsUserDefined || attribute.IsBackwardEdge) { _edges.Add(aEdgeKey); _level++; AddHashCodeFromSingleEdge(ref _hashcode, aEdgeKey); } else { if (_level == 0) { var newEdgeKey = new EdgeKey(aEdgeKey.TypeUUID, null); _edges.Add(newEdgeKey); AddHashCodeFromSingleEdge(ref _hashcode, newEdgeKey); break; } else { break; } } } else { if (_level == 0) { _edges.Add(aEdgeKey); AddHashCodeFromSingleEdge(ref _hashcode, aEdgeKey); break; } else { break; } } } }
public override bool ValidateWorkingBase(IObject workingBase, DBTypeManager typeManager) { if (workingBase is DBInt64) { return true; } else if ((workingBase is DBTypeAttribute) && (workingBase as DBTypeAttribute).GetValue().GetDBType(typeManager).UUID == DBInt64.UUID) { return true; } else { return false; } }
public override bool ValidateWorkingBase(IObject workingBase, DBTypeManager typeManager) { if (workingBase != null) { if ((workingBase is DBTypeAttribute) && (workingBase as DBTypeAttribute).GetValue().GetDBType(typeManager).IsUserDefined) { return false; } else { return true; } } else { return false; } }
/// <summary> /// This will create a new dbContext, based on <paramref name="dbContext"/> reusing all shared data /// </summary> /// <param name="dbContext"></param> public DBContext(DBContext dbContext) { #region Immutable objects _DBPluginManager = dbContext.DBPluginManager; _DBSettingsManager = dbContext.DBSettingsManager; _IGraphFSSession = dbContext._IGraphFSSession; #endregion _SessionSettings = new DBSessionSettings(dbContext.SessionSettings); _DBObjectManager = new ObjectManagement.DBObjectManager(this, _IGraphFSSession); // _DBIndexManager = new Indices.DBIndexManager(_IGraphFSSession, this); _DBTypeManager = new DBTypeManager(dbContext.DBTypeManager); _DBObjectCache = _DBObjectManager.GetSimpleDBObjectCache(this); }
public override bool ValidateWorkingBase(IObject workingBase, DBTypeManager typeManager) { if (workingBase != null) { if (workingBase is DBTypeAttribute) { if ((workingBase as DBTypeAttribute).GetValue().GetDBType(typeManager).IsUserDefined) { return false; } else { return true; } } } else { return false; } throw new NotImplementedException(); }
private bool IsValidDBObjectStreamForBinExpr(DBObjectStream DBObjectStream, TypeAttribute myTypeAttribute, DBTypeManager myDBTypeManager) { if (DBObjectStream.HasAttribute(myTypeAttribute.UUID, myTypeAttribute.GetRelatedType(myDBTypeManager)) || myTypeAttribute.IsBackwardEdge) { return true; } else { return false; } }
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); }
public void AddAttribute(TypeAttribute myTypeAttribute, DBTypeManager myDBTypeManager, Boolean validate) { if (validate) { HashSet<UInt16> occupiedIDs = new HashSet<UInt16>(); #region validate attributes CheckAttributeAgainstOthers(_Attributes, ref myTypeAttribute, ref occupiedIDs); #endregion #region validate superType var parentLookUpAttributes = myDBTypeManager.GetTypeByUUID(this.ParentTypeUUID).AttributeLookupTable; CheckAttributeAgainstOthers(parentLookUpAttributes, ref myTypeAttribute, ref occupiedIDs); CheckAttributeAgainstOthers(_Attributes, ref myTypeAttribute, ref occupiedIDs); #endregion #region validate subtypes var attributesOfSubtypes = GetAttributesOfSubtypes(myDBTypeManager); CheckAttributeAgainstOthers(attributesOfSubtypes, ref myTypeAttribute, ref occupiedIDs); CheckAttributeAgainstOthers(parentLookUpAttributes, ref myTypeAttribute, ref occupiedIDs); CheckAttributeAgainstOthers(_Attributes, ref myTypeAttribute, ref occupiedIDs); #endregion //now we can be shure to add the attribute _Attributes.Add(myTypeAttribute.UUID, myTypeAttribute); _TypeAttributeLookupTable.Add(myTypeAttribute.UUID, myTypeAttribute); } else { _Attributes.Add(myTypeAttribute.UUID, myTypeAttribute); _TypeAttributeLookupTable.Add(myTypeAttribute.UUID, myTypeAttribute); } }
/// <summary> /// add an mandatory attribute to type /// </summary> /// <param name="myAttrib"></param> public void AddMandatoryAttribute(AttributeUUID myAttribID, DBTypeManager myTypeManager) { List<GraphDBType> SubTypes = myTypeManager.GetAllSubtypes(this, false); foreach (var Types in SubTypes) { Types.AddMandatoryAttribute(myAttribID, myTypeManager); } _MandatoryAttributes.Add(myAttribID); }
/// <summary> /// This will validate the function to a working base. /// </summary> /// <param name="workingBase">The working base. Might be null for type independent function calls like CURRENTDATE().</param> /// <param name="typeManager"></param> /// <returns></returns> public abstract bool ValidateWorkingBase(IObject myWorkingBase, DBTypeManager myTypeManager);
public List<AttributeUUID> GetAllUniqueAttributes(Boolean includeCurrentType, DBTypeManager myTypeManager) { List<AttributeUUID> result = new List<AttributeUUID>(); foreach (var aParentType in myTypeManager.GetAllParentTypes(this, includeCurrentType, false)) { result.AddRange(aParentType._UniqueAttributes); } return result; }
public Exceptional<Boolean> ChangeMandatoryAttributes(List<string> myAttribs, DBTypeManager myTypeManager) { TypeAttribute TypeAttr = null; DropMandatoryAttributes(myTypeManager); foreach (var attribs in myAttribs) { TypeAttr = GetTypeAttributeByName(attribs); if (TypeAttr == null) { return new Exceptional<bool>(new Error_AttributeIsNotDefined(this.Name, attribs)); } else { AddMandatoryAttribute(TypeAttr.UUID, myTypeManager); foreach (var attribID in GetParentMandatoryAttr(myTypeManager)) { AddMandatoryAttribute(TypeAttr.UUID, myTypeManager); } } } var FlushExcept = myTypeManager.FlushType(this); if (FlushExcept.Failed()) return new Exceptional<Boolean>(FlushExcept); return new Exceptional<Boolean>(true); }
/// <summary> /// generate a output result /// </summary> /// <param name="mySetting">the setting</param> /// <param name="myReadOutList">list of dbreadouts</param> private Vertex GenerateResult(ADBSettingsBase mySetting, DBTypeManager typeManager) { var Setting = new Dictionary<String, Object>(); Setting.Add("Name", mySetting.Name); Setting.Add("ID", mySetting.ID); Setting.Add("Type", typeManager.GetTypeByUUID(mySetting.Type).Name); Setting.Add("Desc", mySetting.Description); Setting.Add("Default", mySetting.Default); Setting.Add("Value", mySetting.Value); return new Vertex(Setting); }
/// <summary> /// generates an output for a function /// </summary> /// <param name="myFunc">the function</param> /// <param name="myFuncName">function name</param> /// <param name="myTypeManager">type manager</param> /// <returns>a list of readouts which contains the information</returns> private Vertex GenerateOutput(ABaseFunction myFunc, String myFuncName, DBTypeManager myTypeManager) { var Func = new Dictionary<String, Object>(); Func.Add("Name", myFuncName); Func.Add("Description", myFunc.GetDescribeOutput()); #region Add function parameters var parameters = new Dictionary<String, Object>(); foreach (var param in myFunc.GetParameters()) { if (param.VariableNumOfParams) { GraphDBType[] myArray = { myTypeManager.GetTypeByName(param.DBType.ObjectName) }; parameters.Add(param.Name, myArray); } else { parameters.Add(param.Name, myTypeManager.GetTypeByName(param.DBType.ObjectName)); } } Func.Add("Parameters", new Edge(null, new Vertex(parameters))); #endregion return new Vertex(Func); }
public Exceptional<Boolean> DropMandatoryAttributes(DBTypeManager myTypeManager) { List<GraphDBType> SubTypes = myTypeManager.GetAllSubtypes(this, false); if (GetMandatoryAttributesUUIDs(myTypeManager) != null) { foreach (var type in SubTypes) { foreach (var attrib in _MandatoryAttributes) { if (type._MandatoryAttributes.Contains(attrib)) type._MandatoryAttributes.Remove(attrib); } } _MandatoryAttributes.Clear(); var FlushExcept = myTypeManager.FlushType(this); if (FlushExcept.Failed()) return new Exceptional<Boolean>(FlushExcept); } return new Exceptional<Boolean>(true); }
private LevelKey CreateLevelKey(IDChainDefinition myIDChainDefinition, DBTypeManager myTypeManager) { if (myIDChainDefinition.Level == 0) { return new LevelKey(new List<EdgeKey>() { new EdgeKey(myIDChainDefinition.Edges[0].TypeUUID, null) }, myTypeManager); } else { if (myIDChainDefinition.Last() is ChainPartFuncDefinition) { // the funtion in the last idnode part processes the last attribute if (myIDChainDefinition.Level == 1) { return new LevelKey(new List<EdgeKey>() { new EdgeKey(myIDChainDefinition.Edges[0].TypeUUID, null) }, myTypeManager); } else { return new LevelKey(myIDChainDefinition.Edges.Take(myIDChainDefinition.Level - 1), myTypeManager); } } else { return new LevelKey(myIDChainDefinition.Edges.Take(myIDChainDefinition.Level), myTypeManager); } } }
/// <summary> /// Get the return type of this methods. Default is null - neither attribute nor function is valid on this methods. /// </summary> /// <param name="myWorkingBase"></param> /// <param name="myTypeManager"></param> /// <returns></returns> public virtual IObject GetReturnType(IObject myWorkingBase, DBTypeManager myTypeManager) { return null; }
private IEnumerable<Exceptional<DBObjectStream>> GetReferenceObjects(DBObjectStream myStartingDBObject, TypeAttribute interestingAttributeEdge, GraphDBType myStartingDBObjectType, DBTypeManager myDBTypeManager) { if (interestingAttributeEdge.GetDBType(myDBTypeManager).IsUserDefined || interestingAttributeEdge.IsBackwardEdge) { switch (interestingAttributeEdge.KindOfType) { case KindsOfType.SingleReference: yield return LoadDBObjectStream(interestingAttributeEdge.GetDBType(myDBTypeManager), ((ASingleReferenceEdgeType)myStartingDBObject.GetAttribute(interestingAttributeEdge.UUID)).GetUUID()); break; case KindsOfType.SetOfReferences: if (interestingAttributeEdge.IsBackwardEdge) { //get backwardEdge var beStream = LoadDBBackwardEdgeStream(myStartingDBObjectType, myStartingDBObject.ObjectUUID); if (beStream.Failed()) { throw new GraphDBException(new Error_ExpressionGraphInternal(null, String.Format("Error while trying to get BackwardEdge of the DBObject: \"{0}\"", myStartingDBObject.ToString()))); } if (beStream.Value.ContainsBackwardEdge(interestingAttributeEdge.BackwardEdgeDefinition)) { foreach (var aBackwardEdgeObject in LoadListOfDBObjectStreams(interestingAttributeEdge.BackwardEdgeDefinition.TypeUUID, beStream.Value.GetBackwardEdgeUUIDs(interestingAttributeEdge.BackwardEdgeDefinition))) { yield return aBackwardEdgeObject; } } } else { foreach (var aDBOStream in LoadListOfDBObjectStreams(interestingAttributeEdge.GetDBType(myDBTypeManager), ((ASetOfReferencesEdgeType)myStartingDBObject.GetAttribute(interestingAttributeEdge.UUID)).GetAllReferenceIDs())) { yield return aDBOStream; } } break; case KindsOfType.SetOfNoneReferences: case KindsOfType.ListOfNoneReferences: default: throw new GraphDBException(new Error_ExpressionGraphInternal(new System.Diagnostics.StackTrace(true), String.Format("The attribute \"{0}\" has an invalid KindOfType \"{1}\"!", interestingAttributeEdge.Name, interestingAttributeEdge.KindOfType.ToString()))); } } else { throw new GraphDBException(new Error_ExpressionGraphInternal(new System.Diagnostics.StackTrace(true), String.Format("The attribute \"{0}\" is no reference attribute.", interestingAttributeEdge.Name))); } yield break; }
public Exceptional<ResultType> DropUniqueAttributes(DBTypeManager myTypeManager) { #region Remove old unique index and attributes var mayBeUniqueIdx = FindUniqueIndex(); if (mayBeUniqueIdx != null) { var RemoveIdxExcept = RemoveIndex(mayBeUniqueIdx.IndexName, mayBeUniqueIdx.IndexEdition, myTypeManager); if (RemoveIdxExcept.Failed()) { return new Exceptional<ResultType>(RemoveIdxExcept); } foreach (var attrUUID in mayBeUniqueIdx.IndexKeyDefinition.IndexKeyAttributeUUIDs) { foreach (var type in myTypeManager.GetAllSubtypes(this, false)) { var RemoveUniqueExcept = type.RemoveUniqueAttribute(attrUUID, myTypeManager); if (RemoveUniqueExcept.Failed()) return new Exceptional<ResultType>(RemoveUniqueExcept); } } _UniqueAttributes.Clear(); } #endregion var FlushExcept = myTypeManager.FlushType(this); if (FlushExcept.Failed()) return new Exceptional<ResultType>(FlushExcept); return new Exceptional<ResultType>(ResultType.Successful); }
/// <summary> /// Removes an attribute of the given type. /// </summary> /// <param name="targetClass">The target type.</param> /// <param name="myAttributeName">The attribute name, referencing the deprecated attribute.</param> /// <returns>True, if the attribute was successfully removed. Else, false.(it didnt exist)</returns> public Exceptional<ResultType> RemoveAttributeFromType(String targetClass, String attributeName, DBTypeManager myTypeManager) { #region INPUT EXCEPTIONS if (String.IsNullOrEmpty(targetClass)) return new Exceptional<ResultType>(new Error_ArgumentNullOrEmpty(targetClass)); if (String.IsNullOrEmpty(attributeName)) return new Exceptional<ResultType>(new Error_ArgumentNullOrEmpty(attributeName)); #endregion #region Data GraphDBType aType = GetTypeByName(targetClass); #endregion #region check if type exists if (aType == null) return new Exceptional<ResultType>(new Error_TypeDoesNotExist(targetClass)); #endregion TypeAttribute Attribute = aType.GetTypeAttributeByName(attributeName); Exceptional<ResultType> retVal = null; if (Attribute != null) { //Check for other attributes that reference this one (i.e. as BackwardEdge) var referncedBy = GetBackwardReferencesForAttribute(Attribute); if (referncedBy.Count > 0) { return new Exceptional<ResultType>(new Error_DropOfAttributeNotAllowed(Attribute.GetRelatedType(this).Name, attributeName, referncedBy.ToDictionary(key => key, value => value.GetRelatedType(this)))); } if (Attribute.GetRelatedType(this) != aType) { return new Exceptional<ResultType>(new Error_DropOfDerivedAttributeIsNotAllowed(Attribute.GetRelatedType(this).Name, attributeName)); } retVal = RemoveAttributeOfType(aType, Attribute.UUID); } else { retVal = new Exceptional<ResultType>(new Error_AttributeIsNotDefined(attributeName)); } return retVal; }
private LevelKey GetBackwardLevelKey(LevelKey mylevelKey, EdgeKey edgeKey, DBTypeManager myTypeManager) { if (mylevelKey.Level == 1) { return new LevelKey(new List<EdgeKey> { edgeKey }, myTypeManager); } else { List<EdgeKey> newEdges = new List<EdgeKey>(); newEdges.AddRange(mylevelKey.Edges.Take(mylevelKey.Level - 2)); newEdges.Add(edgeKey); return new LevelKey(newEdges, myTypeManager); } throw new NotImplementedException(); }
/// <summary> /// The constructor. /// </summary> /// <param name="myIGraphDBSession">The filesystem where the information is stored.</param> /// <param name="DatabaseRootPath">The database root path.</param> public DBContext(IGraphFSSession graphFSSession, ObjectLocation myDatabaseRootPath, EntityUUID myUserID, Dictionary<String, ADBSettingsBase> myDBSettings, Boolean myRebuildIndices, DBPluginManager myDBPluginManager, DBSessionSettings sessionSettings = null) { _DBPluginManager = myDBPluginManager; _DBTypeManager = new TypeManagement.DBTypeManager(graphFSSession, myDatabaseRootPath, myUserID, myDBSettings, this); _DBSettingsManager = new DBSettingsManager(_DBPluginManager.Settings, myDBSettings, graphFSSession, new ObjectLocation(myDatabaseRootPath.Name, DBConstants.DBSettingsLocation)); _DBObjectManager = new DBObjectManager(this, graphFSSession); _DBIndexManager = new DBIndexManager(graphFSSession, this); _SessionSettings = sessionSettings; _DBObjectCache = _DBObjectManager.GetSimpleDBObjectCache(this); _IGraphFSSession = graphFSSession; //init types var initExcept = _DBTypeManager.Init(graphFSSession, myDatabaseRootPath, myRebuildIndices); if (initExcept.Failed()) { throw new GraphDBException(initExcept.IErrors); } }
private LevelKey GetForwardLevelKey(LevelKey mylevelKey, EdgeKey edgeKey, DBTypeManager myTypeManager) { if (mylevelKey.Level == 0) { return new LevelKey(new List<EdgeKey> { edgeKey }, myTypeManager); } else { List<EdgeKey> newEdges = new List<EdgeKey>(); newEdges.AddRange(mylevelKey.Edges); newEdges.Add(edgeKey); return new LevelKey(newEdges, myTypeManager); } }