private AExpressionDefinition TryGetBinexpression(AExpressionDefinition expression,
GQLPluginManager myPluginManager,
IGraphDB myGraphDB,
SecurityToken mySecurityToken,
Int64 myTransactionToken,
params IVertexType[] types)
{
if (expression is BinaryExpressionDefinition)
{
(expression as BinaryExpressionDefinition).Validate(myPluginManager, myGraphDB, mySecurityToken, myTransactionToken, types);
return(expression as BinaryExpressionDefinition);
}
else
{
//for negative values like -U.Age
if (expression is UnaryExpressionDefinition)
{
var binExpr = (expression as UnaryExpressionDefinition).GetBinaryExpression(myPluginManager, myGraphDB, mySecurityToken, myTransactionToken);
return(binExpr);
}
else
{
if (expression is TupleDefinition)
{
return(TryGetBinexpression(((TupleDefinition)expression).First().Value, myPluginManager, myGraphDB, mySecurityToken, myTransactionToken));
}
}
}
throw new NotImplementedQLException("");
}
/// <summary>
///
/// </summary>
/// <param name="myAExpressionDefinition"></param>
/// <returns></returns>
private AOperationDefinition TryGetOperationValue(AExpressionDefinition myAExpressionDefinition)
{
#region data
var expression = myAExpressionDefinition as BinaryExpressionDefinition;
#endregion
if (expression == null)
{
return(null);
}
if (expression.TypeOfBinaryExpression == TypesOfBinaryExpression.Atom)
{
return(expression.ResultValue);
}
if (expression.ResultValue != null)
{
return(expression.ResultValue);
}
return(null);
}
public BinaryExpressionDefinition(String myOperatorSymbol, AExpressionDefinition myLeft, AExpressionDefinition myRight)
{
_OperatorSymbol = myOperatorSymbol;
_Left = myLeft;
_Right = myRight;
}
public BinaryExpressionDefinition(String myOperatorSymbol,
AExpressionDefinition myLeft,
AExpressionDefinition myRight,
String myExpressionIndex = null)
{
_OperatorSymbol = myOperatorSymbol;
_Left = myLeft;
_Right = myRight;
ExpressionIndex = myExpressionIndex;
}
public void Init(ParsingContext context, ParseTreeNode parseNode)
{
_ParseTreeNode = parseNode.ChildNodes[0];
ExpressionDefinition = GetExpressionDefinition(_ParseTreeNode);
if (HasChildNodes(parseNode.ChildNodes[1]))
{
Parameters = ((ParametersNode)parseNode.ChildNodes[1].AstNode).ParameterValues;
}
}
public BinaryExpressionDefinition(String myOperatorSymbol,
AExpressionDefinition myLeft,
AExpressionDefinition myRight,
String myExpressionIndex = null)
{
_OperatorSymbol = myOperatorSymbol;
_Left = myLeft;
_Right = myRight;
ExpressionIndex = myExpressionIndex;
}
public void Init(ParsingContext context, ParseTreeNode parseNode)
{
#region set type of binary expression
_OperatorSymbol = parseNode.ChildNodes[1].FirstChild.Token.ValueString;
_left = GetExpressionDefinition(parseNode.ChildNodes[0]);
_right = GetExpressionDefinition(parseNode.ChildNodes[2]);
#endregion
BinaryExpressionDefinition = new BinaryExpressionDefinition(_OperatorSymbol, _left, _right);
OriginalString += _left.ToString() + " ";
OriginalString += _OperatorSymbol + " ";
OriginalString += _right.ToString();
}
private void ValidateBinaryExpressionInternal(AExpressionDefinition aUniqueExpr, IVertexType validationType, GQLPluginManager myPluginManager, IGraphDB myGraphDB, SecurityToken mySecurityToken, Int64 myTransactionToken)
{
if (aUniqueExpr is BinaryExpressionDefinition)
{
(aUniqueExpr as BinaryExpressionDefinition).Validate(myPluginManager, myGraphDB, mySecurityToken, myTransactionToken, validationType);
}
else
{
var _potIdNode = aUniqueExpr as IDChainDefinition;
if (_potIdNode != null)
{
//var validationResult = _potIdNode.ValidateMe(validationType, typeManager);
_potIdNode.Validate(myPluginManager, myGraphDB, mySecurityToken, myTransactionToken, false, validationType);
}
}
}
public void Init(ParsingContext context, ParseTreeNode parseNode)
{
if (HasChildNodes(parseNode))
{
if (parseNode.ChildNodes[1].AstNode == null)
{
throw new NotImplementedQLException("");
}
_OperatorSymbol = parseNode.ChildNodes[0].Token.Text;
Expression = GetExpressionDefinition(parseNode.ChildNodes[1]);
}
System.Diagnostics.Debug.Assert(Expression != null);
UnaryExpressionDefinition = new UnaryExpressionDefinition(_OperatorSymbol, Expression);
}
public void Init(ParsingContext context, ParseTreeNode parseNode)
{
ExpressionDefinition = GetExpressionDefinition(parseNode.ChildNodes[0]);
}
/// <summary>
/// Validates the expression (Set the TypeOfBinaryExpression, do some simplifications and validates all IDChains)
/// </summary>
public void Validate(GQLPluginManager myPluginManager,
IGraphDB myGraphDB,
SecurityToken mySecurityToken,
Int64 myTransactionToken,
params IVertexType[] types)
{
if (IsValidated)
{
return;
}
Operator = GetOperatorBySymbol(_OperatorSymbol);
#region Left - Valid TypesOfBinaryExpression are RightComplex (left is atom) or LeftComplex (left is complex)
if (_Left is ValueDefinition)
{
TypeOfBinaryExpression = TypesOfBinaryExpression.RightComplex;
}
else if (_Left is IDChainDefinition)
{
(_Left as IDChainDefinition).Validate(myPluginManager, myGraphDB, mySecurityToken, myTransactionToken, true, types);
TypeOfBinaryExpression = TypesOfBinaryExpression.LeftComplex;
}
else if (_Left is TupleDefinition)
{
#region TupleDefinition
if (IsEncapsulatedBinaryExpression(_Left as TupleDefinition))
{
_Left = TryGetBinexpression((_Left as TupleDefinition).First().Value, myPluginManager, myGraphDB, mySecurityToken, myTransactionToken, types);
TypeOfBinaryExpression = TypesOfBinaryExpression.LeftComplex;
}
else
{
_Left = AssignCorrectTuple(myPluginManager, (_Left as TupleDefinition), Operator, myGraphDB, mySecurityToken, myTransactionToken);
TypeOfBinaryExpression = TypesOfBinaryExpression.RightComplex;
}
#endregion
}
else if (_Left is AggregateDefinition)
{
TypeOfBinaryExpression = TypesOfBinaryExpression.LeftComplex;
}
else if (_Left is UnaryExpressionDefinition)
{
TypeOfBinaryExpression = TypesOfBinaryExpression.LeftComplex;
_Left = (_Left as UnaryExpressionDefinition).GetBinaryExpression(myPluginManager, myGraphDB, mySecurityToken, myTransactionToken);
}
else
{
#region try binexpr
_Left = TryGetBinexpression(_Left, myPluginManager, myGraphDB, mySecurityToken, myTransactionToken, types);
TypeOfBinaryExpression = TypesOfBinaryExpression.LeftComplex;
#endregion
}
#endregion
#region Right
if (_Right is ValueDefinition)
{
if (TypeOfBinaryExpression == TypesOfBinaryExpression.RightComplex)
{
TypeOfBinaryExpression = TypesOfBinaryExpression.Atom;
}
}
else if (_Right is IDChainDefinition)
{
(_Right as IDChainDefinition).Validate(myPluginManager, myGraphDB, mySecurityToken, myTransactionToken, false, types);
if (TypeOfBinaryExpression == TypesOfBinaryExpression.LeftComplex)
{
TypeOfBinaryExpression = TypesOfBinaryExpression.Complex;
}
}
else if (_Right is UnaryExpressionDefinition)
{
if (TypeOfBinaryExpression == TypesOfBinaryExpression.LeftComplex)
{
TypeOfBinaryExpression = TypesOfBinaryExpression.Complex;
}
_Right = (_Right as UnaryExpressionDefinition).GetBinaryExpression(myPluginManager, myGraphDB, mySecurityToken, myTransactionToken);
}
else if (_Right is TupleDefinition)
{
#region TupleDefinition
if (IsEncapsulatedBinaryExpression(_Right as TupleDefinition))
{
_Right = TryGetBinexpression((_Right as TupleDefinition).First().Value, myPluginManager, myGraphDB, mySecurityToken, myTransactionToken, types);
if (TypeOfBinaryExpression == TypesOfBinaryExpression.LeftComplex)
{
TypeOfBinaryExpression = TypesOfBinaryExpression.Complex;
}
}
else
{
_Right = AssignCorrectTuple(myPluginManager, (_Right as TupleDefinition), Operator, myGraphDB, mySecurityToken, myTransactionToken);
if (TypeOfBinaryExpression == TypesOfBinaryExpression.RightComplex)
{
TypeOfBinaryExpression = TypesOfBinaryExpression.Atom;
}
}
#endregion
}
else if (_Right is AggregateDefinition)
{
if (TypeOfBinaryExpression == TypesOfBinaryExpression.LeftComplex)
{
TypeOfBinaryExpression = TypesOfBinaryExpression.Complex;
}
}
else
{
#region try binexpr
_Right = TryGetBinexpression(_Right, myPluginManager, myGraphDB, mySecurityToken, myTransactionToken, types);
if (TypeOfBinaryExpression == TypesOfBinaryExpression.LeftComplex)
{
TypeOfBinaryExpression = TypesOfBinaryExpression.Complex;
}
#endregion
}
#endregion
#region try to get values from complex expr
AOperationDefinition leftTemp;
AOperationDefinition rightTemp;
switch (TypeOfBinaryExpression)
{
case TypesOfBinaryExpression.Atom:
break;
case TypesOfBinaryExpression.LeftComplex:
#region leftComplex
leftTemp = TryGetOperationValue(_Left);
if (leftTemp != null)
{
TypeOfBinaryExpression = TypesOfBinaryExpression.Atom;
_Left = leftTemp;
}
#endregion
break;
case TypesOfBinaryExpression.RightComplex:
#region rightComplex
rightTemp = TryGetOperationValue(_Right);
if (rightTemp != null)
{
TypeOfBinaryExpression = TypesOfBinaryExpression.Atom;
_Right = rightTemp;
}
#endregion
break;
case TypesOfBinaryExpression.Complex:
#region complex
leftTemp = TryGetOperationValue(_Left);
rightTemp = TryGetOperationValue(_Right);
if ((leftTemp != null) && (rightTemp != null))
{
TypeOfBinaryExpression = TypesOfBinaryExpression.Atom;
_Left = leftTemp;
_Right = rightTemp;
}
else
{
if (leftTemp != null)
{
TypeOfBinaryExpression = TypesOfBinaryExpression.RightComplex;
_Left = leftTemp;
}
else if (rightTemp != null)
{
TypeOfBinaryExpression = TypesOfBinaryExpression.LeftComplex;
_Right = rightTemp;
}
}
#endregion
break;
}
#endregion
#region process values
if (TypeOfBinaryExpression == TypesOfBinaryExpression.Atom)
{
#region atomic values
if ((_Left is AOperationDefinition) && (_Right is AOperationDefinition))
{
//ResultValue = Operator.SimpleOperation(((AOperationDefinition)_Left), ((AOperationDefinition)_Right), TypeOfBinaryExpression);
}
#endregion
}
#endregion
if ((Operator == BinaryOperator.AND && ExpressionIndex != null) ||
(Operator == BinaryOperator.OR && ExpressionIndex != null))
{
throw new InvalidBinaryExpressionIndexException(this);
}
_isValidated = true;
}
/// <summary>
/// Finds matching result corresponding to a binary expression.
/// </summary>
/// <param name="myLeftValueObject">The left value of a binary expression.</param>
/// <param name="myRightValueObject">The right value of a binary expression.</param>
/// <returns></returns>
public static IExpressionGraph TypeOperation(
AExpressionDefinition myLeftValueObject, AExpressionDefinition myRightValueObject,
GQLPluginManager myPluginManager,
IGraphDB myGraphDB, SecurityToken mySecurityToken, Int64 myTransactionToken,
TypesOfBinaryExpression typeOfBinExpr, IExpressionGraph resultGr, TypesOfOperators mytypesOfOpertators, BinaryOperator myOperator, Boolean aggregateAllowed = true)
{
#region Data
//DataContainer for all data that is used by a binary expression/comparer
DataContainer data;
#endregion
#region extract data
//data extraction with an eye on the type of the binary expression
switch (typeOfBinExpr)
{
case TypesOfBinaryExpression.Atom:
//sth like 3 = 4
#region Get Atom data
//no further data has to be generated
//data = new DataContainer(null, new Tuple<Object, Object>(myLeftValueObject, myRightValueObject), null);
data = new DataContainer();
#endregion
break;
case TypesOfBinaryExpression.LeftComplex:
//sth like U.Age = 21
#region Get LeftComplex data
data = ExtractData(myLeftValueObject, myRightValueObject, ref typeOfBinExpr, myPluginManager, myGraphDB, mySecurityToken, myTransactionToken, aggregateAllowed);
#endregion
break;
case TypesOfBinaryExpression.RightComplex:
//sth like 21 = U.Age
#region Get RightComplex data
data = ExtractData(myRightValueObject, myLeftValueObject, ref typeOfBinExpr, myPluginManager, myGraphDB, mySecurityToken, myTransactionToken, aggregateAllowed);
#endregion
break;
case TypesOfBinaryExpression.Complex:
//sth like U.Age = F.Alter
#region Get Complex data
var leftData = ExtractData(myLeftValueObject, myRightValueObject, ref typeOfBinExpr, myPluginManager, myGraphDB, mySecurityToken, myTransactionToken, aggregateAllowed);
var rightData = ExtractData(myRightValueObject, myLeftValueObject, ref typeOfBinExpr, myPluginManager, myGraphDB, mySecurityToken, myTransactionToken, aggregateAllowed);
if (typeOfBinExpr == TypesOfBinaryExpression.Unknown)
{
typeOfBinExpr = SetTypeOfBinaryExpression(leftData, rightData);
switch (typeOfBinExpr)
{
case TypesOfBinaryExpression.Atom:
data = new DataContainer(new Tuple<IDChainDefinition, IDChainDefinition>(null, null), new Tuple<AExpressionDefinition, AExpressionDefinition>(leftData.Operands.Item1, leftData.Operands.Item1), new Tuple<AExpressionDefinition, AExpressionDefinition>(null, null));
break;
case TypesOfBinaryExpression.LeftComplex:
data = new DataContainer(new Tuple<IDChainDefinition, IDChainDefinition>(leftData.IDChainDefinitions.Item1, null), new Tuple<AExpressionDefinition, AExpressionDefinition>(rightData.Operands.Item1, null), new Tuple<AExpressionDefinition, AExpressionDefinition>(null, null));
break;
case TypesOfBinaryExpression.RightComplex:
data = new DataContainer(new Tuple<IDChainDefinition, IDChainDefinition>(rightData.IDChainDefinitions.Item1, null), new Tuple<AExpressionDefinition, AExpressionDefinition>(leftData.Operands.Item1, null), new Tuple<AExpressionDefinition, AExpressionDefinition>(null, null));
break;
case TypesOfBinaryExpression.Complex:
case TypesOfBinaryExpression.Unknown:
default:
throw new NotImplementedQLException("");
}
}
else
{
data = JoinData(leftData, rightData);
}
#endregion
break;
default:
throw new ArgumentException();
}
#endregion
#region match data
switch (typeOfBinExpr)
{
case TypesOfBinaryExpression.Atom:
#region Atom
//do nothing 3 = 3 (or 2 != 3) doesnt bother U
#endregion
break;
case TypesOfBinaryExpression.LeftComplex:
#region LeftComplex
MatchData(data, resultGr, myGraphDB, mySecurityToken, myTransactionToken, mytypesOfOpertators, myOperator);
#endregion
break;
case TypesOfBinaryExpression.RightComplex:
#region RightComplex
MatchData(data, resultGr, myGraphDB, mySecurityToken, myTransactionToken, mytypesOfOpertators, myOperator);
#endregion
break;
case TypesOfBinaryExpression.Complex:
#region Complex
throw new NotImplementedQLException("");
#endregion
}
#endregion
return resultGr;
}
private static IExpression GenerateLiteral(AExpressionDefinition aExpressionDefinition, Type myTypeOfLiteral)
{
if (aExpressionDefinition is ValueDefinition)
{
return new SingleLiteralExpression( ((ValueDefinition)aExpressionDefinition).Value.ConvertToIComparable(myTypeOfLiteral));
}
else
{
throw new NotImplementedQLException("TODO");
}
}
/// <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 static DataContainer ExtractData(AExpressionDefinition myComplexValue, AExpressionDefinition mySimpleValue, ref TypesOfBinaryExpression typeOfBinExpr, GQLPluginManager myPluginManager, IGraphDB myGraphDB, SecurityToken mySecurityToken, Int64 myTransactionToken, 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;
complexIDNode.Validate(myPluginManager, myGraphDB, mySecurityToken, myTransactionToken, false);
if (complexIDNode.Any(id => id is ChainPartFuncDefinition))
{
if (complexIDNode.Edges == null || complexIDNode.Edges.Count == 0)
{
#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)
{
throw new FunctionDoesNotExistException(fcn.FuncName);
}
FuncParameter pResult = fcn.Function.ExecFunc(null, null, null, myGraphDB, mySecurityToken, myTransactionToken);
//simpleValue = new AtomValue(fcn.Function.TypeOfResult, ((FuncParameter)pResult.Value).Value); //the new simple value extraced from the function
simpleValue = new ValueDefinition(((FuncParameter)pResult).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 VertexAttributeIsNotDefinedException(complexIDNode.UndefinedAttribute);
}
simpleValue = GetCorrectValueDefinition(complexIDNode.LastAttribute, complexIDNode.LastType, ((ValueDefinition)mySimpleValue));
}
catch (FormatException)
{
throw new DataTypeDoesNotMatchException(((IPropertyDefinition)complexIDNode.LastAttribute).BaseType.Name, ((ValueDefinition)mySimpleValue).Value.GetType().Name);
}
}
else
{
if (mySimpleValue is TupleDefinition)
{
((TupleDefinition)mySimpleValue).ConvertToAttributeType(myPluginManager, complexIDNode.LastAttribute, myGraphDB, mySecurityToken, myTransactionToken);
simpleValue = mySimpleValue;
}
}
}
#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)
{
throw new GQLAggregateArgumentException("An aggregate must have exactly one expression.");
}
if (!(((AggregateDefinition)myComplexValue).ChainPartAggregateDefinition.Parameters[0] is IDChainDefinition))
{
throw new GQLAggregateArgumentException("An aggregate must have exactly one IDNode.");
}
#region Data
complexIDNode = (((AggregateDefinition)myComplexValue).ChainPartAggregateDefinition.Parameters[0] as IDChainDefinition);
if (complexIDNode == null)
{
throw new InvalidIDNodeException("Only single IDNodes are currently allowed in aggregates!");
}
#endregion
#region values
simpleValue = mySimpleValue;
extraordinaryValue = myComplexValue;
#endregion
}
else
{
throw new AggregateNotAllowedException(((AggregateDefinition)myComplexValue).ChainPartAggregateDefinition.Aggregate.PluginShortName);
}
#endregion
}
else
{
throw new NotImplementedQLException("");
}
#endregion
return new DataContainer(new Tuple<IDChainDefinition, IDChainDefinition>(complexIDNode, null), new Tuple<AExpressionDefinition, AExpressionDefinition>(simpleValue, complexValue), new Tuple<AExpressionDefinition, AExpressionDefinition>(extraordinaryValue, null));
}
private bool CheckIDNode(AExpressionDefinition myPotentialIDNode, Dictionary<string, string> attributes)
{
if (myPotentialIDNode is IDChainDefinition)
{
var chainDefinition = (myPotentialIDNode as IDChainDefinition);
if (chainDefinition.Level == 0)
{
if (attributes.ContainsKey(chainDefinition.LastAttribute.Name))
{
return true;
}
else
{
return false;
}
}
else
{
throw new NotImplementedException();
}
}
else
{
return false;
}
}
private Boolean EvaluateHaving(IVertexView myDBObjectReadoutGroup, AExpressionDefinition complexValue, out String attributeName, out ValueDefinition simpleValue)
{
//VertexType graphDBType = null;
attributeName = null;
simpleValue = null;
if (complexValue is IDChainDefinition)
{
if (((IDChainDefinition)complexValue).LastAttribute == null)
{
if (((IDChainDefinition)complexValue).Last() is ChainPartFuncDefinition)
{
var func = (((IDChainDefinition)complexValue).Last() as ChainPartFuncDefinition);
if (func.Parameters.Count != 1)
{
throw new NotImplementedQLException("");
}
attributeName = func.SourceParsedString;
//graphDBType = func.Parameters.First().LastAttribute.GetDBType(dbContext.DBTypeManager);
}
else if (((IDChainDefinition)complexValue).IsUndefinedAttribute)
{
attributeName = ((IDChainDefinition)complexValue).UndefinedAttribute;
//return new Exceptional<bool>(new Error_NotImplemented(new System.Diagnostics.StackTrace(true)));
}
else
{
//return new Exceptional<bool>(new Error_NotImplemented(new System.Diagnostics.StackTrace(true)));
}
}
else
{
attributeName = ((IDChainDefinition)complexValue).LastAttribute.Name;
//graphDBType = ((IDChainDefinition)complexValue).LastAttribute.GetDBType(dbContext.DBTypeManager);
}
}
else
{
if (complexValue is AggregateDefinition)
{
var func = (complexValue as AggregateDefinition);
if (func.ChainPartAggregateDefinition.Parameters.Count != 1)
throw new NotImplementedQLException("");
attributeName = func.ChainPartAggregateDefinition.SourceParsedString;
//graphDBType = func.ContainingIDNodes.First().LastAttribute.GetDBType(dbContext.DBTypeManager);
}
else
{
throw new NotImplementedQLException("");
}
}
if (myDBObjectReadoutGroup.HasProperty(attributeName))
{
simpleValue = new ValueDefinition(myDBObjectReadoutGroup.GetProperty<Object>(attributeName));
return true;
}
return false;
}
/// <summary>
///
/// </summary>
/// <param name="myAExpressionDefinition"></param>
/// <returns></returns>
private AOperationDefinition TryGetOperationValue(AExpressionDefinition myAExpressionDefinition)
{
#region data
var expression = myAExpressionDefinition as BinaryExpressionDefinition;
#endregion
if (expression == null)
{
return null;
}
if (expression.TypeOfBinaryExpression == TypesOfBinaryExpression.Atom)
{
return expression.ResultValue;
}
if (expression.ResultValue != null)
{
return expression.ResultValue;
}
return null;
}
public TupleElement(AExpressionDefinition Value)
{
_Value = Value;
Parameters = new Dictionary <String, object>();
}
/// <summary>
/// Validates the expression (Set the TypeOfBinaryExpression, do some simplifications and validates all IDChains)
/// </summary>
public void Validate(GQLPluginManager myPluginManager,
IGraphDB myGraphDB,
SecurityToken mySecurityToken,
Int64 myTransactionToken,
params IVertexType[] types)
{
if (IsValidated)
{
return;
}
Operator = GetOperatorBySymbol(_OperatorSymbol);
#region Left - Valid TypesOfBinaryExpression are RightComplex (left is atom) or LeftComplex (left is complex)
if (_Left is ValueDefinition)
{
TypeOfBinaryExpression = TypesOfBinaryExpression.RightComplex;
}
else if (_Left is IDChainDefinition)
{
(_Left as IDChainDefinition).Validate(myPluginManager, myGraphDB, mySecurityToken, myTransactionToken, true, types);
TypeOfBinaryExpression = TypesOfBinaryExpression.LeftComplex;
}
else if (_Left is TupleDefinition)
{
#region TupleDefinition
if (IsEncapsulatedBinaryExpression(_Left as TupleDefinition))
{
_Left = TryGetBinexpression((_Left as TupleDefinition).First().Value, myPluginManager, myGraphDB, mySecurityToken, myTransactionToken, types);
TypeOfBinaryExpression = TypesOfBinaryExpression.LeftComplex;
}
else
{
_Left = AssignCorrectTuple(myPluginManager, (_Left as TupleDefinition), Operator, myGraphDB, mySecurityToken, myTransactionToken);
TypeOfBinaryExpression = TypesOfBinaryExpression.RightComplex;
}
#endregion
}
else if (_Left is AggregateDefinition)
{
TypeOfBinaryExpression = TypesOfBinaryExpression.LeftComplex;
}
else if (_Left is UnaryExpressionDefinition)
{
TypeOfBinaryExpression = TypesOfBinaryExpression.LeftComplex;
_Left = (_Left as UnaryExpressionDefinition).GetBinaryExpression(myPluginManager, myGraphDB, mySecurityToken, myTransactionToken);
}
else
{
#region try binexpr
_Left = TryGetBinexpression(_Left, myPluginManager, myGraphDB, mySecurityToken, myTransactionToken, types);
TypeOfBinaryExpression = TypesOfBinaryExpression.LeftComplex;
#endregion
}
#endregion
#region Right
if (_Right is ValueDefinition)
{
if (TypeOfBinaryExpression == TypesOfBinaryExpression.RightComplex)
{
TypeOfBinaryExpression = TypesOfBinaryExpression.Atom;
}
}
else if (_Right is IDChainDefinition)
{
(_Right as IDChainDefinition).Validate(myPluginManager, myGraphDB, mySecurityToken, myTransactionToken, false, types);
if (TypeOfBinaryExpression == TypesOfBinaryExpression.LeftComplex)
{
TypeOfBinaryExpression = TypesOfBinaryExpression.Complex;
}
}
else if (_Right is UnaryExpressionDefinition)
{
if (TypeOfBinaryExpression == TypesOfBinaryExpression.LeftComplex)
{
TypeOfBinaryExpression = TypesOfBinaryExpression.Complex;
}
_Right = (_Right as UnaryExpressionDefinition).GetBinaryExpression(myPluginManager, myGraphDB, mySecurityToken, myTransactionToken);
}
else if (_Right is TupleDefinition)
{
#region TupleDefinition
if (IsEncapsulatedBinaryExpression(_Right as TupleDefinition))
{
_Right = TryGetBinexpression((_Right as TupleDefinition).First().Value, myPluginManager, myGraphDB, mySecurityToken, myTransactionToken, types);
if (TypeOfBinaryExpression == TypesOfBinaryExpression.LeftComplex)
{
TypeOfBinaryExpression = TypesOfBinaryExpression.Complex;
}
}
else
{
_Right = AssignCorrectTuple(myPluginManager, (_Right as TupleDefinition), Operator, myGraphDB, mySecurityToken, myTransactionToken);
if (TypeOfBinaryExpression == TypesOfBinaryExpression.RightComplex)
{
TypeOfBinaryExpression = TypesOfBinaryExpression.Atom;
}
}
#endregion
}
else if (_Right is AggregateDefinition)
{
if (TypeOfBinaryExpression == TypesOfBinaryExpression.LeftComplex)
{
TypeOfBinaryExpression = TypesOfBinaryExpression.Complex;
}
}
else
{
#region try binexpr
_Right = TryGetBinexpression(_Right, myPluginManager, myGraphDB, mySecurityToken, myTransactionToken, types);
if (TypeOfBinaryExpression == TypesOfBinaryExpression.LeftComplex)
{
TypeOfBinaryExpression = TypesOfBinaryExpression.Complex;
}
#endregion
}
#endregion
#region try to get values from complex expr
AOperationDefinition leftTemp;
AOperationDefinition rightTemp;
switch (TypeOfBinaryExpression)
{
case TypesOfBinaryExpression.Atom:
break;
case TypesOfBinaryExpression.LeftComplex:
#region leftComplex
leftTemp = TryGetOperationValue(_Left);
if (leftTemp != null)
{
TypeOfBinaryExpression = TypesOfBinaryExpression.Atom;
_Left = leftTemp;
}
#endregion
break;
case TypesOfBinaryExpression.RightComplex:
#region rightComplex
rightTemp = TryGetOperationValue(_Right);
if (rightTemp != null)
{
TypeOfBinaryExpression = TypesOfBinaryExpression.Atom;
_Right = rightTemp;
}
#endregion
break;
case TypesOfBinaryExpression.Complex:
#region complex
leftTemp = TryGetOperationValue(_Left);
rightTemp = TryGetOperationValue(_Right);
if ((leftTemp != null) && (rightTemp != null))
{
TypeOfBinaryExpression = TypesOfBinaryExpression.Atom;
_Left = leftTemp;
_Right = rightTemp;
}
else
{
if (leftTemp != null)
{
TypeOfBinaryExpression = TypesOfBinaryExpression.RightComplex;
_Left = leftTemp;
}
else if (rightTemp != null)
{
TypeOfBinaryExpression = TypesOfBinaryExpression.LeftComplex;
_Right = rightTemp;
}
}
#endregion
break;
}
#endregion
#region process values
if (TypeOfBinaryExpression == TypesOfBinaryExpression.Atom)
{
#region atomic values
if ((_Left is AOperationDefinition) && (_Right is AOperationDefinition))
{
//ResultValue = Operator.SimpleOperation(((AOperationDefinition)_Left), ((AOperationDefinition)_Right), TypeOfBinaryExpression);
}
#endregion
}
#endregion
if ((Operator == BinaryOperator.AND && ExpressionIndex != null)
|| (Operator == BinaryOperator.OR && ExpressionIndex != null))
{
throw new InvalidBinaryExpressionIndexException(this);
}
_isValidated = true;
}
public UnaryExpressionDefinition(string myOperatorSymbol, AExpressionDefinition myExpression)
{
_OperatorSymbol = myOperatorSymbol;
_Expression = myExpression;
}
private static IExpression GenerateLiteral(AExpressionDefinition aExpressionDefinition, Type myTypeOfLiteral)
{
if (aExpressionDefinition is ValueDefinition)
{
if (myTypeOfLiteral.IsSubclassOf(typeof(AUserdefinedDataType)))
{
try
{
var userdefInstance = (AUserdefinedDataType)Activator.CreateInstance(myTypeOfLiteral, new object[] { (((ValueDefinition)aExpressionDefinition).Value.ConvertToIComparable(typeof(String))) });
return new SingleLiteralExpression((IComparable)userdefInstance.Value);
}
catch(Exception e)
{
throw new UnknownException(e);
}
}
else
{
return new SingleLiteralExpression(((ValueDefinition)aExpressionDefinition).Value.ConvertToIComparable(myTypeOfLiteral));
}
}
else
{
throw new NotImplementedQLException("TODO");
}
}
private Boolean EvaluateHaving(IVertexView myDBObjectReadoutGroup, AExpressionDefinition complexValue, out String attributeName, out ValueDefinition simpleValue)
{
//VertexType graphDBType = null;
attributeName = null;
simpleValue = null;
if (complexValue is IDChainDefinition)
{
if (((IDChainDefinition)complexValue).LastAttribute == null)
{
if (((IDChainDefinition)complexValue).Last() is ChainPartFuncDefinition)
{
var func = (((IDChainDefinition)complexValue).Last() as ChainPartFuncDefinition);
if (func.Parameters.Count != 1)
{
throw new NotImplementedQLException("");
}
attributeName = func.SourceParsedString;
//graphDBType = func.Parameters.First().LastAttribute.GetDBType(dbContext.DBTypeManager);
}
else if (((IDChainDefinition)complexValue).IsUndefinedAttribute)
{
attributeName = ((IDChainDefinition)complexValue).UndefinedAttribute;
//return new Exceptional<bool>(new Error_NotImplemented(new System.Diagnostics.StackTrace(true)));
}
else
{
//return new Exceptional<bool>(new Error_NotImplemented(new System.Diagnostics.StackTrace(true)));
}
}
else
{
attributeName = ((IDChainDefinition)complexValue).LastAttribute.Name;
//graphDBType = ((IDChainDefinition)complexValue).LastAttribute.GetDBType(dbContext.DBTypeManager);
}
}
else
{
if (complexValue is AggregateDefinition)
{
var func = (complexValue as AggregateDefinition);
if (func.ChainPartAggregateDefinition.Parameters.Count != 1)
{
throw new NotImplementedQLException("");
}
attributeName = func.ChainPartAggregateDefinition.SourceParsedString;
//graphDBType = func.ContainingIDNodes.First().LastAttribute.GetDBType(dbContext.DBTypeManager);
}
else
{
throw new NotImplementedQLException("");
}
}
if (myDBObjectReadoutGroup.HasProperty(attributeName))
{
simpleValue = new ValueDefinition(myDBObjectReadoutGroup.GetProperty <Object>(attributeName));
return(true);
}
return(false);
}
private AExpressionDefinition TryGetBinexpression(AExpressionDefinition expression,
GQLPluginManager myPluginManager,
IGraphDB myGraphDB,
SecurityToken mySecurityToken,
Int64 myTransactionToken,
params IVertexType[] types)
{
if (expression is BinaryExpressionDefinition)
{
(expression as BinaryExpressionDefinition).Validate(myPluginManager, myGraphDB, mySecurityToken, myTransactionToken, types);
return expression as BinaryExpressionDefinition;
}
else
{
//for negative values like -U.Age
if (expression is UnaryExpressionDefinition)
{
var binExpr = (expression as UnaryExpressionDefinition).GetBinaryExpression(myPluginManager, myGraphDB, mySecurityToken, myTransactionToken);
return binExpr;
}
else
{
if (expression is TupleDefinition)
{
return TryGetBinexpression(((TupleDefinition)expression).First().Value, myPluginManager, myGraphDB, mySecurityToken, myTransactionToken);
}
}
}
throw new NotImplementedQLException("");
}
public UnaryExpressionDefinition(string myOperatorSymbol, AExpressionDefinition myExpression)
{
_OperatorSymbol = myOperatorSymbol;
_Expression = myExpression;
}
