public void GetContent(CompilerContext context, ParseTreeNode parseNode)
{
if (!parseNode.HasChildNodes())
{
return;
}
#region Static select
if (parseNode.ChildNodes[0].Token.AsSymbol == GetGraphQLGrammar(context).S_EQUALS)
{
ValueAssignment = new SelectValueAssignment(SelectValueAssignment.ValueAssignmentTypes.Always, new ValueDefinition(parseNode.ChildNodes[1].Token.Value));
//ValueAssignment = new Tuple<ValueAssignmentType, object>(ValueAssignmentType.Always, parseNode.ChildNodes[2].Token.Value);
}
else
{
ValueAssignment = new SelectValueAssignment(SelectValueAssignment.ValueAssignmentTypes.IfNotExists, new ValueDefinition(parseNode.ChildNodes[1].Token.Value));
//ValueAssignment = new Tuple<ValueAssignmentType, object>(ValueAssignmentType.IfNotExists, parseNode.ChildNodes[2].Token.Value);
}
#endregion
}
private void GetContent(CompilerContext context, ParseTreeNode parseNode)
{
if (parseNode.ChildNodes[0].Token != null)
{
if (parseNode.ChildNodes[0].Token.Text == DBConstants.ASTERISKSYMBOL)
{
SelType = TypesOfSelect.Asterisk;
}
else if (parseNode.ChildNodes[0].Token.Text == DBConstants.RHOMBSYMBOL)
{
SelType = TypesOfSelect.Rhomb;
}
else if (parseNode.ChildNodes[0].Token.Text == DBConstants.MINUSSYMBOL)
{
SelType = TypesOfSelect.Minus;
}
else if (parseNode.ChildNodes[0].Token.Text == DBConstants.Comperator_Greater)
{
SelType = TypesOfSelect.Gt;
}
else if (parseNode.ChildNodes[0].Token.Text == DBConstants.Comperator_Smaller)
{
SelType = TypesOfSelect.Lt;
}
else
{
throw new GraphDBException(new Error_NotImplemented(new System.Diagnostics.StackTrace(true), parseNode.ChildNodes[0].Token.Text));
}
}
else if (parseNode.ChildNodes[0].AstNode is SelByTypeNode)
{
SelType = TypesOfSelect.Ad;
TypeName = ((SelByTypeNode)parseNode.ChildNodes[0].AstNode).TypeName;
}
else
{
#region IDNode or AggregateNode
SelType = TypesOfSelect.None;
object astNode = parseNode.ChildNodes[0].AstNode;
if (astNode == null)
{
// why the hack are functions without a caller in the child/child?
if (parseNode.ChildNodes[0].HasChildNodes() && parseNode.ChildNodes[0].ChildNodes[0].AstNode != null)
{
astNode = parseNode.ChildNodes[0].ChildNodes[0].AstNode;
}
else
{
if (parseNode.ChildNodes[0].HasChildNodes())
{
throw new ArgumentException("This is not a valid IDNode: " + (parseNode.ChildNodes[0].ChildNodes.Aggregate("", (result, elem) => { result += elem.Token.Text + "."; return result; })));
}
else
{
throw new ArgumentException("Found an invalid IDNode");
}
}
}
if (astNode is IDNode)
{
IDNode aIDNode = astNode as IDNode;
#region ID
TypeOfColumnSource = TypesOfColumnSource.ID;
#region get value
ColumnSourceValue = ((IDNode)aIDNode).IDChainDefinition;
#endregion
#region Alias handling
if (parseNode.ChildNodes.Count > 2)// && parseNode.ChildNodes.Last().AstNode is AliasNode)
{
AliasId = parseNode.ChildNodes[3].Token.ValueString; //(parseNode.ChildNodes.Last().AstNode as AliasNode).AliasId;
}
#endregion
#endregion
}
else if (astNode is AggregateNode)
{
#region aggregate
TypeOfColumnSource = TypesOfColumnSource.Aggregate;
AggregateNode aAggregateNode = (AggregateNode)astNode;
ColumnSourceValue = aAggregateNode.AggregateDefinition;
#endregion
#region Alias handling
if (parseNode.ChildNodes.Count > 1)//Last().AstNode is AliasNode)
{
AliasId = parseNode.ChildNodes[2].Token.ValueString;//(parseNode.ChildNodes.Last().AstNode as AliasNode).AliasId;
}
else
{
AliasId = aAggregateNode.AggregateDefinition.ChainPartAggregateDefinition.SourceParsedString;
}
#endregion
}
else
{
throw new GraphDBException(new Error_NotImplemented(new System.Diagnostics.StackTrace(true), parseNode.ChildNodes[0].AstNode.GetType().Name));
}
#endregion
if (parseNode.ChildNodes.Count > 1)
{
#region SelectValueAssignmentNode
if (parseNode.ChildNodes[1].AstNode is SelectValueAssignmentNode)
{
ValueAssignment = (parseNode.ChildNodes[1].AstNode as SelectValueAssignmentNode).ValueAssignment;
//ValueAssignment = new Tuple<ValueAssignmentType, object>(ValueAssignmentType.Always, parseNode.ChildNodes[2].Token.Value);
}
#endregion
}
}
}
/// <summary>
/// Single IDNode selection attribute
/// </summary>
/// <param name="myReference"></param>
/// <param name="myAlias"></param>
/// <param name="myAStructureNode"></param>
/// <param name="myGraphType"></param>
public Exceptional AddElementToSelection(string myAlias, String myReference, IDChainDefinition myIDChainDefinition, Boolean myIsGroupedOrAggregated, SelectValueAssignment mySelectValueAssignment = null)
{
SelectionElement lastElem = null;
var curLevel = new EdgeList();
EdgeList preLevel = null;
if (myReference != null && _Selections.ContainsKey(myReference) && _Selections[myReference].Any(kv => kv.Value.Any(se => se.RelatedIDChainDefinition == myIDChainDefinition && se.Alias == myAlias)))
{
return new Exceptional(new Error_DuplicateAttributeSelection(myAlias));
}
foreach (var nodeEdgeKey in myIDChainDefinition)
{
if (nodeEdgeKey is ChainPartTypeOrAttributeDefinition)
{
#region Usual attribute
preLevel = null;
var selElem = new SelectionElement(myAlias, curLevel, myIsGroupedOrAggregated, myIDChainDefinition);
var typeOrAttr = (nodeEdgeKey as ChainPartTypeOrAttributeDefinition);
if (true || typeOrAttr.DBType != null && typeOrAttr.TypeAttribute != null)
{
#region defined
var edgeKey = typeOrAttr.EdgeKey;
selElem.Element = typeOrAttr.TypeAttribute; //_DBContext.DBTypeManager.GetTypeAttributeByEdge(edgeKey);
if (String.IsNullOrEmpty(selElem.Alias) || (nodeEdgeKey.Next != null && !(nodeEdgeKey.Next is ChainPartFuncDefinition)))
{
selElem.Alias = typeOrAttr.TypeAttribute.Name;//_DBContext.DBTypeManager.GetTypeAttributeByEdge(edgeKey).Name;
}
curLevel += edgeKey;
preLevel = curLevel.GetPredecessorLevel();
#endregion
}
else
{
#region undefined attribute
if (myIDChainDefinition.Level == 0)
{
preLevel = new EdgeList(myIDChainDefinition.LastType.UUID);
}
else
{
var element = _Selections[myReference].Last();
preLevel = curLevel.GetPredecessorLevel();
//preLevel = curLevel;
}
selElem.Alias = typeOrAttr.TypeOrAttributeName;
selElem.Element = new UndefinedTypeAttribute(typeOrAttr.TypeOrAttributeName);
#endregion
}
#region Add to _Selections if valid
if (!_Selections.ContainsKey(myReference))
{
_Selections.Add(myReference, new Dictionary<EdgeList, List<SelectionElement>>());
}
if (!_Selections[myReference].ContainsKey(preLevel))
{
_Selections[myReference].Add(preLevel, new List<SelectionElement>());
}
///
/// Duplicate AttributeSelection is: "U.Name, U.Name" or "U.Name.TOUPPER(), U.Name" but not "U.Friends.TOP(1).Name, U.Friends.TOP(1).Age"
if ((nodeEdgeKey.Next == null || (nodeEdgeKey.Next is ChainPartFuncDefinition && nodeEdgeKey.Next.Next == null))
// U.Name, U.Name U.Name.TOUPPER, U.Name
&& _Selections[myReference][preLevel].Exists(item => item.Alias == selElem.Alias && selElem.EdgeList.Level == item.EdgeList.Level && item.RelatedIDChainDefinition.Depth == selElem.RelatedIDChainDefinition.Depth && item.Element != null) && !myIsGroupedOrAggregated)
{
return new Exceptional(new Error_DuplicateAttributeSelection(selElem.Alias));
}
// Do not add again if:
// - it is a defined attribute and there is an asterisk selection at this level
// - it is not the last part AND
// - there is already an item of this part with the same alias and the same Depth
if (nodeEdgeKey.Next == null || _Selections[myReference][preLevel].Count == 0 || _Selections[myReference][preLevel].Any(item => IsNewSelectionElement(item, selElem)))
{
_Selections[myReference][preLevel].Add(selElem);
}
#endregion
lastElem = selElem;
#endregion
}
else if (nodeEdgeKey is ChainPartFuncDefinition)
{
var chainPartFuncDefinition = (nodeEdgeKey as ChainPartFuncDefinition);
#region Function
if (myReference == null)
{
#region Type independent functions
var selElem = new SelectionElement(myAlias, myIDChainDefinition);
if (String.IsNullOrEmpty(selElem.Alias))
{
selElem.Alias = chainPartFuncDefinition.SourceParsedString;
}
var funcElem = new SelectionElementFunction(selElem, chainPartFuncDefinition, chainPartFuncDefinition.Parameters);
if (lastElem is SelectionElementFunction)
{
(lastElem as SelectionElementFunction).AddFollowingFunction(funcElem);
lastElem = funcElem;
}
else
{
if (_SelectionElementsTypeIndependend.Any(se => se.Alias == funcElem.Alias))
{
return new Exceptional(new Error_DuplicateAttributeSelection(funcElem.Alias));
}
_SelectionElementsTypeIndependend.Add(funcElem);
lastElem = funcElem;
}
#endregion
}
else
{
#region Type dependent function
var funcElem = new SelectionElementFunction(lastElem, (nodeEdgeKey as ChainPartFuncDefinition), (nodeEdgeKey as ChainPartFuncDefinition).Parameters);
funcElem.RelatedIDChainDefinition = myIDChainDefinition;
if (!String.IsNullOrEmpty(myAlias) && nodeEdgeKey.Next == null)
{
funcElem.Alias = myAlias;
}
if (lastElem is SelectionElementFunction)
{
(lastElem as SelectionElementFunction).AddFollowingFunction(funcElem);
lastElem = funcElem;
}
else if (_Selections[myReference][preLevel].Contains(lastElem))
{
#region Add function to the last selection element (replace it)
_Selections[myReference][preLevel].Remove(lastElem);
//lastElem = new SelectionElementFunction(lastElem, (nodeEdgeKey as ChainPartFuncDefinition), (nodeEdgeKey as ChainPartFuncDefinition).Parameters);
//lastElem.RelatedIDChainDefinition = myIDChainDefinition;
//if (!String.IsNullOrEmpty(alias) && nodeEdgeKey.Next == null)
//{
// lastElem.Alias = alias;
//}
lastElem = funcElem;
if (!_Selections[myReference][preLevel].Contains(lastElem)) // In case this Element with func is already in the selection list do nothing.
{
_Selections[myReference][preLevel].Add(lastElem);
}
#endregion
}
else if (!_Selections[myReference][preLevel].Contains(funcElem))
{
#region In this case we have a similar function but NOT THE SAME. Since we don't know what to do, return error.
return new Exceptional(new Error_InvalidAttributeSelection(myIDChainDefinition.ContentString));
#endregion
}
#endregion
}
#endregion
}
}
#region Set the SelectValueAssignment for the last element
if (lastElem != null && mySelectValueAssignment != null)
{
#region Error handling
System.Diagnostics.Debug.Assert(lastElem.Element != null);
if (lastElem.Element.IsUserDefinedType(_DBContext.DBTypeManager))
{
return new Exceptional(new Error_InvalidSelectValueAssignment(lastElem.Element.Name));
}
if (!(mySelectValueAssignment.TermDefinition is ValueDefinition))
{
return new Exceptional(new Error_NotImplemented(new System.Diagnostics.StackTrace(true)));
}
#endregion
#region Validate datatype if the attribute is a defined attribute
if (!(lastElem.Element is UndefinedTypeAttribute))
{
if (!lastElem.Element.GetADBBaseObjectType(_DBContext.DBTypeManager).IsValidValue((mySelectValueAssignment.TermDefinition as ValueDefinition).Value.Value))
{
return new Exceptional(new Error_SelectValueAssignmentDataTypeDoesNotMatch(lastElem.Element.GetADBBaseObjectType(_DBContext.DBTypeManager).ObjectName, (mySelectValueAssignment.TermDefinition as ValueDefinition).Value.ObjectName));
}
var typedValue = new ValueDefinition(lastElem.Element.GetADBBaseObjectType(_DBContext.DBTypeManager).Clone((mySelectValueAssignment.TermDefinition as ValueDefinition).Value.Value));
mySelectValueAssignment.TermDefinition = typedValue;
}
#endregion
lastElem.SelectValueAssignment = mySelectValueAssignment;
}
#endregion
return Exceptional.OK;
}
