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; } } }