public virtual string GetSql (IClause clause)
{
if (clause == null)
throw new ArgumentNullException ("clause");
Type type = clause.GetType ();
if (type == typeof (FromSelectClause))
return GetClauseSql (clause as FromSelectClause);
else if (type == typeof (FromTableClause))
return GetClauseSql (clause as FromTableClause);
else if (type == typeof (WhereClause))
return GetClauseSql (clause as WhereClause);
else if (type == typeof (HavingClause))
return GetClauseSql (clause as HavingClause);
else if (type == typeof (JoinClause))
return GetClauseSql (clause as JoinClause);
else if (type == typeof (OrderByClause))
return GetClauseSql (clause as OrderByClause);
else if (type == typeof (GroupByClause))
return GetClauseSql (clause as GroupByClause);
else if (type == typeof (UnionClause))
return GetClauseSql (clause as UnionClause);
else
throw new NotImplementedException (type.FullName);
}
public void AddClause(IClause clause)
{
ArgumentUtility.CheckNotNull("clause", clause);
var clauseAsMainFromClause = clause as MainFromClause;
if (clauseAsMainFromClause != null)
{
if (MainFromClause != null)
{
throw new InvalidOperationException("Builder already has a MainFromClause.");
}
MainFromClause = clauseAsMainFromClause;
return;
}
var clauseAsSelectClause = clause as SelectClause;
if (clauseAsSelectClause != null)
{
if (SelectClause != null)
{
throw new InvalidOperationException("Builder already has a SelectClause.");
}
SelectClause = clauseAsSelectClause;
return;
}
var clauseAsBodyClause = clause as IBodyClause;
if (clauseAsBodyClause != null)
{
_bodyClauses.Add(clauseAsBodyClause);
return;
}
var message = string.Format(
"Cannot add clause of type '{0}' to a query model. Only instances of IBodyClause, MainFromClause, or ISelectGroupClause are supported.",
clause.GetType());
throw new ArgumentTypeException(message, "clause", null, clause.GetType());
}
public SyntaxParseResult <IN> ParseOneOrMore(IList <Token <IN> > tokens, OneOrMoreClause <IN> clause, int position)
{
SyntaxParseResult <IN> result = new SyntaxParseResult <IN>();
ManySyntaxNode <IN> manyNode = new ManySyntaxNode <IN>("");
int currentPosition = position;
IClause <IN> innerClause = clause.Clause;
bool isError;
SyntaxParseResult <IN> lastInnerResult = null;
SyntaxParseResult <IN> firstInnerResult = null;
if (innerClause is TerminalClause <IN> )
{
manyNode.IsManyTokens = true;
firstInnerResult = ParseTerminal(tokens, innerClause as TerminalClause <IN>, currentPosition);
}
else if (innerClause is NonTerminalClause <IN> )
{
manyNode.IsManyValues = true;
firstInnerResult = ParseNonTerminal(tokens, innerClause as NonTerminalClause <IN>, currentPosition);
}
else
{
throw new NotImplementedException("unable to apply repeater to " + innerClause.GetType().Name);
}
if (firstInnerResult != null && !firstInnerResult.IsError)
{
manyNode.Add(firstInnerResult.Root);
lastInnerResult = firstInnerResult;
currentPosition = firstInnerResult.EndingPosition;
ZeroOrMoreClause <IN> more = new ZeroOrMoreClause <IN>(innerClause);
SyntaxParseResult <IN> nextResult = ParseZeroOrMore(tokens, more, currentPosition);
if (nextResult != null && !nextResult.IsError)
{
currentPosition = nextResult.EndingPosition;
ManySyntaxNode <IN> moreChildren = (ManySyntaxNode <IN>)nextResult.Root;
manyNode.Children.AddRange(moreChildren.Children);
}
isError = false;
}
else
{
isError = true;
}
result.EndingPosition = currentPosition;
result.IsError = isError;
result.Root = manyNode;
result.IsEnded = lastInnerResult != null && lastInnerResult.IsEnded;
return(result);
}
public void AddClause (IClause clause)
{
ArgumentUtility.CheckNotNull ("clause", clause);
var clauseAsMainFromClause = clause as MainFromClause;
if (clauseAsMainFromClause != null)
{
if (MainFromClause != null)
throw new InvalidOperationException ("Builder already has a MainFromClause.");
MainFromClause = clauseAsMainFromClause;
return;
}
var clauseAsSelectClause = clause as SelectClause;
if (clauseAsSelectClause != null)
{
if (SelectClause != null)
throw new InvalidOperationException ("Builder already has a SelectClause.");
SelectClause = clauseAsSelectClause;
return;
}
var clauseAsBodyClause = clause as IBodyClause;
if (clauseAsBodyClause != null)
{
_bodyClauses.Add (clauseAsBodyClause);
return;
}
var message = string.Format (
"Cannot add clause of type '{0}' to a query model. Only instances of IBodyClause, MainFromClause, or ISelectGroupClause are supported.",
clause.GetType());
throw new ArgumentTypeException (message, "clause", null, clause.GetType());
}
public virtual string GetSql(IClause clause)
{
if (clause == null)
{
throw new ArgumentNullException("clause");
}
Type type = clause.GetType();
if (type == typeof(FromSelectClause))
{
return(GetClauseSql(clause as FromSelectClause));
}
else if (type == typeof(FromTableClause))
{
return(GetClauseSql(clause as FromTableClause));
}
else if (type == typeof(WhereClause))
{
return(GetClauseSql(clause as WhereClause));
}
else if (type == typeof(HavingClause))
{
return(GetClauseSql(clause as HavingClause));
}
else if (type == typeof(JoinClause))
{
return(GetClauseSql(clause as JoinClause));
}
else if (type == typeof(OrderByClause))
{
return(GetClauseSql(clause as OrderByClause));
}
else if (type == typeof(GroupByClause))
{
return(GetClauseSql(clause as GroupByClause));
}
else if (type == typeof(UnionClause))
{
return(GetClauseSql(clause as UnionClause));
}
else
{
throw new NotImplementedException(type.FullName);
}
}
public SyntaxParseResult <IN> ParseOption(IList <Token <IN> > tokens, OptionClause <IN> clause, Rule <IN> rule, int position)
{
SyntaxParseResult <IN> result = new SyntaxParseResult <IN>();
int currentPosition = position;
IClause <IN> innerClause = clause.Clause;
SyntaxParseResult <IN> innerResult = null;
if (innerClause is TerminalClause <IN> )
{
innerResult = ParseTerminal(tokens, innerClause as TerminalClause <IN>, currentPosition);
}
else if (innerClause is NonTerminalClause <IN> )
{
innerResult = ParseNonTerminal(tokens, innerClause as NonTerminalClause <IN>, currentPosition);
}
else
{
throw new NotImplementedException("unable to apply repeater to " + innerClause.GetType().Name);
}
if (innerResult.IsError)
{
if (innerClause is TerminalClause <IN> )
{
result = new SyntaxParseResult <IN>();
result.IsError = false;
result.Root = new SyntaxLeaf <IN>(Token <IN> .Empty());
result.EndingPosition = position;
}
else
{
result = new SyntaxParseResult <IN>();
result.IsError = false;
List <ISyntaxNode <IN> > children = new List <ISyntaxNode <IN> >()
{
innerResult.Root
};
if (innerResult.IsError)
{
children.Clear();
}
result.Root = new OptionSyntaxNode <IN>(rule.NonTerminalName + "__" + rule.Key, children, rule.GetVisitor());
result.EndingPosition = position;
}
}
else
{
ISyntaxNode <IN> node = innerResult.Root;
List <ISyntaxNode <IN> > children = new List <ISyntaxNode <IN> >()
{
innerResult.Root
};
result.Root = new OptionSyntaxNode <IN>(rule.NonTerminalName + "__" + rule.Key, children, rule.GetVisitor());
result.EndingPosition = innerResult.EndingPosition;
}
return(result);
}
public SyntaxParseResult <IN> ParseZeroOrMore(IList <Token <IN> > tokens, ZeroOrMoreClause <IN> clause, int position)
{
SyntaxParseResult <IN> result = new SyntaxParseResult <IN>();
ManySyntaxNode <IN> manyNode = new ManySyntaxNode <IN>("");
int currentPosition = position;
IClause <IN> innerClause = clause.Clause;
bool stillOk = true;
SyntaxParseResult <IN> lastInnerResult = null;
var innerErrors = new List <UnexpectedTokenSyntaxError <IN> >();
while (stillOk)
{
SyntaxParseResult <IN> innerResult = null;
if (innerClause is TerminalClause <IN> )
{
manyNode.IsManyTokens = true;
innerResult = ParseTerminal(tokens, innerClause as TerminalClause <IN>, currentPosition);
}
else if (innerClause is NonTerminalClause <IN> nonTerm)
{
innerResult = ParseNonTerminal(tokens, nonTerm, currentPosition);
if (nonTerm.IsGroup)
{
manyNode.IsManyGroups = true;
}
else
{
manyNode.IsManyValues = true;
}
}
else if (innerClause is GroupClause <IN> )
{
manyNode.IsManyGroups = true;
innerResult = ParseNonTerminal(tokens, innerClause as NonTerminalClause <IN>, currentPosition);
}
else
{
throw new NotImplementedException("unable to apply repeater to " + innerClause.GetType().Name);
}
if (innerResult != null && !innerResult.IsError)
{
manyNode.Add(innerResult.Root);
currentPosition = innerResult.EndingPosition;
lastInnerResult = innerResult;
}
else
{
innerErrors.AddRange(innerResult.Errors);
}
stillOk = stillOk && innerResult != null && !(innerResult.IsError) && currentPosition < tokens.Count;
}
result.EndingPosition = currentPosition;
result.IsError = false;
result.Errors = innerErrors;
result.Root = manyNode;
result.IsEnded = lastInnerResult != null && lastInnerResult.IsEnded;
return(result);
}