public void GetContent(CompilerContext context, ParseTreeNode parseNode)
{
if (parseNode.HasChildNodes())
{
ParallelTasks = Convert.ToUInt32(parseNode.ChildNodes[1].Token.Value);
}
}
public void GetContent(CompilerContext context, ParseTreeNode parseNode)
{
var _GraphQL = GetGraphQLGrammar(context);
if (parseNode.HasChildNodes())
{
var _Terminal = parseNode.ChildNodes[0].Token.Terminal;
if (_Terminal == _GraphQL.S_ALL)
{
DumpType = DumpTypes.GDDL | DumpTypes.GDML;
}
else if (_Terminal == _GraphQL.S_GDDL)
{
DumpType = DumpTypes.GDDL;
}
else if (_Terminal == _GraphQL.S_GDML)
{
DumpType = DumpTypes.GDML;
}
else
{
throw new GraphDBException(new Errors.Error_InvalidDumpType(_Terminal.DisplayName));
}
}
else
{
DumpType = DumpTypes.GDDL | DumpTypes.GDML;
}
}
private void GetContent(CompilerContext context, ParseTreeNode parseNode)
{
if (parseNode.HasChildNodes())
{
if (parseNode.ChildNodes[3] != null && parseNode.ChildNodes[3].HasChildNodes() && parseNode.ChildNodes[3].ChildNodes[0].Term.Name.ToUpper() == "DESC")
_OrderDirection = SortDirection.Desc;
else
_OrderDirection = SortDirection.Asc;
_OrderByAttributeList = new List<OrderByAttributeDefinition>();
foreach (ParseTreeNode treeNode in parseNode.ChildNodes[2].ChildNodes)
{
if (treeNode.AstNode != null && treeNode.AstNode is IDNode)
{
_OrderByAttributeList.Add(new OrderByAttributeDefinition(((IDNode)treeNode.AstNode).IDChainDefinition, null));
}
else
{
_OrderByAttributeList.Add(new OrderByAttributeDefinition(null, treeNode.Token.ValueString));
}
}
OrderByDefinition = new OrderByDefinition(_OrderDirection, _OrderByAttributeList);
}
}
public void GetContent(CompilerContext context, ParseTreeNode parseNode)
{
TypesSettingScope? settingType;
if (parseNode.HasChildNodes() && (parseNode.ChildNodes.Count >= 2))
{
switch (parseNode.ChildNodes[1].Token.Text.ToUpper())
{
case "TYPE":
settingType = TypesSettingScope.TYPE;
_DescribeSettingDefinition = new DescribeSettingDefinition(settingType, myTypeName: (parseNode.ChildNodes[2].ChildNodes[0].AstNode as ATypeNode).ReferenceAndType.TypeName);
break;
case "ATTRIBUTE":
settingType = TypesSettingScope.ATTRIBUTE;
_DescribeSettingDefinition = new DescribeSettingDefinition(settingType, myIDChain: (parseNode.ChildNodes[2].ChildNodes[2].AstNode as IDNode).IDChainDefinition);
break;
case "DB":
settingType = TypesSettingScope.DB;
_DescribeSettingDefinition = new DescribeSettingDefinition(settingType);
break;
case "SESSION":
settingType = TypesSettingScope.SESSION;
_DescribeSettingDefinition = new DescribeSettingDefinition(settingType);
break;
default:
settingType = null;
_DescribeSettingDefinition = new DescribeSettingDefinition(settingType);
break;
}
}
}
/// <summary>
/// This handles the Where Expression Node with all the
/// </summary>
/// <param name="context"></param>
/// <param name="parseNode"></param>
/// <param name="typeManager"></param>
public void GetContent(CompilerContext context, ParseTreeNode parseNode)
{
if (parseNode.HasChildNodes())
{
BinExprNode = (BinaryExpressionNode)parseNode.ChildNodes[1].AstNode;
}
}
public void GetContent(CompilerContext context, ParseTreeNode parseNode)
{
if (parseNode.HasChildNodes())
{
_DescrAggrDefinition = new DescribeAggregateDefinition(parseNode.ChildNodes[1].Token.ValueString.ToUpper());
}
}
public override void GetContent(CompilerContext context, ParseTreeNode parseNode)
{
if (parseNode.HasChildNodes())
{
//get type
if (parseNode.ChildNodes[1] != null && parseNode.ChildNodes[1].AstNode != null)
{
_Type = ((ATypeNode)(parseNode.ChildNodes[1].AstNode)).ReferenceAndType.TypeName;
}
else
{
throw new GraphDBException(new Error_NotImplemented(new System.Diagnostics.StackTrace(true)));
}
if (parseNode.ChildNodes[3] != null && parseNode.ChildNodes[3].HasChildNodes())
{
_AttributeAssignList = new List<AAttributeAssignOrUpdate>((parseNode.ChildNodes[3].AstNode as AttrUpdateOrAssignListNode).ListOfUpdate.Select(e => e as AAttributeAssignOrUpdate));
}
if (parseNode.ChildNodes[4] != null && ((WhereExpressionNode)parseNode.ChildNodes[4].AstNode).BinaryExpressionDefinition != null)
{
_WhereExpression = ((WhereExpressionNode)parseNode.ChildNodes[4].AstNode).BinaryExpressionDefinition;
}
}
}
private void GetContent(CompilerContext myCompilerContext, ParseTreeNode myParseTreeNode)
{
if (myParseTreeNode.HasChildNodes())
_IsUnique = true;
else
_IsUnique = false;
}
private void GetContent(CompilerContext context, ParseTreeNode parseNode)
{
_Shards = null;
if (parseNode.HasChildNodes())
{
_Shards = UInt16.Parse(parseNode.ChildNodes[1].Token.ValueString);
}
}
public void GetContent(CompilerContext context, ParseTreeNode parseNode)
{
var verbosityType = VerbosityType;
if (parseNode.HasChildNodes() && Enum.TryParse<VerbosityTypes>(parseNode.ChildNodes[1].Token.Text, true, out verbosityType))
{
VerbosityType = verbosityType;
}
}
private void GetContent(CompilerContext context, ParseTreeNode parseNode)
{
if (parseNode.HasChildNodes())
{
IndexType = parseNode.ChildNodes[1].Token.ValueString;
}
}
public void GetContent(CompilerContext context, ParseTreeNode parseNode)
{
if (parseNode.HasChildNodes())
{
foreach (var child in (parseNode.ChildNodes[1].AstNode as TupleNode).TupleDefinition)
{
Comments.Add((child.Value as ValueDefinition).Value.ToString());
}
}
}
private void GetContent(CompilerContext context, ParseTreeNode parseNode)
{
if (parseNode.HasChildNodes())
{
if (parseNode.ChildNodes[1] != null)
{
Count = Convert.ToUInt64(parseNode.ChildNodes[1].Token.Value);
}
}
}
private void GetContent(CompilerContext context, ParseTreeNode parseNode)
{
if (parseNode.HasChildNodes())
{
if (parseNode.ChildNodes[1].Token.ValueString.ToLower() == "graph")
_SelectOutputType = SelectOutputTypes.Graph;
else
_SelectOutputType = SelectOutputTypes.Tree;
}
}
private void GetContent(CompilerContext context, ParseTreeNode parseNode)
{
if (!parseNode.HasChildNodes())
return;
IsSorted = true;
if (parseNode.ChildNodes.Count == 3 && parseNode.ChildNodes[2].Token.Text.ToUpper() == GraphQL.GraphQueryLanguage.TERMINAL_DESC)
SortDirection = SortDirection.Desc;
else
SortDirection = SortDirection.Asc;
}
private void GetContent(CompilerContext context, ParseTreeNode parseNode)
{
_ParameterValues = new List<ADBBaseObject>();
if (parseNode.HasChildNodes() && parseNode.ChildNodes[1].HasChildNodes())
{
foreach (var child in parseNode.ChildNodes[1].ChildNodes)
{
_ParameterValues.Add(GraphDBTypeMapper.GetGraphObjectFromTypeName(child.Token.Terminal.GetType().Name, child.Token.Value));
}
}
}
public void GetContent(CompilerContext context, ParseTreeNode parseNode)
{
if (parseNode.HasChildNodes())
{
foreach (var _ParseTreeNode in parseNode.ChildNodes[1].ChildNodes)
{
if (_ParseTreeNode.AstNode as BackwardEdgeNode != null)
{
_BackwardEdgeInformation.Add(((BackwardEdgeNode)_ParseTreeNode.AstNode).BackwardEdgeDefinition);
}
}
}
}
private void GetContent(CompilerContext myCompilerContext, ParseTreeNode myParseTreeNode)
{
if (myParseTreeNode.HasChildNodes())
{
_UniqueAttributes = new List<String>();
if (myParseTreeNode.ChildNodes[1].HasChildNodes())
{
_UniqueAttributes = (from c in myParseTreeNode.ChildNodes[1].ChildNodes select c.Token.ValueString).ToList();
}
}
}
public override void GetContent(CompilerContext context, ParseTreeNode parseNode)
{
if (parseNode.HasChildNodes())
{
_TypeName = ((ATypeNode)(parseNode.ChildNodes[1].AstNode)).ReferenceAndType.TypeName;
if (parseNode.ChildNodes[3] != null && parseNode.ChildNodes[3].HasChildNodes())
{
_AttributeAssignList = (parseNode.ChildNodes[3].AstNode as AttrAssignListNode).AttributeAssigns;
}
_whereExpression = ((BinaryExpressionNode)parseNode.ChildNodes[5].AstNode).BinaryExpressionDefinition;
System.Diagnostics.Debug.Assert(_whereExpression != null);
}
}
public void GetContent(CompilerContext context, ParseTreeNode parseNode)
{
if (parseNode.HasChildNodes())
{
if (parseNode.ChildNodes[1].AstNode is DescribeSettItemNode)
{
_DescribeSettingDefinition = ((DescribeSettItemNode)parseNode.ChildNodes[1].AstNode).DescribeDefinition;
}
if (parseNode.ChildNodes[1].AstNode is DescribeSettingsItemsNode)
{
_DescribeSettingDefinition = ((DescribeSettingsItemsNode)parseNode.ChildNodes[1].AstNode).DescribeDefinition;
}
}
}
public void GetContent(CompilerContext context, ParseTreeNode parseNode)
{
try
{
if (parseNode.HasChildNodes())
{
if (parseNode.ChildNodes[1].HasChildNodes())
{
_MandAttribs = (from Attr in parseNode.ChildNodes[1].ChildNodes select Attr.Token.ValueString).ToList();
}
}
}
catch(Exception ex)
{
throw new GraphDBException(new Error_UnknownDBError(ex));
}
}
public void GetContent(CompilerContext myCompilerContext, ParseTreeNode myParseTreeNode)
{
if (myParseTreeNode == null)
return;
if (myParseTreeNode.HasChildNodes() && myParseTreeNode.ChildNodes[1].HasChildNodes())
{
foreach (var Node in myParseTreeNode.ChildNodes[1].ChildNodes)
{
if (!Types.Contains((Node.AstNode as ATypeNode).ReferenceAndType.TypeName))
{
Types.Add((Node.AstNode as ATypeNode).ReferenceAndType.TypeName);
}
}
}
}
public void GetContent(CompilerContext myCompilerContext, ParseTreeNode myParseTreeNode)
{
if (myParseTreeNode.HasChildNodes())
{
if (myParseTreeNode.ChildNodes[1].AstNode == null)
{
throw new GraphDBException(new Error_NotImplemented(new System.Diagnostics.StackTrace(true)));
}
_OperatorSymbol = myParseTreeNode.ChildNodes[0].Token.Text;
Expression = GetExpressionDefinition(myParseTreeNode.ChildNodes[1]);
}
System.Diagnostics.Debug.Assert(Expression != null);
UnaryExpressionDefinition = new UnaryExpressionDefinition(_OperatorSymbol, Expression);
}
public void GetContent(CompilerContext context, ParseTreeNode parseNode)
{
if (parseNode.HasChildNodes())
{
if (parseNode.ChildNodes.Count >= 3)
{
IBaseEdge ListOfDefaults;
var firstListObject = GraphDBTypeMapper.GetBaseObjectFromCSharpType(parseNode.ChildNodes[2].ChildNodes[0].Token.Value);
if (parseNode.ChildNodes[1].Token.Text.ToUpper() == DBConstants.SETOF)
{
ListOfDefaults = new EdgeTypeSetOfBaseObjects();
}
else if (parseNode.ChildNodes[1].Token.Text.ToUpper() == DBConstants.LISTOF)
{
ListOfDefaults = new EdgeTypeListOfBaseObjects();
}
else
{
throw new GraphDBException(new Error_NotImplemented(new System.Diagnostics.StackTrace(true)));
}
ListOfDefaults.AddRange(parseNode.ChildNodes[2].ChildNodes.Select(item => CheckTypeOfItems(item.Token.Value, firstListObject)));
Value = ListOfDefaults;
}
else
{
var baseObject = GraphDBTypeMapper.GetBaseObjectFromCSharpType(parseNode.ChildNodes[1].Token.Value);
Value = (IObject)baseObject;
}
}
else
{
Value = null;
}
}
public void GetContent(CompilerContext myCompilerContext, ParseTreeNode myParseTreeNode)
{
if (myParseTreeNode.HasChildNodes())
{
if (myParseTreeNode.ChildNodes[1].AstNode is TupleNode && (myParseTreeNode.ChildNodes[1].AstNode as TupleNode).TupleDefinition.TupleElements.Count == 1)
{
var tuple = (myParseTreeNode.ChildNodes[1].AstNode as TupleNode).TupleDefinition.Simplyfy();
BinaryExpressionDefinition = (tuple.TupleElements[0].Value as BinaryExpressionDefinition);
}
else if (myParseTreeNode.ChildNodes[1].AstNode is BinaryExpressionNode)
{
BinaryExpressionDefinition = ((BinaryExpressionNode)myParseTreeNode.ChildNodes[1].AstNode).BinaryExpressionDefinition;
}
//else
//{
// throw new GraphDBException(new Errors.Error_GqlSyntax("Invalid tuple for where expression"));
//}
}
}
private void GetContent(CompilerContext context, ParseTreeNode parseNode)
{
ParamType type = ParamType.Value;
Object param = null;
if (parseNode.HasChildNodes())
{
if (parseNode.ChildNodes[0].AstNode is DefaultValueDefNode)
{
param = (parseNode.ChildNodes[0].AstNode as DefaultValueDefNode).Value;
type = ParamType.DefaultValueDef;
}
else if (parseNode.ChildNodes[0].AstNode is EdgeType_SortedNode)
{
param = (parseNode.ChildNodes[0].AstNode as EdgeType_SortedNode).SortDirection;
type = ParamType.Sort;
}
else
{
if (GraphDBTypeMapper.IsBasicType(parseNode.ChildNodes[0].Token.ValueString))
{
param = GraphDBTypeMapper.GetGraphObjectFromTypeName(parseNode.ChildNodes[0].Token.ValueString);
type = ParamType.GraphType;
}
else
{
param = parseNode.ChildNodes[0].Token.Value;
type = ParamType.Value;
}
}
EdgeTypeParamDefinition = new EdgeTypeParamDefinition(type, param);
}
}
public void GetContent(CompilerContext myCompilerContext, ParseTreeNode myParseTreeNode)
{
if (myParseTreeNode.HasChildNodes())
{
foreach (var child in myParseTreeNode.ChildNodes)
{
if (child.AstNode is ATypeNode)
{
var tr = (child.AstNode as ATypeNode).ReferenceAndType;
if (!Types.Contains(tr))
{
Types.Add(tr);
}
else
{
throw new GraphDBException(new Error_DuplicateReferenceOccurence(tr.TypeName));
}
}
}
}
}
private void GetContent(CompilerContext context, ParseTreeNode parseNode)
{
if (!parseNode.HasChildNodes())
return;
_IsWeighted = true;
if (parseNode.ChildNodes[2].HasChildNodes())
{
String type = ((GraphDBTypeNode)parseNode.ChildNodes[2].AstNode).DBTypeDefinition.Name;
_WeightedValue = (DBNumber)GraphDBTypeMapper.GetGraphObjectFromTypeName(type); //Convert.ToDouble(parseNode.ChildNodes[2].Token.Value);
}
else if (parseNode.ChildNodes.Count == 3)
{
_WeightedValue.SetValue(parseNode.ChildNodes[2].Token.Value);
}
if (parseNode.ChildNodes.Count == 4)
{
_WeightedValue.SetValue(parseNode.ChildNodes[2].Token.Value);
}
}
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.HasChildNodes())
{
switch (parseNode.ChildNodes[0].Token.Text.ToLower())
{
case "drop":
#region drop
if (parseNode.ChildNodes[1].AstNode is IndexDropOnAlterType)
{
var dropNodeExcept = (IndexDropOnAlterType)parseNode.ChildNodes[1].AstNode;
ParsingResult.PushIExceptional(dropNodeExcept.ParsingResult);
AlterTypeCommand = new AlterType_DropIndices(dropNodeExcept.DropIndexList);
break;
}
if (parseNode.ChildNodes.Count == 2 && parseNode.ChildNodes[1].Token.Text.ToLower() == GraphQL.GraphQueryLanguage.TERMINAL_UNIQUE.ToLower())
{
AlterTypeCommand = new AlterType_DropUnique();
break;
}
if (parseNode.ChildNodes.Count == 2 && parseNode.ChildNodes[1].Token.Text.ToUpper() == GraphQL.GraphQueryLanguage.TERMINAL_MANDATORY.ToUpper())
{
AlterTypeCommand = new AlterType_DropMandatory();
break;
}
#region data
List<String> listOfToBeDroppedAttributes = new List<string>();
#endregion
foreach (ParseTreeNode aNode in parseNode.ChildNodes[2].ChildNodes)
{
listOfToBeDroppedAttributes.Add(aNode.Token.ValueString);
}
AlterTypeCommand = new AlterType_DropAttributes(listOfToBeDroppedAttributes);
#endregion
break;
case "add":
#region add
if (parseNode.ChildNodes[1].AstNode is IndexOnCreateTypeNode)
{
#region data
var _IndexInformation = new List<IndexDefinition>();
#endregion
#region add indices
var indexOnCreateTypeNode = (IndexOnCreateTypeNode)parseNode.ChildNodes[1].AstNode;
ParsingResult.PushIExceptional(indexOnCreateTypeNode.ParsingResult);
_IndexInformation.AddRange(indexOnCreateTypeNode.ListOfIndexDefinitions);
AlterTypeCommand = new AlterType_AddIndices(_IndexInformation);
#endregion
}
else
{
#region data
var listOfToBeAddedAttributes = new List<AttributeDefinition>();
var _BackwardEdgeInformation = new List<BackwardEdgeDefinition>();
#endregion
#region add attributes
foreach (ParseTreeNode aNode in parseNode.ChildNodes[2].ChildNodes)
{
if (aNode.AstNode is AttributeDefinitionNode)
{
listOfToBeAddedAttributes.Add(((AttributeDefinitionNode)aNode.AstNode).AttributeDefinition);
}
else if (aNode.AstNode is BackwardEdgeNode)
{
_BackwardEdgeInformation.Add((aNode.AstNode as BackwardEdgeNode).BackwardEdgeDefinition);
}
else
{
throw new NotImplementedException(aNode.AstNode.GetType().ToString());
}
}
AlterTypeCommand = new AlterType_AddAttributes(listOfToBeAddedAttributes, _BackwardEdgeInformation);
#endregion
}
#endregion
break;
case "rename":
#region rename
if (parseNode.ChildNodes.Count > 3)
{
if (parseNode.ChildNodes[1].Token.Text.ToUpper() == "BACKWARDEDGE")
{
AlterTypeCommand = new AlterType_RenameBackwardedge() { OldName = parseNode.ChildNodes[2].Token.ValueString, NewName = parseNode.ChildNodes[4].Token.ValueString };
}
else
{
AlterTypeCommand = new AlterType_RenameAttribute() { OldName = parseNode.ChildNodes[2].Token.ValueString, NewName = parseNode.ChildNodes[4].Token.ValueString };
}
}
else if(parseNode.ChildNodes.Count <= 3)
{
AlterTypeCommand = new AlterType_RenameType() { NewName = parseNode.ChildNodes[2].Token.ValueString };
}
#endregion
break;
case "comment":
#region comment
AlterTypeCommand = new AlterType_ChangeComment() { NewComment = parseNode.ChildNodes[2].Token.ValueString };
#endregion
break;
case "undefine":
#region data
var listOfUndefAttributes = new List<String>();
#endregion
#region undefine attributes
parseNode.ChildNodes[2].ChildNodes.ForEach(node => listOfUndefAttributes.Add(node.Token.ValueString));
AlterTypeCommand = new AlterType_UndefineAttributes(listOfUndefAttributes);
#endregion
break;
case "define":
#region data
var listOfDefinedAttributes = new List<AttributeDefinition>();
#endregion
parseNode.ChildNodes[2].ChildNodes.ForEach(node => listOfDefinedAttributes.Add(((AttributeDefinitionNode)node.AstNode).AttributeDefinition));
AlterTypeCommand = new AlterType_DefineAttributes(listOfDefinedAttributes);
break;
}
}
}
