/// <summary> /// This will be invoked by the BulkInsert class. /// </summary> /// <param name="myTypeManager"></param> /// <param name="myDBTypeStream"></param> /// <param name="myDBObjectStream"></param> /// <param name="myBulkInsert"></param> internal BulkInsertDBO(DBContext myDBContext, GraphDBType myDBTypeStream, DBObjectStream myDBObjectStream, BulkInsert myBulkInsert) { _DBContext = myDBContext; _DBTypeStream = myDBTypeStream; _DBObjectStream = myDBObjectStream; _BulkInsert = myBulkInsert; }
public Warning_EdgeToNonExistingNode(DBObjectStream myStartingNode, GraphDBType myTypeOfDBO, TypeAttribute myEdge, IEnumerable<IError> myErrors) { StartingNode = myStartingNode; Errors = myErrors; Edge = myEdge; TypeOfDBO = myTypeOfDBO; }
/// <summary> /// <seealso cref=" AAttributeAssignOrUpdate"/> /// </summary> public override Exceptional<IObject> GetValueForAttribute(DBObjectStream myDBObject, DBContext myDBContext, GraphDBType myGraphDBType) { if (AttributeIDChain.IsUndefinedAttribute) { return new Exceptional<IObject>(GraphDBTypeMapper.GetBaseObjectFromCSharpType(Value)); } #region Simple value var dbType = AttributeIDChain.LastAttribute.GetDBType(myDBContext.DBTypeManager); if (AttributeIDChain.LastAttribute is SpecialTypeAttribute_UUID) { dbType = myDBContext.DBTypeManager.GetTypeByName(GraphDBTypeMapper.GetBaseObjectFromCSharpType(Value).ObjectName);//DBString.Name); } if (GraphDBTypeMapper.IsAValidAttributeType(dbType, AttributeAssignType, myDBContext, Value)) { return new Exceptional<IObject>(GraphDBTypeMapper.GetGraphObjectFromType(AttributeAssignType, Value)); ; } else { return new Exceptional<IObject>(new Error_InvalidAttributeValue(AttributeIDChain.LastAttribute.Name, Value)); } #endregion }
protected Exceptional<IDictionary<String, IObject>> LoadUndefAttributes(String myName, DBContext dbContext, DBObjectStream myObjStream) { var loadExcept = myObjStream.GetUndefinedAttributePayload(dbContext.DBObjectManager); if (loadExcept.Failed()) return new Exceptional<IDictionary<string, IObject>>(loadExcept); return new Exceptional<IDictionary<string, IObject>>(loadExcept.Value); }
public override Exceptional<IObject> ExtractValue(DBObjectStream dbObjectStream, GraphDBType graphDBType, DBContext dbContext) { EdgeTypeListOfBaseObjects parentRevisions = new EdgeTypeListOfBaseObjects(); foreach (var item in dbObjectStream.ParentRevisionIDs) parentRevisions.Add(new DBString(item.ToString())); return new Exceptional<IObject>(parentRevisions); }
public override Exceptional<IObject> ExtractValue(DBObjectStream dbObjectStream, GraphDBType graphDBType, DBContext dbContext) { EdgeTypeListOfBaseObjects streams = new EdgeTypeListOfBaseObjects(); foreach (var item in dbObjectStream.ObjectStreams) streams.Add(new DBString(item.Key + " " + item.Value.ToString())); return new Exceptional<IObject>(streams); }
public DBObjectMR(DBObjectStream myDBObject, GraphDBType myDBTypeStream, DBContext myTypeManager) { _ObjectUUID = myDBObject.ObjectUUID; _Attributes = new Dictionary<String, Object>(); foreach (var _Attribute in myDBTypeStream.Attributes) { _Attributes.Add(_Attribute.Value.Name, myDBObject.GetAttribute(_Attribute.Key)); } }
public override Exceptional<IObject> ExtractValue(DBObjectStream dbObjectStream, GraphDBType graphDBType, DBContext dbContext) { var myType = dbContext.DBTypeManager.GetTypeByUUID(dbObjectStream.TypeUUID); if (myType != null) { return new Exceptional<IObject>(new DBString(myType.Name)); } else { return new Exceptional<IObject>(new Error_NotImplemented(new System.Diagnostics.StackTrace(true))); } }
public override Exceptional<IObject> GetValueForAttribute(DBObjectStream aDBObject, DBContext dbContext, GraphDBType _Type) { #region ListOfDBObjects if (AttributeIDChain.LastAttribute.GetDBType(dbContext.DBTypeManager).IsUserDefined) { //userdefined //value = aSetNode.GetCorrespondigDBObjectUUIDs(aTaskNode.AttributeIDNodee, typeManager, dbObjectCache, mySessionToken); if (CollectionDefinition.CollectionType == CollectionType.SetOfUUIDs) { var retVal = CollectionDefinition.TupleDefinition.GetAsUUIDEdge(dbContext, AttributeIDChain.LastAttribute); if (!retVal.Success()) { return new Exceptional<IObject>(retVal); } else { return new Exceptional<IObject>(retVal.Value); } } else { var edge = (IEdgeType)(CollectionDefinition.TupleDefinition.GetCorrespondigDBObjectUUIDAsList(_Type, dbContext, AttributeIDChain.LastAttribute.EdgeType.GetNewInstance(), AttributeIDChain.LastAttribute.GetDBType(dbContext.DBTypeManager)).Value); return new Exceptional<IObject>(edge); } } else { //not userdefined var edge = GetBasicList(dbContext); if (edge.Failed()) { return new Exceptional<IObject>(edge); } // If the collection was declared as a SETOF insert if (CollectionDefinition.CollectionType == CollectionType.Set) { edge.Value.Distinction(); } return new Exceptional<IObject>(edge.Value); } #endregion }
public override Exceptional<IObject> GetValueForAttribute(DBObjectStream aDBObject, DBContext dbContext, GraphDBType _Type) { #region Expression var validateResult = BinaryExpressionDefinition.Validate(dbContext, _Type); if (validateResult.Failed()) { return new Exceptional<IObject>(validateResult); } var value = BinaryExpressionDefinition.SimpleExecution(aDBObject, dbContext); #endregion return new Exceptional<IObject>(value); }
public Exceptional<Tuple<String, TypeAttribute, IListOrSetEdgeType>> ApplyUpdateListAttribute(AAttributeAssignOrUpdateOrRemove myAttributeUpdateOrAssign, DBContext dbContext, DBObjectStream aDBObject, GraphDBType _Type) { if (myAttributeUpdateOrAssign is AttributeAssignOrUpdateList) { } else if (myAttributeUpdateOrAssign is AttributeRemoveList) { } else { return new Exceptional<Tuple<String, TypeAttribute, IListOrSetEdgeType>>(new Error_NotImplemented(new System.Diagnostics.StackTrace(true))); } return new Exceptional<Tuple<String, TypeAttribute, IListOrSetEdgeType>>(null as Tuple<String, TypeAttribute, IListOrSetEdgeType>); }
public override Exceptional<IObject> GetValueForAttribute(DBObjectStream myDBObject, DBContext myDBContext, GraphDBType myGraphDBType) { if (AttributeIDChain.IsUndefinedAttribute) { return new Exceptional<IObject>(GraphDBTypeMapper.GetBaseObjectFromCSharpType(Value)); } #region Simple value if (GraphDBTypeMapper.IsAValidAttributeType(AttributeIDChain.LastAttribute.GetDBType(myDBContext.DBTypeManager), AttributeAssignType, myDBContext, Value)) { return new Exceptional<IObject>(GraphDBTypeMapper.GetGraphObjectFromType(AttributeAssignType, Value)); ; } else { return new Exceptional<IObject>(new Error_InvalidAttributeValue(AttributeIDChain.LastAttribute.Name, Value)); } #endregion }
public override Exceptional<Dictionary<String, Tuple<TypeAttribute, IObject>>> Update(DBContext myDBContext, DBObjectStream myDBObjectStream, GraphDBType myGraphDBType) { Dictionary<String, Tuple<TypeAttribute, IObject>> attrsForResult = new Dictionary<String, Tuple<TypeAttribute, IObject>>(); #region undefined attributes //TODO: change this to a more handling thing than KeyValuePair var addExcept = myDBContext.DBObjectManager.AddUndefinedAttribute(UndefinedAttribute.AttributeName, UndefinedAttribute.AttributeValue, myDBObjectStream); if (addExcept.Failed()) { return new Exceptional<Dictionary<string, Tuple<TypeAttribute, IObject>>>(addExcept); } //sthChanged = true; attrsForResult.Add(UndefinedAttribute.AttributeName, new Tuple<TypeAttribute, IObject>(new UndefinedTypeAttribute(UndefinedAttribute.AttributeName), UndefinedAttribute.AttributeValue)); #endregion return new Exceptional<Dictionary<string, Tuple<TypeAttribute, IObject>>>(attrsForResult); }
/// <summary> /// <seealso cref=" AAttributeAssignOrUpdateOrRemove"/> /// </summary> public override Exceptional<IObject> GetValueForAttribute(DBObjectStream myDBObject, DBContext myDBContext, GraphDBType myDBType) { #region reference var validationResult = AttributeIDChain.Validate(myDBContext, true, myDBType); if (validationResult.Failed()) { return new Exceptional<IObject>(validationResult); } if (AttributeIDChain.IsUndefinedAttribute) { return new Exceptional<IObject>(new Error_InvalidReferenceAssignmentOfUndefAttr()); } // if we have a Userdefined Type, than all assignments will work on this type if (!AttributeIDChain.LastAttribute.GetDBType(myDBContext.DBTypeManager).IsUserDefined) { //attributeType = _Type; } var value = AttributeIDChain.LastAttribute.EdgeType.GetNewInstance(); var dbos = SetRefDefinition.GetCorrespondigDBObjects(AttributeIDChain.LastAttribute.GetDBType(myDBContext.DBTypeManager), myDBContext, AttributeIDChain.LastAttribute.GetRelatedType(myDBContext.DBTypeManager)); foreach (var dbo in dbos) { if (dbo.Failed()) return new Exceptional<IObject>(dbo); (value as ASingleReferenceEdgeType).Set(dbo.Value.ObjectUUID, AttributeIDChain.LastAttribute.DBTypeUUID, SetRefDefinition.Parameters); } #endregion return new Exceptional<IObject>(value); }
public Exceptional<Boolean> RemoveUndefinedAttribute(String myName, DBObjectStream myObject) { return myObject.RemoveUndefinedAttribute(myName, this); }
/// <summary> /// Removes a DBObject. /// </summary> /// <param name="myGraphType">The Type of the DBObject that is to be removed.</param> /// <param name="myDBObject">The UUID of the DBObject.</param> public Exceptional RemoveDBObject(GraphDBType myTypeOfDBObject, DBObjectStream myDBObject, DBObjectCache myDBObjectCache, SessionSettings myToken) { #region Input exceptions if (myTypeOfDBObject == null) { return new Exceptional(new Error_ArgumentNullOrEmpty("myTypeOfDBObject")); } if (myDBObject == null) { return new Exceptional(new Error_ArgumentNullOrEmpty("myUUID")); } #endregion #region Data ObjectLocation myDBObjectLocation; #endregion // Get DBObject path myDBObjectLocation = myDBObject.ObjectLocation; #region remove from attributeIDX foreach (var anIndex in myTypeOfDBObject.GetAllAttributeIndices(false)) { anIndex.Remove(myDBObject, myTypeOfDBObject, _DBContext); } #endregion #region remove from fs #region Remove DBOBJECTSTREAM var _RemoveObjectExceptional = _IGraphFSSession.RemoveObjectIfExists(myDBObjectLocation, DBConstants.DBOBJECTSTREAM); if (_RemoveObjectExceptional.Failed()) { return _RemoveObjectExceptional; } #endregion #region Remove DBBACKWARDEDGESTREAM _RemoveObjectExceptional = _IGraphFSSession.RemoveObjectIfExists(myDBObjectLocation, DBConstants.DBBACKWARDEDGESTREAM); if (_RemoveObjectExceptional.Failed()) { return _RemoveObjectExceptional; } #endregion #region Remove UNDEFATTRIBUTESSTREAM _RemoveObjectExceptional = _IGraphFSSession.RemoveObjectIfExists(myDBObjectLocation, DBConstants.UNDEFATTRIBUTESSTREAM); if (_RemoveObjectExceptional.Failed()) { return _RemoveObjectExceptional; } #endregion #endregion return Exceptional.OK; }
/// <summary> /// Flushes a DBObject to FS. /// </summary> /// <param name="myDBObject">The DBObject to be flushed.</param> /// <returns>True for success or otherwise false.</returns> public Exceptional FlushDBObject(DBObjectStream myDBObject) { #region Input validation if (myDBObject == null) return new Exceptional(new Error_ArgumentNullOrEmpty("myDBObject")); #endregion if (myDBObject.IGraphFSSessionReference == null) return _IGraphFSSession.StoreFSObject(myDBObject, true); return myDBObject.Save(); }
public override Exceptional<IObject> ExtractValue(DBObjectStream dbObjectStream, GraphDBType graphDBType, DBContext dbContext) { return new Exceptional<IObject>(new DBUInt64(dbObjectStream.MinNumberOfRevisions)); }
/// <summary> /// Creates IndexKeys from a DBObject. /// </summary> /// <param name="myDBObject">The DBObject reference for the resulting IndexKeys</param> /// <param name="myTypeOfDBObject">The Type of the DBObject</param> /// <param name="myToken">The SessionInfos</param> /// <returns>A HashSet of IndexKeys</returns> private HashSet<IndexKey> GetIndexkeysFromDBObject(DBObjectStream myDBObject, GraphDBType myTypeOfDBObject, DBContext dbContext) { HashSet<IndexKey> result = new HashSet<IndexKey>(); TypeAttribute currentAttribute; foreach (var aIndexAttributeUUID in IndexKeyDefinition.IndexKeyAttributeUUIDs) { currentAttribute = myTypeOfDBObject.GetTypeAttributeByUUID(aIndexAttributeUUID); if (!currentAttribute.GetDBType(dbContext.DBTypeManager).IsUserDefined) { #region base attribute if (myDBObject.HasAttribute(aIndexAttributeUUID, myTypeOfDBObject)) { ADBBaseObject newIndexKeyItem = null; switch (currentAttribute.KindOfType) { #region List/Set case KindsOfType.ListOfNoneReferences: case KindsOfType.SetOfNoneReferences: var helperSet = new List<ADBBaseObject>(); foreach (var aBaseObject in ((IBaseEdge)myDBObject.GetAttribute(aIndexAttributeUUID, myTypeOfDBObject, dbContext)).GetBaseObjects()) { helperSet.Add((ADBBaseObject)aBaseObject); } if (result.Count != 0) { #region update HashSet<IndexKey> helperResultSet = new HashSet<IndexKey>(); foreach (var aNewItem in helperSet) { foreach (var aReturnVal in result) { helperResultSet.Add(new IndexKey(aReturnVal, aIndexAttributeUUID, aNewItem, this.IndexKeyDefinition)); } } result = helperResultSet; #endregion } else { #region create new foreach (var aNewItem in helperSet) { result.Add(new IndexKey(aIndexAttributeUUID, aNewItem, this.IndexKeyDefinition)); } #endregion } break; #endregion #region single/special case KindsOfType.SingleReference: case KindsOfType.SingleNoneReference: case KindsOfType.SpecialAttribute: newIndexKeyItem = (ADBBaseObject)myDBObject.GetAttribute(aIndexAttributeUUID, myTypeOfDBObject, dbContext); if (result.Count != 0) { #region update foreach (var aResultItem in result) { aResultItem.AddAADBBAseObject(aIndexAttributeUUID, newIndexKeyItem); } #endregion } else { #region create new result.Add(new IndexKey(aIndexAttributeUUID, newIndexKeyItem, this.IndexKeyDefinition)); #endregion } break; #endregion #region not implemented case KindsOfType.SetOfReferences: default: throw new GraphDBException(new Error_NotImplemented(new System.Diagnostics.StackTrace(true), "Currently its not implemented to insert anything else than a List/Set/Single of base types")); #endregion } } else { //add default value var defaultADBBAseObject = GraphDBTypeMapper.GetADBBaseObjectFromUUID(currentAttribute.DBTypeUUID); defaultADBBAseObject.SetValue(DBObjectInitializeType.Default); if (result.Count != 0) { #region update foreach (var aResultItem in result) { aResultItem.AddAADBBAseObject(aIndexAttributeUUID, defaultADBBAseObject); } #endregion } else { #region create new result.Add(new IndexKey(aIndexAttributeUUID, defaultADBBAseObject, this.IndexKeyDefinition)); #endregion } } #endregion } else { #region reference attribute throw new GraphDBException(new Error_NotImplemented(new System.Diagnostics.StackTrace(true))); #endregion } } return result; }
/// <summary> /// This method updates the idx corresponding to an DBObject /// </summary> /// <param name="myDBObject">The DBObject that should be updated</param> /// <param name="myTypeOfDBObject">The type of the DBObject</param> /// <param name="myToken">The SessionInfos</param> public override Exceptional Update(DBObjectStream myDBObject, GraphDBType myTypeOfDBObject, DBContext dbContext) { #region Get index reference var idxRef = GetIndexReference(dbContext.DBIndexManager); if (!idxRef.Success()) { return new Exceptional(idxRef); } var idxRefVal = idxRef.Value; #endregion if (idxRefVal != null) { #region remove HashSet<IndexKey> toBeRemovedIdxKeys = new HashSet<IndexKey>(); foreach (var aKeyValue in idxRefVal.GetIDictionary()) { aKeyValue.Value.Remove(myDBObject.ObjectUUID); if (aKeyValue.Value.Count == 0) { toBeRemovedIdxKeys.Add(aKeyValue.Key); } } foreach (var aToBeDeletedIndexKey in toBeRemovedIdxKeys) { idxRefVal.Remove(aToBeDeletedIndexKey); } #endregion #region insert if (myDBObject.HasAtLeastOneAttribute(this.IndexKeyDefinition.IndexKeyAttributeUUIDs, myTypeOfDBObject, dbContext.SessionSettings)) { //insert foreach (var aIndexKey in this.GetIndexkeysFromDBObject(myDBObject, myTypeOfDBObject, dbContext)) { idxRefVal.Set(aIndexKey, myDBObject.ObjectUUID, IndexSetStrategy.MERGE); } } #endregion } else { return new Exceptional(new Error_InvalidIndexReference(IndexName, IndexEdition)); } return Exceptional.OK; }
/// <summary> /// This method inserts the given DBObject into the index /// </summary> /// <param name="myDBObject">The DBObject that should be inserted</param> /// <param name="myIndexSetStrategy">The index merge strategy</param> /// <param name="myTypeOfDBObject">The type of the DBObject</param> /// <param name="myToken">The SessionInfos</param> public override Exceptional Insert(DBObjectStream myDBObject, IndexSetStrategy myIndexSetStrategy, GraphDBType myTypeOfDBObject, DBContext dbContext) { #region Get index reference var idxRef = GetIndexReference(dbContext.DBIndexManager); if (!idxRef.Success()) { return new Exceptional(idxRef); } var idxRefVal = idxRef.Value; #endregion if (idxRefVal != null) { foreach (var aIndexKex in GetIndexkeysFromDBObject(myDBObject, myTypeOfDBObject, dbContext)) { #region Check for uniqueness - TODO: remove me as soon as we have a unique indexObject implementation if (IsUniqueAttributeIndex) { if (idxRefVal.ContainsKey(aIndexKex)) { return new Exceptional(new Error_UniqueConstrainViolation(myTypeOfDBObject.Name, IndexName)); } } #endregion idxRefVal.Set(aIndexKex, myDBObject.ObjectUUID, myIndexSetStrategy); } } else { return new Exceptional(new Error_InvalidIndexReference(IndexName, IndexEdition)); } return Exceptional.OK; }
public override Exceptional<Object> ApplyTo(DBObjectStream myNewDBObject, object myValue, params object[] myOptionalParameters) { return new Exceptional<Object>(new Error_NotImplemented(new StackTrace(true))); }
public Exceptional<Boolean> AddUndefinedAttribute(String myName, IObject myValue, DBObjectStream myObject) { return myObject.AddUndefinedAttribute(myName, myValue, this); }
public Exceptional<Boolean> AddBackwardEdge(DBObjectStream aDBObject, TypeUUID uUIDofType, AttributeUUID uUIDofAttribute, ObjectUUID reference) { return aDBObject.AddBackwardEdge(uUIDofType, uUIDofAttribute, reference, _DBContext.DBObjectManager); }
private Exceptional<Trinary> ObjectExistsOnFS(DBObjectStream NewDBObject) { var objectExistException = _IGraphFSSession.ObjectStreamExists(NewDBObject.ObjectLocation, DBConstants.DBOBJECTSTREAM); if (objectExistException.Failed()) return new Exceptional<Trinary>(objectExistException); return new Exceptional<Trinary>(objectExistException.Value); }
/// <summary> /// This method removes a given DBObject from the index /// </summary> /// <param name="myDBObject">The DBObject that should be removed</param> /// <param name="myTypeOfDBObjects">The type of the DBObject</param> /// <param name="myToken">The SessionInfos</param> public override Exceptional Remove(DBObjectStream myDBObject, GraphDBType myTypeOfDBObjects, DBContext dbContext) { #region Get index reference var idxRef = GetIndexReference(dbContext.DBIndexManager); if (!idxRef.Success()) { return new Exceptional(idxRef); } var idxRefVal = idxRef.Value; #endregion if (idxRefVal != null) { foreach (var aIndexKex in GetIndexkeysFromDBObject(myDBObject, myTypeOfDBObjects, dbContext)) { idxRefVal.Remove(aIndexKex, myDBObject.ObjectUUID); } } else { return new Exceptional(new Error_InvalidIndexReference(IndexName, IndexEdition)); } return Exceptional.OK; }
/// <summary> /// Creates a new DBObject of a given GraphType inserts its UUID into all indices of the given GraphType. /// </summary> /// <param name="myGraphDBType">The GraphType of the DBObject to create</param> /// <param name="myDBObjectAttributes">A dictionary of attributes for the new DBObject</param> /// <param name="mySpecialTypeAttributes">Special values which should be set to a object</param> /// <param name="myCheckUniqueness">check for unique constraints</param> /// <returns>The UUID of the new DBObject</returns> public Exceptional<DBObjectStream> CreateNewDBObjectStream(GraphDBType myGraphDBType, Dictionary<AttributeUUID, IObject> myDBObjectAttributes, Dictionary<String, IObject> myUndefAttributes, Dictionary<ASpecialTypeAttribute, Object> mySpecialTypeAttributes, SessionSettings mySessionSettings, Boolean myCheckUniqueness) { #region Input validation if (myGraphDBType == null) return new Exceptional<DBObjectStream>(new Error_ArgumentNullOrEmpty("The parameter myGraphType must not be null!")); if (myDBObjectAttributes == null) return new Exceptional<DBObjectStream>(new Error_ArgumentNullOrEmpty("The parameter myDBObjectAttributes must not be null!")); #endregion #region Check uniqueness if (myCheckUniqueness) { var parentTypes = _DBContext.DBTypeManager.GetAllParentTypes(myGraphDBType, true, false); var CheckVal = _DBContext.DBIndexManager.CheckUniqueConstraint(myGraphDBType, parentTypes, myDBObjectAttributes); if (CheckVal.Failed()) return new Exceptional<DBObjectStream>(CheckVal); } #endregion #region Create a new DBObjectStream DBObjectStream _NewDBObjectStream = null; ObjectUUID _NewObjectUUID = null; ASpecialTypeAttribute _SpecialTypeAttribute_UUID_Key = new SpecialTypeAttribute_UUID(); Object _SpecialTypeAttribute_UUID_Value = null; #region Search for an user-defined ObjectUUID if (mySpecialTypeAttributes != null) { if (mySpecialTypeAttributes.TryGetValue(_SpecialTypeAttribute_UUID_Key, out _SpecialTypeAttribute_UUID_Value)) { // User-defined ObjectUUID of type UInt64 var _ValueAsUInt64 = _SpecialTypeAttribute_UUID_Value as UInt64?; if (_ValueAsUInt64 != null) _NewObjectUUID = new ObjectUUID(_ValueAsUInt64.Value); // User-defined ObjectUUID of type String or anything else... else { var _String = _SpecialTypeAttribute_UUID_Value.ToString(); if (_String == null || _String == "") return new Exceptional<DBObjectStream>(new Error_InvalidAttributeValue(SpecialTypeAttribute_UUID.AttributeName, _String)); _NewObjectUUID = new ObjectUUID(_SpecialTypeAttribute_UUID_Value.ToString()); } mySpecialTypeAttributes[_SpecialTypeAttribute_UUID_Key] = _NewObjectUUID; } } #endregion // If _NewObjectUUID == null a new one will be generated! _NewDBObjectStream = new DBObjectStream(_NewObjectUUID, myGraphDBType, myDBObjectAttributes); _NewDBObjectStream.ObjectLocation = new ObjectLocation(_NewDBObjectStream.ObjectPath, _NewDBObjectStream.ObjectUUID.ToString()); #endregion #region Check for duplicate ObjectUUIDs... maybe resolve duplicates! var _DBObjectStreamAlreadyExistsResult = ObjectExistsOnFS(_NewDBObjectStream); if (_DBObjectStreamAlreadyExistsResult.Failed()) return new Exceptional<DBObjectStream>(_DBObjectStreamAlreadyExistsResult); while (_DBObjectStreamAlreadyExistsResult.Value == Trinary.TRUE) { if (_NewObjectUUID != null) return new Exceptional<DBObjectStream>(new Error_DBObjectCollision(_NewDBObjectStream)); _NewDBObjectStream = new DBObjectStream(ObjectUUID.NewUUID, myGraphDBType, myDBObjectAttributes); _NewDBObjectStream.ObjectLocation = new ObjectLocation(_NewDBObjectStream.ObjectPath, _NewDBObjectStream.ObjectUUID.ToString()); _DBObjectStreamAlreadyExistsResult = ObjectExistsOnFS(_NewDBObjectStream); if (_DBObjectStreamAlreadyExistsResult.Failed()) return new Exceptional<DBObjectStream>(_DBObjectStreamAlreadyExistsResult); } #endregion #region Check for ExtractSetting attributes unlike UUID if (mySpecialTypeAttributes != null && mySpecialTypeAttributes.Any()) { foreach (var _SpecialAttribute in mySpecialTypeAttributes) { // Skip SpecialTypeAttribute_UUID! if (!(_SpecialAttribute.Key is SpecialTypeAttribute_UUID)) { var result = _SpecialAttribute.Key.ApplyTo(_NewDBObjectStream, _SpecialAttribute.Value); if (result.Failed()) { return new Exceptional<DBObjectStream>(result); } } } } #endregion // Flush new DBObject var flushResult = FlushDBObject(_NewDBObjectStream); if (flushResult.Failed()) return new Exceptional<DBObjectStream>(flushResult); #region Check for existing object - might be removed at some time //var exists = ObjectExistsOnFS(_NewDBObjectStream); //if (exists.Failed()) // return new Exceptional<DBObjectStream>(exists); //if (exists.Value != Trinary.TRUE) //{ // return new Exceptional<DBObjectStream>(new Error_UnknownDBError("DBObject with path " + _NewDBObjectStream.ObjectLocation + " does not exist.")); //} #endregion #region Add UUID of the new DBObject to all indices of myGraphType foreach (var _GraphDBType in _DBContext.DBTypeManager.GetAllParentTypes(myGraphDBType, true, false)) { foreach (var _AAttributeIndex in _GraphDBType.GetAllAttributeIndices(false)) { //Find out if the dbobject carries all necessary attributes if (_NewDBObjectStream.HasAtLeastOneAttribute(_AAttributeIndex.IndexKeyDefinition.IndexKeyAttributeUUIDs, _GraphDBType, mySessionSettings)) { //valid dbo for idx _AAttributeIndex.Insert(_NewDBObjectStream, _GraphDBType, _DBContext); } } } #endregion #region add undefined attributes to the object if (!myUndefAttributes.IsNullOrEmpty()) { foreach (var item in myUndefAttributes) { var addExcept = _NewDBObjectStream.AddUndefinedAttribute(item.Key, item.Value, this); if (addExcept.Failed()) { return new Exceptional<DBObjectStream>(addExcept); } } } #endregion return new Exceptional<DBObjectStream>(_NewDBObjectStream); }
/// <summary> /// This method checks if the current attribute index contains a DBObject /// </summary> /// <param name="myDBObject">The DBObject that should be checked</param> /// <param name="myTypeOfDBObject">The Type of the DBObject</param> /// <param name="myToken">The SessionInfos</param> /// <returns>A Trinary</returns> public override Boolean Contains(DBObjectStream myDBObject, GraphDBType myTypeOfDBObject, DBContext dbContext) { #region Get index reference var idxRef = GetIndexReference(dbContext.DBIndexManager); if (idxRef.Failed()) { throw new GraphDBException(new Error_CouldNotGetIndexReference(idxRef.IErrors, IndexName, IndexEdition)); } var idxRefVal = idxRef.Value; #endregion if (idxRefVal != null) { foreach (var aIndexKex in GetIndexkeysFromDBObject(myDBObject, myTypeOfDBObject, dbContext)) { if (idxRefVal.Contains(aIndexKex, myDBObject.ObjectUUID)) { return true; } } return false; } else { throw new GraphDBException(new Error_InvalidIndexReference(IndexName, IndexEdition)); } }
public override Exceptional<IObject> ExtractValue(DBObjectStream myDBObjectStream, GraphDBType myGraphDBType, DBContext myDBContext) { return new Exceptional<IObject>(new DBObjectRevisionID(myDBObjectStream.ObjectRevisionID)); }
/// <summary> /// This method inserts the given DBObject into the index /// </summary> /// <param name="myDBObject">The DBObject that should be inserted</param> /// <param name="myTypeOfDBobject">The type of the DBObject</param> /// <param name="myToken">The SessionInfos</param> public override Exceptional Insert(DBObjectStream myDBObject, GraphDBType myTypeOfDBobject, DBContext dbContext) { return Insert(myDBObject, IndexSetStrategy.MERGE, myTypeOfDBobject, dbContext); }