public override Exceptional<IObject> Aggregate(AAttributeIndex attributeIndex, GraphDBType graphDBType, DBContext dbContext) { if (attributeIndex is UUIDIndex) { return new Exceptional<IObject>(new Error_NotImplemented(new System.Diagnostics.StackTrace(true), "Aggregating attribute UUID is not implemented!")); } else { var indexRelatedType = dbContext.DBTypeManager.GetTypeByUUID(attributeIndex.IndexRelatedTypeUUID); // HACK: rewrite as soon as we have real attribute index keys if (attributeIndex.IndexKeyDefinition.IndexKeyAttributeUUIDs.Count != 1) { return new Exceptional<IObject>(new Error_NotImplemented(new System.Diagnostics.StackTrace(true))); } var typeAttr = graphDBType.GetTypeAttributeByUUID(attributeIndex.IndexKeyDefinition.IndexKeyAttributeUUIDs.First()); ADBBaseObject oneVal = typeAttr.GetADBBaseObjectType(dbContext.DBTypeManager); return new Exceptional<IObject>(attributeIndex.GetKeyValues(indexRelatedType, dbContext).AsParallel().Select(kv => { var mul = oneVal.Clone(kv.Key); mul.Mul(oneVal.Clone(kv.Value.Count())); return mul; }).Aggregate(oneVal.Clone(), (elem, result) => { result.Add(elem); return result; })); } }
public override Exceptional<IObject> Aggregate(AAttributeIndex attributeIndex, GraphDBType graphDBType, DBContext dbContext) { //if (graphDBType.IsAbstract) //{ // #region For abstract types, count all attribute idx of the subtypes // UInt64 count = 0; // foreach (var aSubType in dbContext.DBTypeManager.GetAllSubtypes(graphDBType, false)) // { // if (!aSubType.IsAbstract) // { // count += aSubType.GetUUIDIndex(dbContext.DBTypeManager).GetValueCount(); // } // } // return new Exceptional<IObject>(new DBUInt64(count)); // #endregion //} //else //{ #region Return the count of idx values var indexRelatedType = dbContext.DBTypeManager.GetTypeByUUID(attributeIndex.IndexRelatedTypeUUID); return new Exceptional<IObject>(new DBUInt64(attributeIndex.GetValueCount())); #endregion //} }
public override IEnumerable<ObjectUUID> IndexSingleOperation(AAttributeIndex myIndex, ADBBaseObject myOperationValue, AttributeUUID myAttributeUUID, TypesOfBinaryExpression typeOfBinExpr, DBContext dbContext) { IndexKey lookup = new IndexKey(myAttributeUUID, myOperationValue, myIndex.IndexKeyDefinition); var currentType = dbContext.DBTypeManager.GetTypeByUUID(myIndex.IndexRelatedTypeUUID); var result = myIndex.Contains(lookup, currentType, dbContext); if (result.Value) { var interestingUUIDs = myIndex.GetValues(lookup, currentType, dbContext); foreach (var aIndexValue in myIndex.GetAllValues(currentType, dbContext)) { foreach (var aUUID in aIndexValue) { if (!interestingUUIDs.Contains(aUUID)) { yield return aUUID; } } } } else { foreach (var aIndexValue in myIndex.GetKeyValues(currentType, dbContext).Select(kv => kv.Value)) { foreach (var aUUID in aIndexValue) { yield return aUUID; } } } yield break; }
public override IEnumerable<ObjectUUID> IndexOperation(AAttributeIndex myIndex, TupleDefinition myTuple, TypesOfBinaryExpression typeOfBinExpr, DBContext dbContext) { if (myTuple.Count() != 2) { throw new GraphDBException(new Error_InvalidInRangeInterval(2, myTuple.Count())); } var currentType = dbContext.DBTypeManager.GetTypeByUUID(myIndex.IndexRelatedTypeUUID); #region As soon as the index supports ranges use them!! //limits var fromKey = new IndexKey(myIndex.IndexKeyDefinition.IndexKeyAttributeUUIDs[0], (myTuple.ElementAt(0).Value as ValueDefinition).Value, myIndex.IndexKeyDefinition); var toKey = new IndexKey(myIndex.IndexKeyDefinition.IndexKeyAttributeUUIDs[0], (myTuple.ElementAt(1).Value as ValueDefinition).Value, myIndex.IndexKeyDefinition); switch (myTuple.KindOfTuple) { case KindOfTuple.Inclusive: return myIndex.InRange(fromKey, toKey, true, true, currentType, dbContext); case KindOfTuple.LeftExclusive: return myIndex.InRange(fromKey, toKey, false, true, currentType, dbContext); case KindOfTuple.RightExclusive: return myIndex.InRange(fromKey, toKey, true, false, currentType, dbContext); case KindOfTuple.Exclusive: return myIndex.InRange(fromKey, toKey, false, false, currentType, dbContext); default: throw new GraphDBException(new Error_NotImplemented(new System.Diagnostics.StackTrace(true))); } #endregion }
public override IEnumerable<ObjectUUID> IndexSingleOperation(AAttributeIndex myIndex, ADBBaseObject myOperationValue, AttributeUUID myAttributeUUID, TypesOfBinaryExpression typeOfBinExpr, DBContext dbContext) { var myIndeyKey = new IndexKey(myAttributeUUID, myOperationValue, myIndex.IndexKeyDefinition); var currentType = dbContext.DBTypeManager.GetTypeByUUID(myIndex.IndexRelatedTypeUUID); if (myIndex.Contains(myIndeyKey, currentType, dbContext)) { foreach (var aUUID in myIndex.GetValues(myIndeyKey, currentType, dbContext)) { yield return aUUID; } } yield break; }
/// <summary> /// Count the index elements /// <seealso cref=" ABaseAggregate"/> /// </summary> public override Exceptional<FuncParameter> Aggregate(AAttributeIndex attributeIndex, GraphDBType graphDBType, DBContext dbContext) { //if (graphDBType.IsAbstract) //{ // #region For abstract types, count all attribute idx of the subtypes // UInt64 count = 0; // foreach (var aSubType in dbContext.DBTypeManager.GetAllSubtypes(graphDBType, false)) // { // if (!aSubType.IsAbstract) // { // count += aSubType.GetUUIDIndex(dbContext.DBTypeManager).GetValueCount(); // } // } // return new Exceptional<IObject>(new DBUInt64(count)); // #endregion //} //else //{ #region Return the count of idx values var indexRelatedType = dbContext.DBTypeManager.GetTypeByUUID(attributeIndex.IndexRelatedTypeUUID); var count = attributeIndex.GetValueCount(dbContext, indexRelatedType); foreach (var type in dbContext.DBTypeManager.GetAllSubtypes(indexRelatedType, false)) { var idx = type.GetAttributeIndex(dbContext, attributeIndex.IndexKeyDefinition.IndexKeyAttributeUUIDs, attributeIndex.IndexEdition); if (idx.Success()) { count += idx.Value.GetValueCount(dbContext, type); } } return new Exceptional<FuncParameter>(new FuncParameter(new DBUInt64(count))); #endregion //} }
public virtual IEnumerable<ObjectUUID> IndexSingleOperation(AAttributeIndex myIndex, ADBBaseObject myOperationValue, AttributeUUID myAttributeUUID, TypesOfBinaryExpression typeOfBinExpr, DBContext dbContext) { foreach (var keyValPair in myIndex.GetKeyValues(dbContext.DBTypeManager.GetTypeByUUID(myIndex.IndexRelatedTypeUUID), dbContext)) { var res = Compare(keyValPair.Key.IndexKeyValues[0], myOperationValue); if (res.Failed()) { throw new GraphDBException(res.PushIError(new Error_InvalidIndexOperation(myIndex.IndexName, keyValPair.Key.IndexKeyValues[0].Value, myOperationValue.Value)).IErrors); } if (res.Value) { foreach (var aUUID in keyValPair.Value) { yield return aUUID; } } } yield break; }
public override Exceptional<FuncParameter> Aggregate(AAttributeIndex attributeIndex, GraphDBType graphDBType, DBContext dbContext) { if (attributeIndex.IsUUIDIndex) { return new Exceptional<FuncParameter>(new Error_NotImplemented(new System.Diagnostics.StackTrace(true), "AVG(UUID) is not implemented!")); } var indexRelatedType = dbContext.DBTypeManager.GetTypeByUUID(attributeIndex.IndexRelatedTypeUUID); // HACK: rewrite as soon as we have real attribute index keys ADBBaseObject aADBBaseObject = new DBDouble(DBObjectInitializeType.Default); DBUInt64 total = new DBUInt64((UInt64)0); foreach (var idxEntry in attributeIndex.GetKeyValues(indexRelatedType, dbContext)) { aADBBaseObject.Add(aADBBaseObject.Clone(idxEntry.Key)); total += (UInt64)idxEntry.Value.LongCount(); } aADBBaseObject.Div(total); return new Exceptional<FuncParameter>(new FuncParameter(aADBBaseObject)); }
public virtual IEnumerable<ObjectUUID> IndexOperationReloaded(AAttributeIndex myIndex, List<Tuple<AttributeUUID, ADBBaseObject>> myOperationValues, TypesOfBinaryExpression typeOfBinExpr) { throw new GraphDBException(new Error_NotImplemented(new System.Diagnostics.StackTrace(true))); }
public virtual IEnumerable<ObjectUUID> IndexOperation(AAttributeIndex myIndex, TupleDefinition myOperationValues, TypesOfBinaryExpression typeOfBinExpr, DBContext dbContext) { throw new GraphDBException(new Error_InvalidIndexOperation(myIndex.IndexName)); }
private IEnumerable<ObjectUUID> IndexSingleOperation(AAttributeIndex myIndex, AOperationDefinition myOperationValue, AttributeUUID myAttributeUUID, TypesOfBinaryExpression typeOfBinExpr, DBContext dbContext) { if (myOperationValue is ValueDefinition) { return IndexSingleOperation(myIndex, ((ValueDefinition)myOperationValue).Value, myAttributeUUID, typeOfBinExpr, dbContext); } else { if (myOperationValue is TupleDefinition) { return IndexOperation(myIndex, (myOperationValue as TupleDefinition), typeOfBinExpr, dbContext); } else { throw new GraphDBException(new Error_NotImplemented(new System.Diagnostics.StackTrace(true), "Currently, it is not implemented to execute an IndexOperation on anything else but AtomValue or TupleValue.")); } } }
public override IEnumerable<ObjectUUID> IndexOperation(AAttributeIndex myIndex, TupleDefinition myTuple, TypesOfBinaryExpression typeOfBinExpr, DBContext dbContext) { HashSet<ObjectUUID> interestingUUIDs = new HashSet<ObjectUUID>(); IndexKey idxLookupKey = null; var currentType = dbContext.DBTypeManager.GetTypeByUUID(myIndex.IndexRelatedTypeUUID); var myOperationValues = myTuple; switch (typeOfBinExpr) { case TypesOfBinaryExpression.LeftComplex: if (!myIndex.IsListOfBaseObjectsIndex) { foreach (var aItem in myOperationValues) { idxLookupKey = new IndexKey(myIndex.IndexKeyDefinition.IndexKeyAttributeUUIDs[0], (aItem.Value as ValueDefinition).Value, myIndex.IndexKeyDefinition); interestingUUIDs.UnionWith(myIndex.GetValues(idxLookupKey, currentType, dbContext)); } } else { #region In case the index is from a set or list of baseobjects we use this way to get the values foreach (var aItem in myOperationValues) { idxLookupKey = new IndexKey(myIndex.IndexKeyDefinition.IndexKeyAttributeUUIDs[0], (aItem.Value as ValueDefinition).Value, myIndex.IndexKeyDefinition); interestingUUIDs.UnionWith(myIndex.GetValues(idxLookupKey, currentType, dbContext)); } /* What the hack is that??? - This is too slow for any usual usage of in operator! */ var indexRelatedType = dbContext.DBTypeManager.GetTypeByUUID(myIndex.IndexRelatedTypeUUID); foreach (var aKey in myIndex.GetKeys(currentType, dbContext).Where(item => !myOperationValues.Contains(new TupleElement(new ValueDefinition(item.IndexKeyValues[0]))))) { foreach (var aMatch in myIndex.GetValues(aKey, indexRelatedType, dbContext).Intersect(interestingUUIDs)) { interestingUUIDs.Remove(aMatch); } } #endregion } break; case TypesOfBinaryExpression.RightComplex: var myEnumerator = myOperationValues.GetEnumerator(); if (myEnumerator.MoveNext()) { idxLookupKey = new IndexKey(myIndex.IndexKeyDefinition.IndexKeyAttributeUUIDs[0], (myEnumerator.Current.Value as ValueDefinition).Value, myIndex.IndexKeyDefinition); interestingUUIDs.UnionWith(myIndex.GetValues(idxLookupKey, currentType, dbContext)); while (myEnumerator.MoveNext()) { idxLookupKey = new IndexKey(myIndex.IndexKeyDefinition.IndexKeyAttributeUUIDs[0], (myEnumerator.Current.Value as ValueDefinition).Value, myIndex.IndexKeyDefinition); interestingUUIDs.IntersectWith(myIndex.GetValues(idxLookupKey, currentType, dbContext)); } } break; case TypesOfBinaryExpression.Atom: case TypesOfBinaryExpression.Complex: case TypesOfBinaryExpression.Unknown: default: break; } foreach (var aValidUUID in interestingUUIDs) { yield return aValidUUID; } yield break; }
public override Exceptional<FuncParameter> Aggregate(AAttributeIndex attributeIndex, GraphDBType graphDBType, DBContext dbContext) { var indexRelatedType = dbContext.DBTypeManager.GetTypeByUUID(attributeIndex.IndexRelatedTypeUUID); return new Exceptional<FuncParameter>(new FuncParameter(attributeIndex.GetKeys(indexRelatedType, dbContext).Min().IndexKeyValues[0])); }
public abstract Exceptional<IObject> Aggregate(AAttributeIndex attributeIndex, GraphDBType graphDBType, DBContext myDBContext);
/// <summary> /// Creates an index for the given myAttributes by filling the given the index with the objects /// of this type that are already stored.</summary> /// <param name="myAttributeNames">The names of the myAttributes, over which the index was created.</param> private Exceptional<Boolean> AddAttributeIndex(AAttributeIndex myAttributeIndex, DBContext myDBContext = null) { // Add this index to the list of indices of this GraphType lock (_AttributeIndices) { if (!_AttributeIndices.ContainsKey(myAttributeIndex.IndexKeyDefinition)) { #region New IndexKeyDefinition #region Check if the IndexName already exist - same name and different keyDefinitions are not allowed! if (_AttributeIndicesNameLookup.ContainsKey(myAttributeIndex.IndexName)) { return new Exceptional<Boolean>(new Error_IndexAlreadyExist(myAttributeIndex.IndexName)); } #endregion #region Add Index (IndexKeyDefinition, IndexEdition) _AttributeIndices.Add(myAttributeIndex.IndexKeyDefinition, new Dictionary<string, AAttributeIndex>()); _AttributeIndices[myAttributeIndex.IndexKeyDefinition].Add(myAttributeIndex.IndexEdition, myAttributeIndex); _AttributeIndicesNameLookup.Add(myAttributeIndex.IndexName, myAttributeIndex.IndexKeyDefinition); #endregion #endregion } else if (_AttributeIndices[myAttributeIndex.IndexKeyDefinition].ContainsKey(myAttributeIndex.IndexEdition)) { #region IndexKeyDefinition and Edition already exist return new Exceptional<Boolean>(new Error_IndexAlreadyExistWithSameEditionAndAttribute(myDBContext, _AttributeIndices[myAttributeIndex.IndexKeyDefinition][myAttributeIndex.IndexEdition].IndexName, myAttributeIndex.IndexKeyDefinition, myAttributeIndex.IndexEdition)); #endregion } else { #region Existing IndexKeyDefinition but different edition #region If the IndexName does not exist, add it - different names for same keyDefinition and DIFFERENT Edition are allowed if (!_AttributeIndicesNameLookup.ContainsKey(myAttributeIndex.IndexName)) { _AttributeIndicesNameLookup.Add(myAttributeIndex.IndexName, myAttributeIndex.IndexKeyDefinition); } #endregion #region Add Index (IndexEdition) _AttributeIndices[myAttributeIndex.IndexKeyDefinition].Add(myAttributeIndex.IndexEdition, myAttributeIndex); #endregion #endregion } } return new Exceptional<Boolean>(true); }
/// <summary> /// Creates an index for the given myAttributes by filling the given the index with the objects /// of this type that are already stored.</summary> /// <param name="myAttributeNames">The names of the myAttributes, over which the index was created.</param> private Exceptional<Boolean> AddAttributeIndex(AAttributeIndex myAttributeIndex, DBContext myDBContext = null) { // Add this index to the list of indices of this GraphType lock (_AttributeIndices) { if (!_AttributeIndices.ContainsKey(myAttributeIndex.IndexKeyDefinition)) { #region New IndexKeyDefinition #region Check if the IndexName already exist - same name and different keyDefinitions are not allowed! if (_AttributeIndicesNameLookup.ContainsKey(myAttributeIndex.IndexName)) { return new Exceptional<Boolean>(new Error_IndexAlreadyExist(myAttributeIndex.IndexName)); } #endregion #region Add Index (IndexKeyDefinition, IndexEdition) _AttributeIndices.Add(myAttributeIndex.IndexKeyDefinition, new Dictionary<string, AAttributeIndex>()); _AttributeIndices[myAttributeIndex.IndexKeyDefinition].Add(myAttributeIndex.IndexEdition, myAttributeIndex); _AttributeIndicesNameLookup.Add(myAttributeIndex.IndexName, myAttributeIndex.IndexKeyDefinition); #endregion #endregion } else if (_AttributeIndices[myAttributeIndex.IndexKeyDefinition].ContainsKey(myAttributeIndex.IndexEdition)) { #region IndexKeyDefinition and Edition already exist return new Exceptional<Boolean>(new Error_IndexAlreadyExistWithSameEditionAndAttribute(myDBContext, _AttributeIndices[myAttributeIndex.IndexKeyDefinition][myAttributeIndex.IndexEdition].IndexName, myAttributeIndex.IndexKeyDefinition, myAttributeIndex.IndexEdition)); #endregion } else { #region Existing IndexKeyDefinition but different edition #region If the IndexName does not exist, add it - different names for same keyDefinition and DIFFERENT Edition are allowed if (!_AttributeIndicesNameLookup.ContainsKey(myAttributeIndex.IndexName)) { _AttributeIndicesNameLookup.Add(myAttributeIndex.IndexName, myAttributeIndex.IndexKeyDefinition); } #endregion #region Add Index (IndexEdition) _AttributeIndices[myAttributeIndex.IndexKeyDefinition].Add(myAttributeIndex.IndexEdition, myAttributeIndex); #endregion #endregion } myAttributeIndex.ObjectLocation = ObjectLocation + DBConstants.DBIndicesLocation + myAttributeIndex.IndexName; myAttributeIndex.ObjectName = myAttributeIndex.IndexName; myAttributeIndex.ObjectEdition = myAttributeIndex.IndexEdition; myAttributeIndex.ObjectStream = DBConstants.DBINDEXSTREAM; var storeResult = myDBContext.IGraphFSSession.StoreFSObject(myAttributeIndex, true); if (storeResult.Failed()) { return new Exceptional<bool>(storeResult); } } return new Exceptional<Boolean>(true); }
public override Exceptional<IObject> Aggregate(AAttributeIndex attributeIndex, GraphDBType graphDBType, DBContext dbContext) { var indexRelatedType = dbContext.DBTypeManager.GetTypeByUUID(attributeIndex.IndexRelatedTypeUUID); return new Exceptional<IObject>(attributeIndex.GetKeys(indexRelatedType, dbContext).Max().IndexKeyValues[0]); }
internal Exceptional<IVersionedIndexObject<IndexKey, ObjectUUID>> LoadOrCreateDBIndex(ObjectLocation myShardObjectLocation, IVersionedIndexObject<IndexKey, ObjectUUID> myIIndexObject, AAttributeIndex correspondingIDX) { if (!(myIIndexObject is AFSObject)) { return new Exceptional<IVersionedIndexObject<IndexKey, ObjectUUID>>(new Error_IndexIsNotPersistent(myIIndexObject)); } var result = _IGraphFSSession.GetOrCreateFSObject<AFSObject>(myShardObjectLocation, DBConstants.DBINDEXSTREAM, () => myIIndexObject as AFSObject); if (!result.Success()) { return new Exceptional<IVersionedIndexObject<IndexKey, ObjectUUID>>(result); } else { if (result.Value.isNew) { //TODO: might be a performance bug if (!_IGraphFSSession.ObjectExists(correspondingIDX.FileSystemLocation).Value) { result.PushIExceptional(_IGraphFSSession.CreateDirectoryObject(correspondingIDX.FileSystemLocation)); } // Uncomment as soon as index is serializeable result.PushIExceptional(_IGraphFSSession.StoreFSObject(result.Value, false)); //result.AddErrorsAndWarnings(result.Value.Save()); //ToDo: Fehler beim Speichern werden im Weiterm ignoriert statt darauf reagiert! } return new Exceptional<IVersionedIndexObject<IndexKey, ObjectUUID>>(result.Value as IVersionedIndexObject<IndexKey, ObjectUUID>); } }
/// <summary> /// Abstract aggregate function for a attribute index /// </summary> /// <param name="myAttributeIndex">Attribute index</param> /// <param name="myGraphDBType">Underlying type of the index</param> /// <param name="myDBContext">The db context</param> /// <returns>The result of the aggregation</returns> public abstract Exceptional<FuncParameter> Aggregate(AAttributeIndex myAttributeIndex, GraphDBType myGraphDBType, DBContext myDBContext);
/// <summary> /// Generate an output for an index /// </summary> /// <param name="myIndex">The index</param> /// <param name="myName">The index name</param> /// <returns>List of readouts which contain the index information</returns> private Vertex GenerateOutput(AAttributeIndex myIndex, String myName) { var _Index = new Dictionary<String, Object>(); _Index.Add("Name", myName); _Index.Add("Edition", myIndex.IndexEdition); _Index.Add("IndexType", myIndex.IndexType); _Index.Add("IsUuidIndex", myIndex.IsUUIDIndex); _Index.Add("IsUniqueAttributeIndex", myIndex.IsUniqueAttributeIndex); return new Vertex(_Index); }
private Vertex GenerateCreateIndexResult(String myDBType, List<IndexAttributeDefinition> myAttributeList, AAttributeIndex myAttributeIndex) { var payload = new Dictionary<String, Object>(); payload.Add("NAME", myAttributeIndex.IndexName); payload.Add("EDITION", myAttributeIndex.IndexEdition); payload.Add("INDEXTYPE", myAttributeIndex.IndexType); payload.Add("ONTYPE", myDBType); var attributes = new List<Vertex>(); foreach (var _Attribute in myAttributeList) { var payloadAttributes = new Dictionary<String, Object>(); payloadAttributes.Add("ATTRIBUTE", _Attribute.IndexAttribute); attributes.Add(new Vertex(payloadAttributes)); } payload.Add("ATTRIBUTES", new Edge(null, attributes) { EdgeTypeName = "ATTRIBUTE" }); return new Vertex(payload); }