protected Exceptional RemoveBackwardEdges(TypeUUID myTypeUUID, Dictionary<AttributeUUID, object> myUserdefinedAttributes, ObjectUUID myObjectUUIDReference, DBContext myDBContext) { #region get type that carries the attributes var aType = myDBContext.DBTypeManager.GetTypeByUUID(myTypeUUID); #endregion #region process attributes foreach (var aUserDefinedAttribute in myUserdefinedAttributes) { #region Data GraphDBType typeOFAttribute = null; TypeAttribute attributesOfType = null; #endregion #region get GraphType of Attribute attributesOfType = aType.Attributes[aUserDefinedAttribute.Key]; typeOFAttribute = myDBContext.DBTypeManager.GetTypeByUUID(attributesOfType.DBTypeUUID); #endregion IEnumerable<Exceptional<DBObjectStream>> listOfObjects; if (aUserDefinedAttribute.Value is IReferenceEdge) { listOfObjects = ((IReferenceEdge)aUserDefinedAttribute.Value).GetAllEdgeDestinations(myDBContext.DBObjectCache); } else { listOfObjects = myDBContext.DBObjectCache.LoadListOfDBObjectStreams(typeOFAttribute, (HashSet<ObjectUUID>)aUserDefinedAttribute.Value); } foreach (var aDBObject in listOfObjects) { if (aDBObject.Failed()) { return new Exceptional(aDBObject); } var removeExcept = myDBContext.DBObjectManager.RemoveBackwardEdge(aDBObject.Value, myTypeUUID, aUserDefinedAttribute.Key, myObjectUUIDReference); if (removeExcept.Failed()) { return new Exceptional(removeExcept); } } } #endregion return Exceptional.OK; }
public override void Add(ObjectUUID myValue, TypeUUID typeOfDBObjects, params ADBBaseObject[] myParameters) { if (!_ObjectUUIDs.ContainsKey(myValue)) { _ObjectUUIDs.Add(myValue, new Reference(myValue, typeOfDBObjects)); } }
public EdgeTypeSingleReference(ObjectUUID dbos, TypeUUID myTypeOfDBObject) { Debug.Assert(myTypeOfDBObject != null); if (dbos != null) { _ObjectUUID = new Tuple<ObjectUUID, Reference>(dbos, new Reference(dbos, myTypeOfDBObject)); } }
public ADBSettingsBase(String myName, String myDescription, EntityUUID myOwnerID, TypeUUID myType, ADBBaseObject myDefault, ADBBaseObject myValue) { Name = myName; Description = myDescription; OwnerID = myOwnerID; Type = myType; Default = myDefault; _Value = myValue; }
public EdgeTypeSetOfReferences(IEnumerable<ObjectUUID> dbos, TypeUUID typeOfDBObjects) { Debug.Assert(typeOfDBObjects != null); _ObjectUUIDs = new Dictionary<ObjectUUID, Reference>(); if (dbos != null) { foreach (var aUUID in dbos) { _ObjectUUIDs.Add(aUUID, new Reference(aUUID, typeOfDBObjects)); } } }
/// <summary> /// Loads a DBObject from internal cache structure or GraphFS (if it is not present in cache) /// </summary> /// <param name="myType">The type of the DBObject as TypeUUID.</param> /// <param name="myObjectUUID">The UUID of the DBObject.</param> /// <returns>A DBObject.</returns> public Exceptional<DBObjectStream> LoadDBObjectStream(TypeUUID myType, ObjectUUID myObjectUUID) { return LoadDBObjectStream(_typeManager.GetTypeByUUID(myType), myObjectUUID); }
public override void Add(ObjectUUID myValue, TypeUUID typeOfDBObjects, params ADBBaseObject[] myParameters) { if (!_ObjectUUIDs.ContainsKey(myValue)) { var aReference = new Reference(myValue, typeOfDBObjects); _estimatedSize += aReference.GetEstimatedSize() + EstimatedSizeConstants.CalcUUIDSize(myValue); _ObjectUUIDs.Add(myValue, aReference); } }
public override IReferenceEdge GetNewInstance(IEnumerable<ObjectUUID> iEnumerable, TypeUUID typeOfObjects) { return new EdgeTypeSetOfReferences(iEnumerable, typeOfObjects); }
/// <summary> /// Adds the typeNode as an asterisk *, rhomb # or minus - or ad /// </summary> /// <param name="typeNode"></param> public Exceptional AddSelectionType(String myReference, GraphDBType myType, TypesOfSelect mySelType, TypeUUID myTypeID = null) { var selElem = new SelectionElement(mySelType, myTypeID); if (!_Selections.ContainsKey(myReference)) _Selections.Add(myReference, new Dictionary<EdgeList, List<SelectionElement>>()); var level = new EdgeList(new EdgeKey(myType.UUID, null)); if (!_Selections[myReference].ContainsKey(level)) _Selections[myReference].Add(level, new List<SelectionElement>()); if (!_Selections[myReference][level].Exists(item => item.Selection == mySelType)) { _Selections[myReference][level].Add(selElem); } return Exceptional.OK; }
private object Deserialize(ref SerializationReader mySerializationReader, ADBSettingsBase myValue) { #region Read Basics try { if (myValue != null) { myValue.Name = mySerializationReader.ReadString(); myValue.Description = mySerializationReader.ReadString(); myValue.OwnerID = (EntityUUID)mySerializationReader.ReadObject(); myValue.Type = new TypeUUID(mySerializationReader.ReadByteArray()); myValue.Default.SetValue(mySerializationReader.ReadObject()); myValue._Value.SetValue(mySerializationReader.ReadObject()); } else { Name = mySerializationReader.ReadString(); Description = mySerializationReader.ReadString(); OwnerID = (EntityUUID)mySerializationReader.ReadObject(); Type = new TypeUUID(mySerializationReader.ReadByteArray()); Default.SetValue(mySerializationReader.ReadObject()); _Value.SetValue(mySerializationReader.ReadObject()); } } catch (Exception e) { throw new GraphFSException_EntityCouldNotBeDeserialized("ADBSetting could not be deserialized!\n\n" + e); } #endregion return myValue; }
public GraphDBType GetTypeByUUID(TypeUUID myUUID) { #region Input Validation if (myUUID == null) throw new ArgumentNullException("The parameter myTypeName must not be null!"); #endregion if (_SystemTypes.ContainsKey(myUUID)) { return _SystemTypes[myUUID]; } else { if (_BasicTypes.ContainsKey(myUUID)) { return _BasicTypes[myUUID]; } else { if (_UserDefinedTypes.ContainsKey(myUUID)) { return _UserDefinedTypes[myUUID]; } } } return null; }
/// <summary> /// Internal method for loading a DBObject from GraphFS. /// </summary> /// <param name="myType">The Type of the DBObjects as TypeUUID.</param> /// <param name="myObjectUUID">The UUID of the DBObject.</param> /// <returns>An DBObject</returns> private Exceptional<DBObjectStream> LoadDBObjectInternal(TypeUUID myType, ObjectUUID myObjectUUID) { return LoadDBObjectInternal(_typeManager.GetTypeByUUID(myType), myObjectUUID); }
/// <summary> /// Adds a set of ObjectUUID with parameters /// </summary> /// <param name="hashSet"></param> /// <param name="myParameters"></param> public abstract void AddRange(IEnumerable<ObjectUUID> hashSet, TypeUUID typeOfObjects, params ADBBaseObject[] myParameters);
/// <summary> /// Sets the given setting for a given type within this session /// </summary> /// <param name="setting">The setting to be set</param> /// <param name="typeUUID">The name of the type</param> /// <returns>True for success</returns> public Exceptional SetTypeSetting(ADBSettingsBase setting, TypeUUID typeUUID) { lock (_SessionSettingsType) { if (_SessionSettingsType.ContainsKey(typeUUID)) { if (_SessionSettingsType[typeUUID].ContainsKey(setting.Name)) { _SessionSettingsType[typeUUID][setting.Name] = setting; } else { _SessionSettingsType[typeUUID].Add(setting.Name, setting); } } else { _SessionSettingsType.Add(typeUUID, new Dictionary<string, ADBSettingsBase>()); _SessionSettingsType[typeUUID].Add(setting.Name, setting); } } return Exceptional.OK; }
internal Exceptional AddBackwardEdge(ObjectUUID uuid, TypeUUID typeOfBESource, EdgeKey beEdgeKey, ObjectUUID reference) { //load the backward edge var loadExcept = _DBContext.DBObjectCache.LoadDBBackwardEdgeStream(typeOfBESource, uuid); // LoadBackwardEdge(beLocation); if (loadExcept.Failed()) { return new Exceptional(loadExcept); } loadExcept.Value.AddBackwardEdge(beEdgeKey, reference, this); if (loadExcept.Value.isNew) { return _IGraphFSSession.StoreFSObject(loadExcept.Value, true); } else { return loadExcept.Value.Save(); } }
public override void Add(ObjectUUID myValue, TypeUUID typeOfDBObjects, params ADBBaseObject[] myParameters) { if (!myParameters.IsNullOrEmpty()) { if (weightedSet.DefaultWeight.IsValidValue(myParameters[0].Value)) { Add(new Reference(myValue, typeOfDBObjects), (DBNumber)weightedSet.DefaultWeight.Clone(myParameters[0].Value), true);//new DBNumber(myParameters[0].Value)); } else { throw new GraphDBException(new Error_DataTypeDoesNotMatch(myParameters[0].Value.GetType().Name, weightedSet.DefaultWeight.ObjectName)); } } else { Add(new Reference(myValue, typeOfDBObjects), weightedSet.DefaultWeight, true); } }
public override IReferenceEdge GetNewInstance(IEnumerable<ObjectUUID> iEnumerable, TypeUUID typeOfObjects) { var retEdge = new EdgeTypeWeighted(); foreach (var uuid in iEnumerable) { var vals = weightedSet.Get(new Reference(uuid, typeOfObjects)); ; retEdge.Add(vals.Key, vals.Value); } CalcEstimatedSize(retEdge); return retEdge; }
public override void AddRange(IEnumerable<ObjectUUID> hashSet, TypeUUID typeOfDBObjects, params ADBBaseObject[] myParameters) { if (!myParameters.IsNullOrEmpty()) { if (weightedSet.DefaultWeight.IsValidValue(myParameters[0].Value)) { weightedSet.AddRange(hashSet.Select(item => new Reference(item, typeOfDBObjects)), (DBNumber)weightedSet.DefaultWeight.Clone(myParameters[0].Value)); } else { throw new GraphDBException(new Error_DataTypeDoesNotMatch(myParameters[0].Value.GetType().Name, weightedSet.DefaultWeight.ObjectName)); } } else { weightedSet.AddRange(hashSet.Select(item => new Reference(item, typeOfDBObjects)), weightedSet.DefaultWeight); } CalcEstimatedSize(this); }
/// <summary> /// This will add all attributes of <paramref name="myDBObject"/> to the <paramref name="myAttributes"/> reference. Reference attributes will be resolved to the <paramref name="myDepth"/> /// </summary> /// <param name="myAttributes"></param> /// <param name="myType"></param> /// <param name="myDBObject"></param> /// <param name="myDepth"></param> /// <param name="myEdgeList"></param> /// <param name="myReference"></param> /// <param name="myUsingGraph"></param> /// <param name="mySelType"></param> /// <param name="myTypeID"></param> private void AddAttributesByDBO(ref Dictionary<String, Object> myAttributes, GraphDBType myType, DBObjectStream myDBObject, Int64 myDepth, EdgeList myEdgeList, String myReference, Boolean myUsingGraph, TypesOfSelect mySelType, TypeUUID myTypeID = null) { #region Get all attributes which are stored at the DBO foreach (var attr in myDBObject.GetAttributes()) { #region Check whether the attribute is still exist in the type - if not, continue var typeAttr = myType.GetTypeAttributeByUUID(attr.Key); if (typeAttr == null) { continue; } #endregion #region Only attributes of the selected myTypeID (TypesOfSelect.Ad) if (mySelType == TypesOfSelect.Ad) { if (myTypeID != typeAttr.GetDBType(_DBContext.DBTypeManager).UUID) { continue; } } #endregion if (attr.Value is ADBBaseObject) { #region Single base object if (mySelType != TypesOfSelect.Minus && mySelType != TypesOfSelect.Gt && mySelType != TypesOfSelect.Lt) { myAttributes.Add(typeAttr.Name, (attr.Value as ADBBaseObject).GetReadoutValue()); } #endregion } else if (attr.Value is IBaseEdge) { #region List of base objects if (mySelType != TypesOfSelect.Minus && mySelType != TypesOfSelect.Gt && mySelType != TypesOfSelect.Lt) { myAttributes.Add(typeAttr.Name, (attr.Value as IBaseEdge).GetReadoutValues()); } #endregion } else if (attr.Value is IReferenceEdge) { #region Reference edge if (mySelType == TypesOfSelect.Minus || mySelType == TypesOfSelect.Asterisk || mySelType == TypesOfSelect.Ad || mySelType == TypesOfSelect.Gt) { // Since we can define special depth (via setting) for attributes we need to check them now myDepth = GetDepth(-1, myDepth, myType, typeAttr); if ((myDepth > 0)) { myAttributes.Add(typeAttr.Name, ResolveAttributeValue(typeAttr, attr.Value, myDepth, myEdgeList, myDBObject, myReference, myUsingGraph)); } else { myAttributes.Add(typeAttr.Name, GetNotResolvedReferenceAttributeValue(myDBObject, typeAttr, myType, myEdgeList, myUsingGraph, _DBContext)); } } #endregion } else { throw new GraphDBException(new Error_NotImplemented(new System.Diagnostics.StackTrace(true))); } } #endregion #region Get all backwardEdge attributes if (mySelType == TypesOfSelect.Minus || mySelType == TypesOfSelect.Asterisk || mySelType == TypesOfSelect.Ad || mySelType == TypesOfSelect.Lt) { foreach (var beAttr in GetBackwardEdgeAttributes(myType)) { if (myDepth > 0) { if (mySelType == TypesOfSelect.Ad) { if (beAttr.BackwardEdgeDefinition.TypeUUID != myTypeID) { continue; } } var bes = myDBObject.GetBackwardEdges(beAttr.BackwardEdgeDefinition, _DBContext, _DBContext.DBObjectCache, beAttr.GetDBType(_DBContext.DBTypeManager)); if (bes.Failed()) throw new GraphDBException(bes.IErrors); if (bes.Value != null) // otherwise the DBO does not have any myAttributes.Add(beAttr.Name, ResolveAttributeValue(beAttr, bes.Value, myDepth, myEdgeList, myDBObject, myReference, myUsingGraph)); } else { if (mySelType == TypesOfSelect.Ad) { if (beAttr.BackwardEdgeDefinition.TypeUUID != myTypeID) { continue; } } var notResolvedBEs = GetNotResolvedBackwardEdgeReferenceAttributeValue(myDBObject, beAttr, beAttr.BackwardEdgeDefinition, myEdgeList, myUsingGraph, _DBContext); if (notResolvedBEs != null) { myAttributes.Add(beAttr.Name, notResolvedBEs); } } } } #endregion #region Get all undefined attributes from DBO if (mySelType == TypesOfSelect.Asterisk || mySelType == TypesOfSelect.Rhomb) { var undefAttrException = myDBObject.GetUndefinedAttributes(_DBContext.DBObjectManager); if (undefAttrException.Failed()) throw new GraphDBException(undefAttrException.IErrors); foreach (var undefAttr in undefAttrException.Value) myAttributes.Add(undefAttr.Key, undefAttr.Value.GetReadoutValue()); } #endregion #region Add special attributes if (mySelType == TypesOfSelect.Asterisk) { foreach (var specialAttr in GetSpecialAttributes(myType)) { if (!myAttributes.ContainsKey(specialAttr.Name)) { var result = (specialAttr as ASpecialTypeAttribute).ExtractValue(myDBObject, myType, _DBContext); if (result.Failed()) { throw new GraphDBException(result.IErrors); } myAttributes.Add(specialAttr.Name, result.Value.GetReadoutValue()); } } } #endregion }
/// <summary> /// Loads an Enumaration of DBObjects (if possible from internal cache structure). /// </summary> /// <param name="myTypeUUID">The Type of the DBObjects as TypeUUID.</param> /// <param name="myListOfObjectUUID">The list of ObjectsUUIDs.</param> /// <returns>An Enumeratiuon of DBObjects.</returns> public IEnumerable<Exceptional<DBObjectStream>> LoadListOfDBObjectStreams(TypeUUID myTypeUUID, IEnumerable<ObjectUUID> myListOfObjectUUID) { return LoadListOfDBObjectStreams(_typeManager.GetTypeByUUID(myTypeUUID), myListOfObjectUUID); }
/// <summary> /// Internal method for loading a DBBackwardEdge from GraphFS. /// </summary> /// <param name="myType">The Type of the DBObjects as TypeUUID.</param> /// <param name="myObjectUUID">The UUID of the corresponding DBObject.</param> /// <returns>A BackwardEdge</returns> private Exceptional<BackwardEdgeStream> LoadDBBackwardEdgeInternal(TypeUUID myType, ObjectUUID myObjectUUID) { return LoadDBBackwardEdgeInternal(_typeManager.GetTypeByUUID(myType), myObjectUUID); }
public abstract IReferenceEdge GetNewInstance(IEnumerable<ObjectUUID> iEnumerable, TypeUUID typeOfObjects);
/// <summary> /// Returns true, if the type with myClassName baseTypeName is "a" base type to the type with /// myClassName superTypeName. /// </summary> /// <param name="derivedTypeName">The name of the derived class.</param> /// <param name="superTypeName">The name of the super class.</param> /// <returns>True, if the super class is a supertype to derived type.</returns> public Exceptional<Boolean> HasParentType(TypeUUID derivedTypeUUID, TypeUUID superTypeUUID) { #region INPUT EXCEPTIONS if (derivedTypeUUID == null) return new Exceptional<bool>(new Error_ArgumentNullOrEmpty("UUID of derived type should not be null.")); if (superTypeUUID == null) return new Exceptional<bool>(new Error_ArgumentNullOrEmpty("UUID of super type should not be null.")); if (GetTypeByUUID(derivedTypeUUID) == null) return new Exceptional<bool>(new Error_TypeDoesNotExist("")); if (GetTypeByUUID(superTypeUUID) == null) return new Exceptional<bool>(new Error_TypeDoesNotExist("")); #endregion bool result = false; GraphDBType derivedType = GetTypeByUUID(derivedTypeUUID); while (derivedType.ParentTypeUUID != null && !derivedType.UUID.Equals(superTypeUUID)) { derivedType = GetTypeByUUID(derivedType.ParentTypeUUID); } if (derivedType.UUID.Equals(superTypeUUID)) result = true; return new Exceptional<Boolean>(result); }
internal Exceptional AddBackwardEdge(ObjectUUID uuid, TypeUUID typeOfBESource, EdgeKey beEdgeKey, ObjectUUID reference) { //var beLocation = DBObjectStream.GetObjectLocation(_DBContext.DBTypeManager.GetTypeByUUID(typeOfBESource), uuid); var loadExcept = _DBContext.DBObjectCache.LoadDBBackwardEdgeStream(typeOfBESource, uuid); // LoadBackwardEdge(beLocation); if (loadExcept.Failed()) { return new Exceptional(loadExcept); } //EdgeKey tempKey = new EdgeKey(typeUUID, attributeUUID); loadExcept.Value.AddBackwardEdge(beEdgeKey, reference, this); if (loadExcept.Value.isNew) { return _IGraphFSSession.StoreFSObject(loadExcept.Value, true); } else { return loadExcept.Value.Save(); } }
public void Deserialize(byte[] mySerializedData) { #region Data SerializationReader reader; reader = new SerializationReader(mySerializedData); #endregion #region Read Basics try { Name = reader.ReadString(); Description = reader.ReadString(); OwnerID = new EntityUUID(reader.ReadByteArray()); Type = new TypeUUID(reader.ReadByteArray()); Default.SetValue(reader.ReadObject()); _Value.SetValue(reader.ReadObject()); } catch (Exception e) { throw new GraphFSException_EntityCouldNotBeDeserialized("ADBSetting could not be deserialized!\n\n" + e); } #endregion }
public override void AddRange(IEnumerable<ObjectUUID> hashSet, TypeUUID typeOfDBObjects, params ADBBaseObject[] myParameters) { foreach (var aUUID in hashSet) { if (!_ObjectUUIDs.ContainsKey(aUUID)) { _ObjectUUIDs.Add(aUUID, new Reference(aUUID, typeOfDBObjects)); } } CalcEstimatedSize(this); }
/// <summary> /// Set the value with some optional parameters /// </summary> /// <param name="myValue">A ObjectUUID</param> /// <param name="myParameters">Some optional parameters</param> public abstract void Set(ObjectUUID myValue, TypeUUID typeOfObjects, params ADBBaseObject[] myParameters);
public override void Deserialize(ref Lib.NewFastSerializer.SerializationReader mySerializationReader) { FileSystemLocation = new ObjectLocation(mySerializationReader.ReadString()); IndexEdition = mySerializationReader.ReadString(); IndexName = mySerializationReader.ReadString(); _IsUUIDIndex = mySerializationReader.ReadBoolean(); IndexRelatedTypeUUID = new TypeUUID(ref mySerializationReader); }
public Exceptional<Boolean> AddBackwardEdge(DBObjectStream aDBObject, TypeUUID uUIDofType, AttributeUUID uUIDofAttribute, ObjectUUID reference) { return aDBObject.AddBackwardEdge(uUIDofType, uUIDofAttribute, reference, _DBContext.DBObjectManager); }
public static ADBBaseObject GetADBBaseObjectFromUUID(TypeUUID myUUID) { if (myUUID == DBDouble.UUID) return new DBDouble(); if (myUUID == DBUInt64.UUID) return new DBUInt64(); if (myUUID == DBInt64.UUID) return new DBInt64(); if (myUUID == DBInt32.UUID) return new DBInt32(); if (myUUID == DBString.UUID) return new DBString(); if (myUUID == DBDateTime.UUID) return new DBDateTime(); if (myUUID == DBBoolean.UUID) return new DBBoolean(); if (myUUID == DBEdge.UUID) return new DBEdge(); if (myUUID == DBReference.UUID) return new DBReference(); if (myUUID == DBBaseObject.UUID) return new DBBaseObject(); throw new GraphDBException(new Error_TypeDoesNotExist(myUUID.ToString())); }