/// <summary> /// Visits the given SQL node. /// </summary> /// <param name="node">The <see cref="ISqlNode"/> to visit.</param> /// <seealso cref="ISqlNodeVisitor.Visit"/> public virtual void Visit(ISqlNode node) { if (node is IntegerLiteralNode) { VisitIntegerLiteral((IntegerLiteralNode)node); } else if (node is NumberLiteralNode) { VisitNumberLiteral((NumberLiteralNode)node); } else if (node is StringLiteralNode) { VisitStringLiteral((StringLiteralNode)node); } else if (node is DataTypeNode) { VisitDataType((DataTypeNode)node); } else if (node is IExpressionNode) { VisitExpression((IExpressionNode)node); } else if (node is IStatementNode) { VisitStatement((IStatementNode)node); } else if (node is ISqlVisitableNode) { ((ISqlVisitableNode)node).Accept(this); } }
private void GetSizedType(ISqlNode node) { foreach (var childNode in node.ChildNodes) { if (childNode.NodeName == "long_varchar") { TypeName = "LONG VARCHAR"; } else if (childNode is SqlKeyNode) { TypeName = ((SqlKeyNode)childNode).Text; } else if (childNode.NodeName == "datatype_size") { GetDataSize(childNode); } else if (childNode.NodeName == "locale_opt") { GetLocale(childNode); } else if (childNode.NodeName == "encoding_opt") { GetEncoding(childNode); } } }
public static string ToPostgreSqlString(this ISqlNode n) { var sb = new StringBuilder(); new PostgreSql.Stringify.StringifyVisitor(sb).Visit(n); return(sb.ToString()); }
protected override ISqlNode OnChildNode(ISqlNode node) { if (node is TableColumnNode) Column = (TableColumnNode) node; return base.OnChildNode(node); }
internal ISqlNode PrepareParse() { if (!File.Exists(_sqlFilePath)) { throw new InvalidSqlFileException(ExceptionMessageId.EspC001, _sqlFilePath); } var rawSql = File.ReadAllText(_sqlFilePath); if (string.IsNullOrWhiteSpace(rawSql)) { throw new InvalidSqlFileException(ExceptionMessageId.EspC002, _sqlFilePath); } if (_config == null) { throw new InvalidSqlParserConfigException(ExceptionMessageId.EspD001); } if (_config.DbConnectionKind == DbConnectionKind.Unknown) { throw new InvalidSqlParserConfigException(ExceptionMessageId.EspD002); } if (_config.DataParameterCreator == null) { throw new InvalidSqlParserConfigException(ExceptionMessageId.EspD003); } _evaluator = new EasyExpressionEvaluator(_sqlFilePath); ISqlNode sqlNode = null; var hasCache = false; if (ConfigContainer.EnableCache) { if (SqlCache.TryGetValue(_sqlFilePath, out SqlFileInfo info)) { sqlNode = info.SqlNode; hasCache = true; } } if (!hasCache) { var parser = new DomaSqlParser(rawSql); sqlNode = parser.Parse(); if (ConfigContainer.EnableCache) { var info = new SqlFileInfo { FilePath = _sqlFilePath, RawSql = rawSql, SqlNode = sqlNode }; SqlCache.TryAdd(_sqlFilePath, info); } } return(sqlNode); }
protected override ISqlNode OnChildNode(ISqlNode node) { if (node.NodeName == "drop_procedure_trigger") { var idNode = node.FindNode <ObjectNameNode>(); if (idNode == null) { throw new SqlParseException("Could not find the name of the trigger to delete."); } TriggerName = idNode.Name; } else if (node.NodeName == "drop_callback_trigger") { CallbackTrigger = true; var tableNameNode = node.FindNode <ObjectNameNode>(); if (tableNameNode == null) { throw new SqlParseException("Could not find the name of the table in a DROP CALLBACK TRIGGER"); } TableName = tableNameNode.Name; } return(base.OnChildNode(node)); }
private void GetAnyAllOp(ISqlNode node) { var sb = new StringBuilder(); foreach (var childNode in node.ChildNodes) { if (childNode is SqlKeyNode) { var anyOrAll = ((SqlKeyNode)childNode).Text; if (String.Equals(anyOrAll, "ALL", StringComparison.OrdinalIgnoreCase)) { IsAll = true; } else if (String.Equals(anyOrAll, "ANY", StringComparison.OrdinalIgnoreCase)) { IsAny = true; } } else if (childNode.NodeName == "binary_op_simple") { var op = childNode.ChildNodes.First(); sb.Append(((SqlKeyNode)op).Text); } } Operator = sb.ToString(); }
/// <inheritdoc/> protected override ISqlNode OnChildNode(ISqlNode node) { if (node.NodeName == "join_type") { GetJoinType(node); } else if (node is IFromSourceNode) { Source = (IFromSourceNode)node; } else if (node.NodeName == "from_source") { Source = (IFromSourceNode)node.ChildNodes.FirstOrDefault(); } else if (node.NodeName == "on_opt") { OnExpression = node.FindNode <IExpressionNode>(); } else if (node.NodeName == "join_opt") { var join = node.ChildNodes.FirstOrDefault(); if (join != null) { NextJoin = (JoinNode)join; } } return(base.OnChildNode(node)); }
private void AddTableIds(ISqlNode n) { // Identifier is presumed to be table name if (n is SqlIdentifierNode id) { Current.AddSymbol(id.ToString(), new SymbolInfo { OriginalName = id.ToString(), OriginKind = SymbolOriginKind.Environmental, ObjectKind = ObjectKind.TableExpression, DefinedAt = id.Location }); return; } // Object ID is a table name, only use the name of the table as the symbol, not the full qualification if (n is SqlObjectIdentifierNode objId) { Current.AddSymbol(objId.ToString(), new SymbolInfo { OriginalName = objId.ToString(), OriginKind = SymbolOriginKind.Environmental, ObjectKind = ObjectKind.TableExpression, DefinedAt = objId.Location }); return; } if (n is SqlVariableNode variable) { Current.GetInfoOrThrow(variable.Name, n.Location).UsedAsTableExpression(n.Location); return; } }
private void GetWithGrant(ISqlNode node) { if (node.ChildNodes.Any()) { WithGrant = true; } }
private ISqlNode ParseJoin(ITokenizer t) { // <TableExpression> (<JoinOperator> <TableExpression> "ON" <JoinCondition>)? // TODO: <TableExpression> ("WITH" <Hint>)? var tableExpression1 = ParseMaybeAliasedTable(t, ParseTableOrSubexpression); var join = ParseJoinOperator(t); if (join == null) { return(tableExpression1); } var tableExpression2 = ParseMaybeAliasedTable(t, ParseTableOrSubexpression); ISqlNode condition = null; if (join.Operator != "NATURAL JOIN") { // "ON" <BooleanExpression> t.Expect(SqlTokenType.Keyword, "ON"); condition = ParseBooleanExpression(t); } return(new SqlJoinNode { Location = tableExpression1.Location, Left = tableExpression1, Operator = join, Right = tableExpression2, OnCondition = condition }); }
protected override ISqlNode OnChildNode(ISqlNode node) { if (node is IdentifierNode) { CursorName = ((IdentifierNode)node).Text; } else if (node.NodeName.Equals("cursor_args_opt")) { Parameters = node.FindNodes <CursorParameterNode>(); } else if (node is IExpressionNode) { QueryExpression = (SqlQueryExpressionNode)node; } else if (node.NodeName.Equals("insensitive_opt")) { Insensitive = node.ChildNodes.Any(); } else if (node.NodeName.Equals("scroll_opt")) { Scroll = node.ChildNodes.Any(); } return(base.OnChildNode(node)); }
protected override ISqlNode OnChildNode(ISqlNode node) { if (node is SqlKeyNode) { var keyNode = (SqlKeyNode) node; if (String.Equals(keyNode.Text, "NULL", StringComparison.OrdinalIgnoreCase)) { if (notSeen) { ConstraintType = ConstraintTypeNames.NotNull; } else { ConstraintType = ConstraintTypeNames.Null; } } else if (String.Equals(keyNode.Text, "NOT", StringComparison.OrdinalIgnoreCase)) { notSeen = true; } else if (String.Equals(keyNode.Text, "REFERENCES", StringComparison.OrdinalIgnoreCase)) { ConstraintType = ConstraintTypeNames.ForeignKey; } else if (String.Equals(keyNode.Text, "CHECK", StringComparison.OrdinalIgnoreCase)) { ConstraintType = ConstraintTypeNames.Check; } else if (String.Equals(keyNode.Text, "PRIMARY", StringComparison.OrdinalIgnoreCase)) { ConstraintType = ConstraintTypeNames.PrimaryKey; } else if (String.Equals(keyNode.Text, "UNIQUE", StringComparison.OrdinalIgnoreCase)) { ConstraintType = ConstraintTypeNames.UniqueKey; } } else if (node is IExpressionNode) { CheckExpression = (IExpressionNode) node; } else if (node is ObjectNameNode) { if (!String.Equals(ConstraintType, ConstraintTypeNames.ForeignKey, StringComparison.OrdinalIgnoreCase)) throw new InvalidOperationException(); ReferencedTable = ((ObjectNameNode) node); } return base.OnChildNode(node); }
public static string ToSqlServerString(this ISqlNode n) { var sb = new StringBuilder(); new SqlServer.Stringify.StringifyVisitor(sb).Visit(n); return(sb.ToString()); }
/// <inheritdoc/> protected override ISqlNode OnChildNode(ISqlNode node) { if (node is IExpressionNode) { if (!expressionSeen) { Expression = (IExpressionNode)node; expressionSeen = true; } else if (!minValueSeen) { MinValue = (IExpressionNode)node; minValueSeen = true; } else { MaxValue = (IExpressionNode)node; } } else if (node.NodeName == "not_opt") { Not = node.ChildNodes.Any(); } return(base.OnChildNode(node)); }
protected override ISqlNode OnChildNode(ISqlNode node) { if (node.NodeName.Equals("exception_name_opt")) ExceptionName = node.FindNode<IdentifierNode>().Text; return base.OnChildNode(node); }
public void Append(ISqlNode sqlNode) { if (sqlNode == null) return; sqlNode.Render(this); }
private ISqlNode Visit(ISqlNode parent, Expression expr) { if (expr.NodeType == ExpressionType.Constant && expr.Type.IsGenericType(typeof(Queryable<>))) return VisitRoot(parent, expr); if(expr.NodeType == ExpressionType.Call) { var call = (MethodCallExpression) expr; switch (call.Method.Name) { case "Where": return VisitWhere(Visit(parent, call.Arguments[0]), call); case "OrderBy": return VisitOrderBy(Visit(parent, call.Arguments[0]), call); case "ThenBy": return VisitThenBy(Visit(parent, call.Arguments[0]), call); case "OrderByDescending": return VisitOrderByDescending(Visit(parent, call.Arguments[0]), call); case "ThenByDescending": return VisitThenByDescending(Visit(parent, call.Arguments[0]), call); case "Take": return VisitTake(Visit(parent, call.Arguments[0]), call); case "Skip": return VisitSkip(Visit(parent, call.Arguments[0]), call); case "First": case "Single": case "FirstOrDefault": case "SingleOrDefault": return VisitFirst(Visit(parent, call.Arguments[0]), call); } } throw new NotSupportedException("Not supported expression: " + expr); }
private void GetPrivileges(ISqlNode node) { bool isAll = false; foreach (var childNode in node.ChildNodes) { if (childNode is SqlKeyNode) { if (((SqlKeyNode)childNode).Text.Equals("ALL", StringComparison.OrdinalIgnoreCase)) { isAll = true; } else if (!((SqlKeyNode)childNode).Text.Equals("PRIVILEGES", StringComparison.OrdinalIgnoreCase)) { throw new InvalidOperationException(); } } else if (childNode.NodeName.Equals("priv_list")) { Privileges = childNode.ChildNodes.OfType <PrivilegeNode>(); } } if (isAll) { Privileges = new[] { PrivilegeNode.All } } ; }
private void GetGrantOption(ISqlNode node) { if (node.ChildNodes.Any()) { GrantOption = true; } }
private void GetWithAdmin(ISqlNode node) { if (node.ChildNodes.Any()) { WithAdmin = true; } }
private void ConfirmExpressionOperands(ISqlNode n) { if (n is SqlIdentifierNode id) { Current.GetInfoOrThrow(id.ToString(), n.Location).UsedInScalarExpression(n.Location); return; } // Object ID is a table name, only use the name of the table as the symbol, not the full qualification if (n is SqlObjectIdentifierNode objId) { Current.GetInfoOrThrow(objId.ToString(), n.Location).UsedInScalarExpression(n.Location); return; } if (n is SqlQualifiedIdentifierNode qid) { Current.GetInfoOrThrow(qid.ToString(), n.Location).UsedInScalarExpression(n.Location); return; } if (n is SqlVariableNode variable) { // This is a parameter from a parameterized query, so it must be defined beforehand Current.GetInfoOrThrow(variable.ToString(), n.Location).UsedInScalarExpression(n.Location); return; } }
protected override ISqlNode OnChildNode(ISqlNode node) { if (node is IdentifierNode) { VariableName = ((IdentifierNode)node).Text; } else if (node is DataTypeNode) { Type = (DataTypeNode)node; } else if (node.NodeName.Equals("constant_opt")) { IsConstant = node.ChildNodes.Any(); } else if (node.NodeName.Equals("var_not_null_opt")) { IsNotNull = node.ChildNodes.Any(); } else if (node.NodeName.Equals("var_default_opt")) { GetDefaultExpression(node); } return(base.OnChildNode(node)); }
private void GetHandledExceptions(ISqlNode node) { var exceptionNames = new List <string>(); foreach (var childNode in node.ChildNodes) { if (HandlesOthers) { throw new SqlParseException("Multiple exception names found when OTHERS clause was specified."); } if (childNode is SqlKeyNode && ((SqlKeyNode)childNode).Text.Equals("OTHERS", StringComparison.OrdinalIgnoreCase)) { HandlesOthers = true; } else if (childNode is IdentifierNode) { exceptionNames.Add(((IdentifierNode)childNode).Text); } } if (!HandlesOthers) { HandledExceptionNames = exceptionNames.ToArray(); } }
private void GetOrderBy(ISqlNode node) { var listNode = node.FindByName("sorted_def_list"); if (listNode != null) { OrderBy = listNode.ChildNodes.Cast<OrderByNode>(); } }
protected override ISqlNode OnChildNode(ISqlNode node) { if (node is IExpressionNode) Password = (IExpressionNode) node; return base.OnChildNode(node); }
public SqlSelectNode Update(string modifier, SqlTopLimitNode top, SqlListNode <ISqlNode> columns, ISqlNode from, ISqlNode where, SqlOrderByNode orderBy, ISqlNode groupBy, ISqlNode having, ISqlNode offset, ISqlNode fetch) { if (modifier == Modifier && top == TopLimitClause && columns == Columns && from == FromClause && where == WhereClause && orderBy == OrderByClause && groupBy == GroupByClause && having == HavingClause && fetch == FetchClause && offset == OffsetClause) { return(this); } return(new SqlSelectNode { Location = Location, Columns = columns, FromClause = from, GroupByClause = groupBy, HavingClause = having, Modifier = modifier, OrderByClause = orderBy, TopLimitClause = top, WhereClause = where, FetchClause = fetch, OffsetClause = offset }); }
protected override ISqlNode OnChildNode(ISqlNode node) { if (node is ObjectNameNode) { SequenceName = ((ObjectNameNode)node).Name; } else if (node.NodeName.Equals("start_opt")) { StartWith = node.FindNode <IExpressionNode>(); } else if (node.NodeName.Equals("increment_opt")) { IncrementBy = node.FindNode <IExpressionNode>(); } else if (node.NodeName.Equals("minvalue_opt")) { MinValue = node.FindNode <IExpressionNode>(); } else if (node.NodeName.Equals("maxvalue_opt")) { MaxValue = node.FindNode <IExpressionNode>(); } else if (node.NodeName.Equals("cycle_opt")) { Cycle = node.ChildNodes.Any(); } else if (node.NodeName.Equals("cache_opt")) { Cache = node.FindNode <IExpressionNode>(); } return(base.OnChildNode(node)); }
/// <inheritdoc/> protected override ISqlNode OnChildNode(ISqlNode node) { if (node.NodeName == "sql_expression_list") GetExpressions(node); return base.OnChildNode(node); }
private void GetDirection(ISqlNode node) { var childNode = node.ChildNodes.FirstOrDefault(); if (childNode == null) return; childNode = childNode.ChildNodes.FirstOrDefault(); if (childNode == null) throw new SqlParseException(); if (String.Equals(childNode.NodeName, "NEXT", StringComparison.OrdinalIgnoreCase) || String.Equals(childNode.NodeName, "PRIOR", StringComparison.OrdinalIgnoreCase) || String.Equals(childNode.NodeName, "FIRST", StringComparison.OrdinalIgnoreCase) || String.Equals(childNode.NodeName, "LAST", StringComparison.OrdinalIgnoreCase)) { Direction = childNode.NodeName.ToUpper(); } else if (String.Equals(childNode.NodeName, "ABSOLUTE", StringComparison.OrdinalIgnoreCase) || String.Equals(childNode.NodeName, "RELATIVE", StringComparison.OrdinalIgnoreCase)) { var positionNode = childNode.ChildNodes.FirstOrDefault(); if (positionNode == null) throw new SqlParseException("The position expression if required in an ABSOLUTE or RELATIVE fetch."); var expression = positionNode as IExpressionNode; if (expression == null) throw new SqlParseException(); Direction = childNode.NodeName.ToUpper(); Position = expression; } }
private ISqlNode VisitFirst(ISqlNode parent, MethodCallExpression expr) { var select = (ISelect)parent; select.Top = new Top(new ConstantProvider(_context, 1)); return select; }
protected override ISqlNode OnChildNode(ISqlNode node) { if (node is TableConstraintNode) Constraint = (TableConstraintNode) node; return base.OnChildNode(node); }
public static IReadOnlyCollection <ISqlNode> Find(this ISqlNode root, Func <ISqlNode, bool> predicate) { var list = new List <ISqlNode>(); new GetNodesVisitor(predicate, list).Visit(root); return(list); }
protected override ISqlNode OnChildNode(ISqlNode node) { if (node is ObjectNameNode) { TableName = ((ObjectNameNode)node).Name; } else if (node.NodeName == "column_set_list") { Columns = node.FindNodes <UpdateColumnNode>(); } else if (node.NodeName == "update_where") { WhereExpression = node.FindNode <IExpressionNode>(); } else if (node.NodeName == "limit_opt") { var child = node.FindNode <IntegerLiteralNode>(); if (child != null) { Limit = (int)child.Value; } } return(base.OnChildNode(node)); }
/// <inheritdoc/> protected override ISqlNode OnChildNode(ISqlNode node) { if (node.NodeName.Equals("name_part")) { node = node.ChildNodes.FirstOrDefault(); } string text; if (node is IdentifierNode) { var idNode = (IdentifierNode) node; text = idNode.Text; } else if (node is SqlKeyNode) { text = ((SqlKeyNode) node).Text; if (!String.Equals(text, "*")) throw new SqlParseException(String.Format("Invalid object name part '{0}' provided.", text)); } else { throw new SqlParseException(String.Format("The node of type '{0}' is not allowed.", node.GetType())); } if (Name != null) { Name = String.Format("{0}.{1}", Name, text); } else { Name = text; } return base.OnChildNode(node); }
protected override ISqlNode OnChildNode(ISqlNode node) { if (node is IdentifierNode) Text = ((IdentifierNode) node).Text; return base.OnChildNode(node); }
public bool Assert(ISqlNode parent, string name, Func <bool> predicate) { if (!predicate()) { return(AddError(parent, name, "Condition is false")); } return(true); }
public bool AssertIsNotNullOrEmpty(ISqlNode parent, string name, string value) { if (string.IsNullOrEmpty(value)) { return(AddError(parent, name, "string value cannot be null or empty")); } return(true); }
protected override ISqlNode OnChildNode(ISqlNode node) { if (node.NodeName.Equals("sql_expression_list")) { Values = node.ChildNodes.OfType<IExpressionNode>(); } return base.OnChildNode(node); }
protected override ISqlNode OnChildNode(ISqlNode node) { if (node is IdentifierNode) { SchemaName = ((IdentifierNode) node).Text; } return base.OnChildNode(node); }
public static string ToString(ISqlNode node) { var sb = new StringBuilder(); var visitor = new StringifyVisitor(sb); visitor.Visit(node); return(sb.ToString()); }
public void AddNode(ISqlNode child) { if (child == null) { throw new ArgumentNullException(nameof(child)); } Children.Add(child); }
private void GetLimit(ISqlNode node) { foreach (var childNode in node.ChildNodes) { if (childNode is IntegerLiteralNode) { Limit = ((IntegerLiteralNode) childNode).Value; } } }
protected override ISqlNode OnChildNode(ISqlNode node) { if (node.NodeName == "user_list") { UserNames = node.FindNodes<IdentifierNode>().Select(x => x.Text); } return base.OnChildNode(node); }
protected override ISqlNode OnChildNode(ISqlNode node) { if (node is ObjectNameNode) { TypeName = ((ObjectNameNode) node).Name; } return base.OnChildNode(node); }
public ISqlNode Visit(ISqlNode n) { if (_include(n)) { return(_inner.Visit(n)); } return(n); }
protected override ISqlNode OnChildNode(ISqlNode node) { if (node.NodeName.Equals("insert_tuple")) { Values = node.FindNodes<InsertValueNode>(); } return base.OnChildNode(node); }
private void GetFromCursor(ISqlNode node) { var idNode = node.FindNode<IdentifierNode>(); if (idNode != null) { FromCursor = true; CursorName = idNode.Text; } }
public static ISqlNode Optimize(this ISqlNode n) { if (n == null) { return(null); } return(new ExpressionOptimizeVisitor().Visit(n)); }
public static void BuildSymbolTables(this ISqlNode n, IEnumerable <SymbolInfo> environmentalSymbols = null) { if (n == null) { return; } new SymbolTableBuildVisitor(environmentalSymbols).Visit(n); }
/// <inheritdoc/> protected override ISqlNode OnChildNode(ISqlNode node) { if (node.NodeName == "sql_expression_list") { GetGroupExpressions(node); } else if (node.NodeName == "having_clause_opt") { HavingExpression = node.ChildNodes.FirstOrDefault() as IExpressionNode; } return base.OnChildNode(node); }
protected override ISqlNode OnChildNode(ISqlNode node) { if (node.NodeName.Equals("label_opt")) { Label = node.FindNode<StringLiteralNode>().Value; } else if (node.NodeName.Equals("when_opt")) { WhenExpression = node.FindNode<IExpressionNode>(); } return base.OnChildNode(node); }
private void GetGroupExpressions(ISqlNode node) { var exps = new List<IExpressionNode>(); foreach (var childNode in node.ChildNodes) { if (childNode is IExpressionNode) exps.Add((IExpressionNode) childNode); } GroupExpressions = exps.ToArray(); }
/// <inheritdoc/> protected override ISqlNode OnChildNode(ISqlNode node) { if (node is ObjectNameNode) { TableName = (ObjectNameNode)node; } else if (node.NodeName == "select_as_opt") { Alias = (IdentifierNode)node.ChildNodes.FirstOrDefault(); } return base.OnChildNode(node); }
/// <inheritdoc/> protected override ISqlNode OnChildNode(ISqlNode node) { if (node.NodeName == "from_source") { Source = (IFromSourceNode) node.ChildNodes.FirstOrDefault(); } else if (node.NodeName == "join_opt") { Join = (JoinNode) node.ChildNodes.FirstOrDefault(); } return base.OnChildNode(node); }
protected override ISqlNode OnChildNode(ISqlNode node) { if (node.NodeName == "sql_query_expression") { QueryExpression = node as SqlQueryExpressionNode; } else if (node.NodeName == "order_opt") { GetOrderBy(node); } return base.OnChildNode(node); }
protected override ISqlNode OnChildNode(ISqlNode node) { if (node.NodeName.Equals("plsql_statement_list")) { GetStatements(node); } else if (node.NodeName.Equals("exception_block_opt")) { ExceptionHandlers = node.FindNodes<ExceptionHandlerNode>(); } return base.OnChildNode(node); }
protected override ISqlNode OnChildNode(ISqlNode node) { if (node.NodeName.Equals("label_opt")) { Label = node.FindNode<IdentifierNode>().Text; } else if (node.NodeName.Equals("when_opt")) { WhenExpression = node.FindNode<IExpressionNode>(); } return base.OnChildNode(node); }
protected override ISqlNode OnChildNode(ISqlNode node) { if (node is IdentifierNode) { ColumnName = ((IdentifierNode) node).Text; } else if (node is IExpressionNode) { Expression = (IExpressionNode) node; } return base.OnChildNode(node); }
protected override ISqlNode OnChildNode(ISqlNode node) { if (node is IdentifierNode) { UserName = ((IdentifierNode) node).Text; } else if (node.NodeName.Equals("action_list")) { Actions = node.FindNodes<IAlterUserActionNode>(); } return base.OnChildNode(node); }