/// <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="myExtractSettings">Special values which should be set to a object</param>
/// <returns>The UUID of the new DBObject</returns>
public Exceptional<DBObjectStream> CreateNewDBObject(GraphDBType myGraphDBType, Dictionary<String, IObject> myDBObjectAttributes, Dictionary<String, IObject> myUndefAttributes, Dictionary<ASpecialTypeAttribute, Object> mySpecialTypeAttributes, SessionSettings mySessionSettings, Boolean myCheckUniqueness)
{
Dictionary<AttributeUUID, IObject> _attrs = myDBObjectAttributes.ToDictionary(key => myGraphDBType.GetTypeAttributeByName(key.Key).UUID, value => value.Value);
return CreateNewDBObjectStream(myGraphDBType, _attrs, myUndefAttributes, mySpecialTypeAttributes, mySessionSettings, myCheckUniqueness);
}
/// <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);
}
private IObject GetDbos(IDChainDefinition myIDChainDefinition, DBObjectStream myDBObjectStream, DBContext dbContext, SessionSettings mySessionToken, DBObjectCache dbObjectCache)
{
if (myIDChainDefinition.LastAttribute.IsBackwardEdge)
{
var contBackwardExcept = myDBObjectStream.ContainsBackwardEdge(myIDChainDefinition.LastAttribute.BackwardEdgeDefinition, dbContext, dbObjectCache, myIDChainDefinition.LastAttribute.GetRelatedType(dbContext.DBTypeManager));
if (contBackwardExcept.Failed())
throw new GraphDBException(contBackwardExcept.IErrors);
if (contBackwardExcept.Value)
{
var beStream = dbObjectCache.LoadDBBackwardEdgeStream(myIDChainDefinition.LastType, myDBObjectStream.ObjectUUID).Value;
if (beStream.ContainsBackwardEdge(myIDChainDefinition.LastAttribute.BackwardEdgeDefinition))
return beStream.GetBackwardEdges(myIDChainDefinition.LastAttribute.BackwardEdgeDefinition);
else
return null;
}
else
{
return null;
}
}
else
{
if (myIDChainDefinition.LastAttribute.KindOfType == KindsOfType.SpecialAttribute)
{
return myDBObjectStream.GetAttribute(myIDChainDefinition.LastAttribute.UUID, myIDChainDefinition.LastAttribute.GetRelatedType(dbContext.DBTypeManager), dbContext);
}
else
{
return myDBObjectStream.GetAttribute(myIDChainDefinition.LastAttribute.UUID);
}
}
}
/// <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;
}
private Exceptional<Boolean> GetComplexMatch(IEnumerable<Tuple<GraphDBType, AAttributeIndex>> myIDX, Dictionary<DBObjectStream, AOperationDefinition> operands, DBObjectCache dbObjectCache, IDChainDefinition primIDNode, IDChainDefinition operandIDNode, DBContext dbContext, TypesOfAssociativity associativity, ref IExpressionGraph resultGraph, SessionSettings mySessionToken)
{
LevelKey primLevelKey = CreateLevelKey(primIDNode, dbContext.DBTypeManager);
LevelKey operandLevelKey = CreateLevelKey(operandIDNode, dbContext.DBTypeManager);
foreach (var aIDX in myIDX)
{
if (aIDX.Item2.IsUUIDIndex)
{
#region UUID idx
var currentIndexRelatedType = dbContext.DBTypeManager.GetTypeByUUID(aIDX.Item2.IndexRelatedTypeUUID);
foreach (var aOperand in operands)
{
foreach (var _ObjectUUIDs in ((UUIDIndex)aIDX.Item2).GetAllUUIDs(currentIndexRelatedType, dbContext))
{
var DBObjectStream = dbObjectCache.LoadDBObjectStream(aIDX.Item1, _ObjectUUIDs);
if (DBObjectStream.Failed())
{
return new Exceptional<bool>(new Error_NotImplemented(new System.Diagnostics.StackTrace(true)));
}
if (IsValidDBObjectStreamForBinExpr(DBObjectStream.Value, primIDNode.LastAttribute, dbContext.DBTypeManager))
{
var aCtype = GraphDBTypeMapper.ConvertGraph2CSharp(primIDNode.LastAttribute.GetDBType(dbContext.DBTypeManager).Name);
IObject dbos = GetDbos(primIDNode, DBObjectStream.Value, dbContext, mySessionToken, dbObjectCache);
Exceptional<AOperationDefinition> tempResult;
if (aCtype == BasicType.SetOfDBObjects)
{
tempResult = this.SimpleOperation(new TupleDefinition(aCtype, dbos, primIDNode.LastAttribute.GetDBType(dbContext.DBTypeManager)), aOperand.Value, TypesOfBinaryExpression.Complex);
}
else
{
tempResult = this.SimpleOperation(new ValueDefinition(aCtype, dbos), aOperand.Value, TypesOfBinaryExpression.Complex);
}
if (tempResult.Failed())
return new Exceptional<bool>(tempResult);
var tempOperatorResult = ((ValueDefinition)tempResult.Value);
if ((Boolean)tempOperatorResult.Value.Value)
{
switch (associativity)
{
case TypesOfAssociativity.Neutral:
case TypesOfAssociativity.Left:
IntegrateInGraph(aOperand.Key, resultGraph, operandLevelKey, dbContext, dbObjectCache);
break;
case TypesOfAssociativity.Right:
IntegrateInGraph(DBObjectStream.Value, resultGraph, primLevelKey, dbContext, dbObjectCache);
break;
default:
return new Exceptional<bool>(new Error_NotImplemented(new System.Diagnostics.StackTrace(true)));
}
}
}
}
}
#endregion
}
else
{
return new Exceptional<bool>(new Error_NotImplemented(new System.Diagnostics.StackTrace(true)));
}
}
return new Exceptional<bool>(true);
}
private ValueDefinition GetCorrectValueDefinition(TypeAttribute typeAttribute, GraphDBType graphDBType, ValueDefinition myValueDefinition, DBContext dbContext, SessionSettings mySessionsInfos)
{
if (typeAttribute.IsBackwardEdge)
{
return GetCorrectValueDefinition(dbContext.DBTypeManager.GetTypeByUUID(typeAttribute.BackwardEdgeDefinition.TypeUUID).GetTypeAttributeByUUID(typeAttribute.BackwardEdgeDefinition.AttrUUID), graphDBType, myValueDefinition, dbContext, mySessionsInfos);
}
else
{
if (typeAttribute is ASpecialTypeAttribute && typeAttribute.UUID == SpecialTypeAttribute_UUID.AttributeUUID)
{
//var uuid = SpecialTypeAttribute_UUID.ConvertToUUID(atomValue.Value.Value.ToString(), graphDBType, mySessionsInfos, dbContext.DBTypeManager);
//if (uuid.Failed())
//{
// throw new GraphDBException(uuid.Errors);
//}
//return new AtomValue(new DBReference(uuid.Value));
return new ValueDefinition(new DBReference(ObjectUUID.FromString(myValueDefinition.Value.Value.ToString())));
}
else if (!typeAttribute.GetDBType(dbContext.DBTypeManager).IsUserDefined)
{
return new ValueDefinition(GraphDBTypeMapper.GetADBBaseObjectFromUUID(typeAttribute.DBTypeUUID, myValueDefinition.Value));
}
else
{
throw new GraphDBException(new Error_InvalidAttributeValue(typeAttribute.Name, myValueDefinition.Value));
}
}
}
/// <summary>
/// This method checks and integrates a DBObjectStream into the result graph.
/// </summary>
/// <param name="myData">The DataContainer.</param>
/// <param name="myTypeManager">The TypeManager of the database.</param>
/// <param name="myQueryCache">The current query cache.</param>
/// <param name="myTypeOfBinExpr">The kind of the binary expression.</param>
/// <param name="myResultGraph">The resulting IExpressionGraph.</param>
/// <param name="myDBObjectStream">The DBObjectStream.</param>
private Exceptional<object> CheckAndIntegrateDBObjectStream(DataContainer myData, DBContext myTypeManager, DBObjectCache myQueryCache, TypesOfBinaryExpression myTypeOfBinExpr, IExpressionGraph myResultGraph, DBObjectStream myDBObjectStream, LevelKey myLevelKey, SessionSettings mySessionToken)
{
//get the operand
var operand = GetOperand(myData.IDChainDefinitions.Item1, myData.Extraordinaries.Item1, myTypeManager, myDBObjectStream, myQueryCache, mySessionToken);
if(operand == null)
{
return new Exceptional<object>();
}
if (operand.Failed())
{
return new Exceptional<object>(operand);
}
Exceptional<AOperationDefinition> tempSimpleOperationResult;
switch (myTypeOfBinExpr)
{
case TypesOfBinaryExpression.LeftComplex:
tempSimpleOperationResult = this.SimpleOperation(operand.Value, ((AOperationDefinition)myData.Operands.Item1), myTypeOfBinExpr);
break;
case TypesOfBinaryExpression.RightComplex:
tempSimpleOperationResult = this.SimpleOperation(((AOperationDefinition)myData.Operands.Item1), operand.Value, myTypeOfBinExpr);
break;
case TypesOfBinaryExpression.Complex:
case TypesOfBinaryExpression.Atom:
default:
throw new ArgumentException();
}
if (tempSimpleOperationResult.Failed())
{
return new Exceptional<object>(tempSimpleOperationResult);
}
var tempOperatorResult = ((ValueDefinition)tempSimpleOperationResult.Value);
if ((Boolean)tempOperatorResult.Value.Value)
{
IntegrateInGraph(myDBObjectStream, myResultGraph, myLevelKey, myTypeManager, myQueryCache);
}
//else
//{
// /// We need to add an empty level in case, the DBO should not be integerated. Otherwise the select does not know, either the level was never touched or
// /// not added due to an expression
// ExcludeFromGraph(myDBObjectStream, myResultGraph, myLevelKey, myTypeManager, myQueryCache);
//}
return new Exceptional<object>();
}
/// <summary>
/// Extracts data for a binary expression
/// </summary>
/// <param name="myComplexValue">The complex part of the binary expression.</param>
/// <param name="mySimpleValue">The simple/atomic part of the expression.</param>
/// <param name="errors">The list of errors.</param>
/// <param name="typeOfBinExpr">The kind of the binary expression</param>
/// <returns>A data tuple.</returns>
private Exceptional<DataContainer> ExtractData(AExpressionDefinition myComplexValue, AExpressionDefinition mySimpleValue, ref TypesOfBinaryExpression typeOfBinExpr, DBObjectCache myDBObjectCache, SessionSettings mySessionToken, DBContext dbContext, Boolean aggregateAllowed)
{
#region data
//the complex IDNode (sth. like U.Age or Count(U.Friends))
IDChainDefinition complexIDNode = null;
//the value that is on the opposite of the complex IDNode
AExpressionDefinition simpleValue = null;
//a complex IDNode may result in a complexValue (i.e. Count(U.Friends) --> 3)
AExpressionDefinition complexValue = null;
//reference to former myComplexValue
AExpressionDefinition extraordinaryValue = null;
#endregion
#region extraction
if (myComplexValue is IDChainDefinition)
{
#region IDNode
#region Data
complexIDNode = (IDChainDefinition)myComplexValue;
var validateResult = complexIDNode.Validate(dbContext, false);
if (validateResult.Failed())
{
return new Exceptional<DataContainer>(validateResult);
}
if (complexIDNode.Any(id => id is ChainPartFuncDefinition))
{
if (complexIDNode.Edges.IsNullOrEmpty())
{
#region parameterless function
var fcn = (complexIDNode.First(id => id is ChainPartFuncDefinition) as ChainPartFuncDefinition);
// somes functions (aggregates) like SUM are not valid for where expressions, though they are not resolved
if (fcn.Function == null)
return new Exceptional<DataContainer>(new Error_FunctionDoesNotExist(fcn.FuncName));
Exceptional<FuncParameter> pResult = fcn.Function.ExecFunc(dbContext);
if (pResult.Failed())
{
return new Exceptional<DataContainer>(pResult);
}
//simpleValue = new AtomValue(fcn.Function.TypeOfResult, ((FuncParameter)pResult.Value).Value); //the new simple value extraced from the function
simpleValue = new ValueDefinition(((FuncParameter)pResult.Value).Value);
typeOfBinExpr = TypesOfBinaryExpression.Unknown; //we do not know if we are left or right associated
complexIDNode = null; //we resolved it... so it's null
#endregion
}
else
{
//extraordinaryValue = (complexIDNode.First(id => id is ChainPartFuncDefinition) as ChainPartFuncDefinition);
extraordinaryValue = complexIDNode;
if (mySimpleValue is ValueDefinition)
{
simpleValue = mySimpleValue;
}
}
}
else
{
if(mySimpleValue is ValueDefinition)
{
try
{
if (complexIDNode.IsUndefinedAttribute)
{
throw new GraphDBException(new Error_AttributeIsNotDefined(complexIDNode.UndefinedAttribute));
}
simpleValue = GetCorrectValueDefinition(complexIDNode.LastAttribute, complexIDNode.LastType, ((ValueDefinition)mySimpleValue), dbContext, mySessionToken);
}
catch (FormatException)
{
return new Exceptional<DataContainer>(new Error_DataTypeDoesNotMatch(complexIDNode.LastAttribute.GetDBType(dbContext.DBTypeManager).Name, ((ValueDefinition)mySimpleValue).Value.ObjectName));
}
}
else
{
if (mySimpleValue is TupleDefinition)
{
((TupleDefinition)mySimpleValue).ConvertToAttributeType(complexIDNode.LastAttribute, dbContext);
simpleValue = mySimpleValue;
}
//else if (mySimpleValue is TupleNode)
//{
// var simpleValE = (mySimpleValue as TupleNode).GetAsTupleValue(dbContext, complexIDNode.LastAttribute);
// if (!simpleValE.Success())
// {
// return new Exceptional<DataContainer>(simpleValE);
// }
// simpleValue = simpleValE.Value;
//}
else
{
//return new Exceptional<DataContainer>(new Error_NotImplemented(new System.Diagnostics.StackTrace(true)));
}
}
}
#endregion
#endregion
}
else if (myComplexValue is TupleDefinition)
{
#region TupleSetNode
complexValue = ((TupleDefinition)myComplexValue);
simpleValue = mySimpleValue;
typeOfBinExpr = TypesOfBinaryExpression.Atom;
#endregion
}
else if (myComplexValue is AggregateDefinition)
{
#region AggregateNode
if (aggregateAllowed)
{
if (((AggregateDefinition)myComplexValue).ChainPartAggregateDefinition.Parameters.Count != 1)
{
return new Exceptional<DataContainer>(new Error_ArgumentException("An aggregate must have exactly one expression."));
}
if (!(((AggregateDefinition)myComplexValue).ChainPartAggregateDefinition.Parameters[0] is IDChainDefinition))
{
return new Exceptional<DataContainer>(new Error_ArgumentException("An aggregate must have exactly one IDNode."));
}
#region Data
complexIDNode = (((AggregateDefinition)myComplexValue).ChainPartAggregateDefinition.Parameters[0] as IDChainDefinition);
if (complexIDNode == null)
{
return new Exceptional<DataContainer>(new Error_InvalidIDNode("Only single IDNodes are currently allowed in aggregates!"));
}
#endregion
#region values
simpleValue = mySimpleValue;
extraordinaryValue = myComplexValue;
#endregion
}
else
{
return new Exceptional<DataContainer>(new Error_AggregateNotAllowed(((AggregateDefinition)myComplexValue).ChainPartAggregateDefinition));
}
#endregion
}
else
{
return new Exceptional<DataContainer>(new Error_NotImplementedExpressionNode(myComplexValue.GetType()));
}
#endregion
return new Exceptional<DataContainer>(new DataContainer(new Tuple<IDChainDefinition, IDChainDefinition>(complexIDNode, null), new Tuple<AExpressionDefinition, AExpressionDefinition>(simpleValue, complexValue), new Tuple<AExpressionDefinition, AExpressionDefinition>(extraordinaryValue, null)));
}
/// <param name="data">The DataContainer.</param>
/// <param name="dbContext">The TypeManager of the database.</param>
/// <param name="queryCache">The current query cache.</param>
/// <param name="typeOfBinExpr">The type of the binary expression.</param>
/// <param name="idx">The index for the complex part.</param>
/// <param name="errors">A list of errors.</param>
/// <param name="resultGraph">The IExpressionGraph that serves as result.</param>
/// <returns>True if the method succeeded</returns>
private Exceptional<Boolean> MatchData(DataContainer data, DBContext dbContext, DBObjectCache dbObjectCache, TypesOfBinaryExpression typeOfBinExpr, IEnumerable<Tuple<GraphDBType, AAttributeIndex>> idx, IExpressionGraph resultGraph, SessionSettings mySessionToken)
{
#region data
LevelKey myLevelKey = CreateLevelKey(data.IDChainDefinitions.Item1, dbContext.DBTypeManager);
#endregion
foreach (var aIDX in idx)
{
//this is only for such type(DBVertex) that have no AAttributeIndex
if (aIDX.Item2 == null)
{
continue;
}
#region Execution
if (aIDX.Item2.IsUUIDIndex && (data.IDChainDefinitions.Item1.LastAttribute != dbContext.DBTypeManager.GetUUIDTypeAttribute()))
{
#region UUID idx - check ALL DBOs
var IndexRelatedType = dbContext.DBTypeManager.GetTypeByUUID(aIDX.Item2.IndexRelatedTypeUUID);
var idxKeyValues = (aIDX.Item2).GetAllValues(IndexRelatedType, dbContext);
if (idxKeyValues.CountIs(0))
{
continue;
}
var uuids = idxKeyValues.Aggregate((elem, aggrresult) => aggrresult.Union(elem));
var result = IntegrateUUID(data, dbContext, dbObjectCache, typeOfBinExpr, resultGraph, mySessionToken, myLevelKey, dbObjectCache.LoadListOfDBObjectStreams(aIDX.Item1, uuids));
if (result.Failed())
{
return new Exceptional<bool>(result);
}
if (resultGraph.ContainsLevelKey(myLevelKey))
{
#region clean lower levels
if (Type == TypesOfOperators.AffectsLowerLevels)
{
CleanLowerLevel(myLevelKey, dbContext, dbObjectCache, resultGraph);
}
#endregion
}
else
{
resultGraph.AddEmptyLevel(myLevelKey);
}
#endregion
}
else
{
#region Get operationValue and type
var operationValue = (AOperationDefinition)data.Operands.Item1;
#endregion
#region Attribute index
if (aIDX.Item2.IndexKeyDefinition.IndexKeyAttributeUUIDs.Count > 1)
{
return new Exceptional<bool>(new Error_NotImplemented(new System.Diagnostics.StackTrace(true), "Currently it is not implemented to use compound indices."));
}
var interestingUUIDsByIdx = IndexSingleOperation(aIDX.Item2, operationValue, data.IDChainDefinitions.Item1.LastAttribute.UUID, typeOfBinExpr, dbContext);
#region integrate in graph
var runMT = DBConstants.RunMT;
if (runMT)
{
Parallel.ForEach(dbObjectCache.LoadListOfDBObjectStreams(data.IDChainDefinitions.Item1.LastType, interestingUUIDsByIdx), aDBO =>
{
IntegrateInGraph(aDBO.Value, resultGraph, myLevelKey, dbContext, dbObjectCache);
}
);
}
else
{
foreach (var aDBO in dbObjectCache.LoadListOfDBObjectStreams(data.IDChainDefinitions.Item1.LastType, interestingUUIDsByIdx))
{
IntegrateInGraph(aDBO.Value, resultGraph, myLevelKey, dbContext, dbObjectCache);
}
}
#endregion
if (resultGraph.ContainsLevelKey(myLevelKey))
{
#region clean lower levels
if (Type == TypesOfOperators.AffectsLowerLevels)
{
CleanLowerLevel(myLevelKey, dbContext, dbObjectCache, resultGraph);
}
#endregion
}
else
{
resultGraph.AddEmptyLevel(myLevelKey);
}
#endregion
}
#endregion
}
return new Exceptional<bool>(true);
}
private Exceptional<Boolean> MatchComplexData(TypesOfAssociativity associativity, DataContainer data, DBContext dbContext, DBObjectCache dbObjectCache, TypesOfBinaryExpression typeOfBinExpr, IEnumerable<Tuple<GraphDBType, AAttributeIndex>> leftIndices, IEnumerable<Tuple<GraphDBType, AAttributeIndex>> rightIndices, ref List<GraphDBError> errors, ref IExpressionGraph result, SessionSettings mySessionToken)
{
#region data
Dictionary<DBObjectStream, AOperationDefinition> operandsLeft = null;
Dictionary<DBObjectStream, AOperationDefinition> operandsRight = null;
#endregion
#region handle extraordinaries
if (data.Extraordinaries.Item1 != null)
{
#region left extraordinary
//there is something like a function or so
operandsLeft = new Dictionary<DBObjectStream, AOperationDefinition>();
//we have to calculate the real operand.
//TODO: try to use attribute idx instead of uuid idx
foreach (var aLeftIDX in leftIndices)
{
AAttributeIndex currentLeftIdx = null;
#region get UUID idx
if (!(aLeftIDX.Item2.IsUUIDIndex))
{
currentLeftIdx = aLeftIDX.Item1.GetUUIDIndex(dbContext);
}
else
{
currentLeftIdx = aLeftIDX.Item2;
}
#endregion
var currentIndexRelatedType = dbContext.DBTypeManager.GetTypeByUUID(currentLeftIdx.IndexRelatedTypeUUID);
foreach (var aObjectUUIDs_Left in currentLeftIdx.GetAllValues(currentIndexRelatedType, dbContext))
{
foreach (var aObjectUUID_Left in aObjectUUIDs_Left)
{
var leftDBObject = dbObjectCache.LoadDBObjectStream(aLeftIDX.Item1, aObjectUUID_Left);
if (leftDBObject.Failed())
{
throw new NotImplementedException();
}
if (IsValidDBObjectStreamForBinExpr(leftDBObject.Value, data.IDChainDefinitions.Item1.LastAttribute, dbContext.DBTypeManager))
{
var oper = GetOperand(data.IDChainDefinitions.Item1, data.Extraordinaries.Item1, dbContext, leftDBObject.Value, dbObjectCache, mySessionToken);
if (oper.Failed())
return new Exceptional<bool>(oper);
if (oper != null)
{
operandsLeft.Add(leftDBObject.Value, oper.Value);
}
}
}
}
}
//from now on the binary expression is right complex, because there are atom values on the left
typeOfBinExpr = TypesOfBinaryExpression.RightComplex;
#endregion
}
if (data.Extraordinaries.Item2 != null)
{
#region right extraordinary
//there is something like a function or so
operandsRight = new Dictionary<DBObjectStream, AOperationDefinition>();
foreach (var aRightIDX in rightIndices)
{
AAttributeIndex currentRightIdx = null;
#region get UUID idx
//we have to calculate the real operand.
//TODO: try to use attribute idx instead of uuid idx
if (!(aRightIDX.Item2.IsUUIDIndex))
{
currentRightIdx = aRightIDX.Item1.GetUUIDIndex(dbContext);
}
else
{
currentRightIdx = aRightIDX.Item2;
}
#endregion
var currentIndexRelatedType = dbContext.DBTypeManager.GetTypeByUUID(currentRightIdx.IndexRelatedTypeUUID);
foreach (var aObjectUUIDs_Right in currentRightIdx.GetAllValues(currentIndexRelatedType, dbContext))
{
foreach (var aObjectUUID_Right in aObjectUUIDs_Right)
{
var rightDBObject = dbObjectCache.LoadDBObjectStream(aRightIDX.Item1, aObjectUUID_Right);
if (rightDBObject.Failed())
{
throw new NotImplementedException();
}
if (IsValidDBObjectStreamForBinExpr(rightDBObject.Value, data.IDChainDefinitions.Item2.LastAttribute, dbContext.DBTypeManager))
{
var oper = GetOperand(data.IDChainDefinitions.Item2, data.Extraordinaries.Item2, dbContext, rightDBObject.Value, dbObjectCache, mySessionToken);
if (oper.Failed())
return new Exceptional<bool>(oper);
if (oper != null)
{
operandsRight.Add(rightDBObject.Value, oper.Value);
}
}
}
}
}
if (typeOfBinExpr == TypesOfBinaryExpression.RightComplex)
{
typeOfBinExpr = TypesOfBinaryExpression.Atom;
}
#endregion
}
#endregion
switch (typeOfBinExpr)
{
case TypesOfBinaryExpression.Atom:
#region atom
switch (associativity)
{
case TypesOfAssociativity.Unknown:
case TypesOfAssociativity.Neutral:
GetComplexAtom(dbContext, operandsLeft, operandsRight, data.IDChainDefinitions.Item1, dbObjectCache, ref result);
GetComplexAtom(dbContext, operandsRight, operandsLeft, data.IDChainDefinitions.Item2, dbObjectCache, ref result);
break;
case TypesOfAssociativity.Left:
GetComplexAtom(dbContext, operandsLeft, operandsRight, data.IDChainDefinitions.Item1, dbObjectCache, ref result);
break;
case TypesOfAssociativity.Right:
GetComplexAtom(dbContext, operandsRight, operandsLeft, data.IDChainDefinitions.Item2, dbObjectCache, ref result);
break;
default:
return new Exceptional<bool>(new Error_NotImplemented(new System.Diagnostics.StackTrace(true)));
}
#endregion
break;
case TypesOfBinaryExpression.LeftComplex:
#region Left complex
GetComplexMatch(leftIndices, operandsRight, dbObjectCache, data.IDChainDefinitions.Item1, data.IDChainDefinitions.Item2, dbContext, associativity, ref result, mySessionToken);
#endregion
break;
case TypesOfBinaryExpression.RightComplex:
#region Right complex
GetComplexMatch(rightIndices, operandsLeft, dbObjectCache, data.IDChainDefinitions.Item2, data.IDChainDefinitions.Item1, dbContext, associativity, ref result, mySessionToken);
#endregion
break;
case TypesOfBinaryExpression.Complex:
#region Complex
LevelKey leftLevelKey = CreateLevelKey(data.IDChainDefinitions.Item1, dbContext.DBTypeManager);
LevelKey rightLevelKey = CreateLevelKey(data.IDChainDefinitions.Item2, dbContext.DBTypeManager);
GraphDBType leftGraphDBType = data.IDChainDefinitions.Item1.LastType;
GraphDBType rightGraphDBType = data.IDChainDefinitions.Item2.LastType;
#region exception
if (leftIndices.CountIsGreater(1) || rightIndices.CountIsGreater(1))
{
return new Exceptional<bool>(new Error_NotImplemented(new System.Diagnostics.StackTrace(true)));
}
#endregion
var leftIndexRelatedType = dbContext.DBTypeManager.GetTypeByUUID(leftIndices.First().Item2.IndexRelatedTypeUUID);
var rightIndexRelatedType = dbContext.DBTypeManager.GetTypeByUUID(rightIndices.First().Item2.IndexRelatedTypeUUID);
foreach (var ObjectUUIDs_left in leftIndices.First().Item2.GetAllValues(leftIndexRelatedType, dbContext))
{
foreach (var aLeftUUID in ObjectUUIDs_left)
{
var leftDBObject = dbObjectCache.LoadDBObjectStream(leftIndices.First().Item1, aLeftUUID);
if (leftDBObject.Failed())
{
return new Exceptional<bool>(new Error_NotImplemented(new System.Diagnostics.StackTrace(true)));
}
if (IsValidDBObjectStreamForBinExpr(leftDBObject.Value, data.IDChainDefinitions.Item1.LastAttribute, dbContext.DBTypeManager))
{
foreach (var ObjectUUIDs_right in rightIndices.First().Item2.GetAllValues(rightIndexRelatedType, dbContext))
{
foreach (var aRightUUID in ObjectUUIDs_right)
{
var rightDBObject = dbObjectCache.LoadDBObjectStream(rightIndices.First().Item1, aRightUUID);
if (rightDBObject.Failed())
{
return new Exceptional<bool>(new Error_NotImplemented(new System.Diagnostics.StackTrace(true)));
}
if (IsValidDBObjectStreamForBinExpr(rightDBObject.Value, data.IDChainDefinitions.Item2.LastAttribute, dbContext.DBTypeManager))
{
//everything is valid
var leftType = GraphDBTypeMapper.ConvertGraph2CSharp(data.IDChainDefinitions.Item1.LastAttribute.GetDBType(dbContext.DBTypeManager).Name);
var rightType = GraphDBTypeMapper.ConvertGraph2CSharp(data.IDChainDefinitions.Item2.LastAttribute.GetDBType(dbContext.DBTypeManager).Name);
AOperationDefinition leftValue;
AOperationDefinition rightValue;
if (data.IDChainDefinitions.Item1.LastAttribute.KindOfType == KindsOfType.SetOfReferences
|| data.IDChainDefinitions.Item1.LastAttribute.KindOfType == KindsOfType.ListOfNoneReferences || data.IDChainDefinitions.Item1.LastAttribute.KindOfType == KindsOfType.SetOfNoneReferences)
leftValue = new TupleDefinition(leftType, leftDBObject.Value.GetAttribute(data.IDChainDefinitions.Item1.LastAttribute.UUID), data.IDChainDefinitions.Item1.LastAttribute.GetDBType(dbContext.DBTypeManager));
else
leftValue = new ValueDefinition(leftType, leftDBObject.Value.GetAttribute(data.IDChainDefinitions.Item1.LastAttribute.UUID, data.IDChainDefinitions.Item1.LastAttribute.GetRelatedType(dbContext.DBTypeManager), dbContext));
if (data.IDChainDefinitions.Item2.LastAttribute.KindOfType == KindsOfType.SetOfReferences
|| data.IDChainDefinitions.Item2.LastAttribute.KindOfType == KindsOfType.ListOfNoneReferences || data.IDChainDefinitions.Item2.LastAttribute.KindOfType == KindsOfType.SetOfNoneReferences)
rightValue = new TupleDefinition(rightType, rightDBObject.Value.GetAttribute(data.IDChainDefinitions.Item2.LastAttribute.UUID), data.IDChainDefinitions.Item2.LastAttribute.GetDBType(dbContext.DBTypeManager));
else
rightValue = new ValueDefinition(rightType, rightDBObject.Value.GetAttribute(data.IDChainDefinitions.Item2.LastAttribute.UUID, data.IDChainDefinitions.Item2.LastAttribute.GetRelatedType(dbContext.DBTypeManager), dbContext));
var tempSimpleOperationResult = this.SimpleOperation(leftValue, rightValue, typeOfBinExpr);
if (tempSimpleOperationResult.Failed())
return new Exceptional<bool>(tempSimpleOperationResult);
var tempOperatorResult = tempSimpleOperationResult.Value;
if ((Boolean)(tempOperatorResult as ValueDefinition).Value.Value)
{
//found sth that is really true
#region insert into graph
switch (associativity)
{
case TypesOfAssociativity.Neutral:
case TypesOfAssociativity.Left:
IntegrateInGraph(leftDBObject.Value, result, leftLevelKey, dbContext, dbObjectCache);
break;
case TypesOfAssociativity.Right:
IntegrateInGraph(rightDBObject.Value, result, rightLevelKey, dbContext, dbObjectCache);
break;
case TypesOfAssociativity.Unknown:
if (Type == TypesOfOperators.AffectsLowerLevels)
{
result.AddNodesWithComplexRelation(leftDBObject, leftLevelKey, rightDBObject, rightLevelKey, dbObjectCache, 1);
}
else
{
result.AddNodesWithComplexRelation(leftDBObject, leftLevelKey, rightDBObject, rightLevelKey, dbObjectCache, 0);
}
break;
default:
return new Exceptional<bool>(new Error_NotImplemented(new System.Diagnostics.StackTrace(true)));
}
#endregion
}
}
}
}
#region clean lower levels
if (Type == TypesOfOperators.AffectsLowerLevels)
{
switch (associativity)
{
case TypesOfAssociativity.Neutral:
case TypesOfAssociativity.Left:
CleanLowerLevel(leftLevelKey, dbContext, dbObjectCache, result);
break;
case TypesOfAssociativity.Right:
CleanLowerLevel(rightLevelKey, dbContext, dbObjectCache, result);
break;
case TypesOfAssociativity.Unknown:
CleanLowerLevel(leftLevelKey, dbContext, dbObjectCache, result);
CleanLowerLevel(rightLevelKey, dbContext, dbObjectCache, result);
break;
default:
return new Exceptional<bool>(new Error_NotImplemented(new System.Diagnostics.StackTrace(true)));
}
}
#endregion
}
}
}
#endregion
break;
default:
return new Exceptional<bool>(new Error_NotImplemented(new System.Diagnostics.StackTrace(true)));
}
return new Exceptional<bool>(true);
}
private Exceptional<object> IntegrateUUID(DataContainer data, DBContext dbContext, DBObjectCache dbObjectCache, TypesOfBinaryExpression typeOfBinExpr, IExpressionGraph resultGraph, SessionSettings mySessionToken, LevelKey myLevelKey, IEnumerable<Exceptional<DBObjectStream>> myDBObjects)
{
foreach (var aDBO in myDBObjects)
{
if (aDBO.Failed())
{
return new Exceptional<object>(aDBO);
}
if (IsValidDBObjectStreamForBinExpr(aDBO.Value, data.IDChainDefinitions.Item1.LastAttribute, dbContext.DBTypeManager))
{
//check and integrate
var result = CheckAndIntegrateDBObjectStream(data, dbContext, dbObjectCache, typeOfBinExpr, resultGraph, aDBO.Value, myLevelKey, mySessionToken);
if(!result.Success())
{
return new Exceptional<object>(result);
}
}
}
return new Exceptional<object>();
}
/// <summary>
/// This method extracts an IOperationValue out of a DBObjectStream.
/// </summary>
/// <param name="myIDChainDefinition">The corresponding IDNode.</param>
/// <param name="myExtraordinary">Sth extraordinary like an aggregate or function call.</param>
/// <param name="dbContext">The TypeManager of the database.</param>
/// <param name="myDBObjectStream">The DBObjectStream.</param>
/// <returns>An IOperationValue.</returns>
private Exceptional<AOperationDefinition> GetOperand(IDChainDefinition myIDChainDefinition, AExpressionDefinition myExtraordinary, DBContext dbContext, DBObjectStream myDBObjectStream, DBObjectCache dbObjectCache, SessionSettings mySessionToken)
{
var aCtype = GraphDBTypeMapper.ConvertGraph2CSharp(myIDChainDefinition.LastAttribute.GetDBType(dbContext.DBTypeManager).Name);
IObject dbos = GetDbos(myIDChainDefinition, myDBObjectStream, dbContext, mySessionToken, dbObjectCache);
if (dbos == null)
{
return null;
}
AOperationDefinition operand = null;
if (myExtraordinary != null)
{
#region extraordinary
if (myExtraordinary is AggregateDefinition)
{
System.Diagnostics.Debug.Assert(false);
//var aggrNode = ((AggregateDefinition)myExtraordinary).ChainPartAggregateDefinition;
//aggrNode.Validate(dbContext);
////result of aggregate
//var pResult = aggrNode.Aggregate.Aggregate(dbos, myIDChainDefinition.LastAttribute, dbContext);
//if (pResult.Failed())
// return new Exceptional<AOperationDefinition>(pResult);
//aCtype = aggrNode.Aggregate.TypeOfResult;
//operand = new ValueDefinition(aggrNode.Aggregate.TypeOfResult, pResult.Value);
}
else
{
if (myExtraordinary is IDChainDefinition)
{
var chainFunc = (myExtraordinary as IDChainDefinition).First(id => id is ChainPartFuncDefinition) as ChainPartFuncDefinition;
chainFunc.Validate(dbContext);
var func = chainFunc.Function;
func.CallingAttribute = myIDChainDefinition.LastAttribute;
func.CallingObject = dbos;
//result of function
var pResult = chainFunc.Execute(myIDChainDefinition.LastAttribute.GetDBType(dbContext.DBTypeManager), myDBObjectStream, myIDChainDefinition.Reference.Item1, dbContext);
if (pResult.Failed())
return new Exceptional<AOperationDefinition>(pResult);
//aCtype = funcCallNode.Function.TypeOfResult;
//aCtype = ((FuncParameter)pResult.Value).TypeOfOperatorResult;
operand = new ValueDefinition(((FuncParameter)pResult.Value).Value);
aCtype = (operand as ValueDefinition).Value.Type;
}
else
{
return new Exceptional<AOperationDefinition>(new Error_NotImplemented(new System.Diagnostics.StackTrace(true)));
}
}
#endregion
}
else
{
#region simple
if (aCtype == BasicType.SetOfDBObjects)
{
operand = new TupleDefinition(aCtype, dbos, myIDChainDefinition.LastAttribute.GetDBType(dbContext.DBTypeManager));
}
else
{
if (dbos is AListOfBaseEdgeType)
{
operand = new TupleDefinition(aCtype, dbos, myIDChainDefinition.LastAttribute.GetDBType(dbContext.DBTypeManager));
}
else if (dbos is ADBBaseObject)
{
operand = new ValueDefinition(dbos as ADBBaseObject);
}
else
{
operand = new ValueDefinition(aCtype, dbos);
}
}
#endregion
}
return new Exceptional<AOperationDefinition>(operand);
}
public DBSessionSettings(SessionSettings anotherSettings)
: base(anotherSettings.GetAllSettings())
{
}
