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