public TSQLArgumentList Parse(ITSQLTokenizer tokenizer)
{
List <TSQLToken> tokens = new List <TSQLToken>();
// need to do this before starting the argument loop
// so we can handle an empty argument list of just whitespace
// and comments
TSQLTokenParserHelper.ReadCommentsAndWhitespace(
tokenizer,
tokens);
TSQLValueAsTypeExpression argument = new TSQLValueAsTypeExpression();
TSQLExpression expression = new TSQLValueExpressionParser().Parse(tokenizer);
argument.Expression = expression;
tokens.AddRange(expression.Tokens);
TSQLTokenParserHelper.ReadCommentsAndWhitespace(
tokenizer,
tokens);
if (!tokenizer.Current.IsKeyword(TSQLKeywords.AS))
{
throw new InvalidOperationException("AS expected.");
}
tokens.Add(tokenizer.Current);
TSQLTokenParserHelper.ReadThroughAnyCommentsOrWhitespace(
tokenizer,
tokens);
argument.DataType = tokenizer.Current.AsIdentifier;
tokens.Add(tokenizer.Current);
// reading until closing paren
TSQLTokenParserHelper.ReadThroughAnyCommentsOrWhitespace(
tokenizer,
tokens);
TSQLArgumentList argList = new TSQLArgumentList(
new List <TSQLExpression> {
argument
});
argList.Tokens.AddRange(tokens);
return(argList);
}
public TSQLArgumentList Parse(ITSQLTokenizer tokenizer)
{
List <TSQLExpression> arguments = new List <TSQLExpression>();
TSQLValueExpressionParser factory = new TSQLValueExpressionParser();
List <TSQLToken> tokens = new List <TSQLToken>();
// need to do this before starting the argument loop
// so we can handle an empty argument list of just whitespace
// and comments
TSQLTokenParserHelper.ReadCommentsAndWhitespace(
tokenizer,
tokens);
while (
tokenizer.Current != null &&
!tokenizer.Current.IsCharacter(TSQLCharacters.CloseParentheses))
{
TSQLTokenParserHelper.ReadCommentsAndWhitespace(
tokenizer,
tokens);
TSQLExpression argument = factory.Parse(tokenizer);
tokens.AddRange(argument.Tokens);
arguments.Add(argument);
if (tokenizer.Current.IsCharacter(TSQLCharacters.Comma))
{
tokens.Add(tokenizer.Current);
tokenizer.MoveNext();
TSQLTokenParserHelper.ReadCommentsAndWhitespace(
tokenizer,
tokens);
}
}
TSQLArgumentList argList = new TSQLArgumentList(
arguments);
argList.Tokens.AddRange(tokens);
return(argList);
}
public TSQLOptionClause Parse(ITSQLTokenizer tokenizer)
{
TSQLOptionClause option = new TSQLOptionClause();
if (!tokenizer.Current.IsKeyword(TSQLKeywords.OPTION))
{
throw new InvalidOperationException("OPTION expected.");
}
option.Tokens.Add(tokenizer.Current);
while (
tokenizer.MoveNext() &&
!tokenizer.Current.IsCharacter(TSQLCharacters.OpenParentheses))
{
option.Tokens.Add(tokenizer.Current);
}
do
{
if (tokenizer.Current != null)
{
option.Tokens.Add(tokenizer.Current);
}
} while (
tokenizer.MoveNext() &&
!tokenizer.Current.IsCharacter(TSQLCharacters.CloseParentheses));
if (tokenizer.Current != null)
{
option.Tokens.Add(tokenizer.Current);
tokenizer.MoveNext();
}
TSQLTokenParserHelper.ReadCommentsAndWhitespace(
tokenizer,
option);
return(option);
}
public TSQLSelectColumn Parse(ITSQLTokenizer tokenizer)
{
TSQLSelectColumn column = new TSQLSelectColumn();
TSQLExpression columnExpression = new TSQLSelectExpressionParser().Parse(tokenizer);
column.Expression = columnExpression;
column.Tokens.AddRange(columnExpression.Tokens);
TSQLTokenParserHelper.ReadCommentsAndWhitespace(
tokenizer,
column);
// check for operator =, when expression type is column, and return new column expression with alias
// e.g. IsFinishedGoods = p.FinishedGoodsFlag
if (
tokenizer.Current != null &&
tokenizer.Current.Type == TSQLTokenType.Operator &&
tokenizer.Current.Text == "=" &&
columnExpression.Type == TSQLExpressionType.Column
)
{
column.Tokens.Add(tokenizer.Current);
tokenizer.MoveNext();
TSQLExpression actualColumn = new TSQLValueExpressionParser().Parse(tokenizer);
column.Expression = actualColumn;
column.ColumnAlias = columnExpression.AsColumn.Column;
column.Tokens.AddRange(actualColumn.Tokens);
}
else
{
if (tokenizer.Current.IsKeyword(TSQLKeywords.AS))
{
column.Tokens.Add(tokenizer.Current);
tokenizer.MoveNext();
TSQLTokenParserHelper.ReadCommentsAndWhitespace(
tokenizer,
column);
}
if (tokenizer.Current != null &&
tokenizer.Current.Type.In(
TSQLTokenType.Identifier,
TSQLTokenType.SystemIdentifier,
TSQLTokenType.IncompleteIdentifier))
{
column.Tokens.Add(tokenizer.Current);
if (tokenizer.Current.Type.In(
TSQLTokenType.Identifier,
TSQLTokenType.SystemIdentifier))
{
column.ColumnAlias = tokenizer.Current.AsIdentifier;
}
tokenizer.MoveNext();
}
}
return(column);
}
public TSQLSelectClause Parse(ITSQLTokenizer tokenizer)
{
TSQLSelectClause select = new TSQLSelectClause();
if (!tokenizer.Current.IsKeyword(TSQLKeywords.SELECT))
{
throw new InvalidOperationException("SELECT expected.");
}
select.Tokens.Add(tokenizer.Current);
tokenizer.MoveNext();
TSQLTokenParserHelper.ReadCommentsAndWhitespace(
tokenizer,
select);
if (tokenizer.Current.IsKeyword(TSQLKeywords.ALL) ||
tokenizer.Current.IsKeyword(TSQLKeywords.DISTINCT))
{
select.Tokens.Add(tokenizer.Current);
tokenizer.MoveNext();
TSQLTokenParserHelper.ReadCommentsAndWhitespace(
tokenizer,
select);
}
if (tokenizer.Current.IsKeyword(TSQLKeywords.TOP))
{
select.Tokens.Add(tokenizer.Current);
tokenizer.MoveNext();
TSQLTokenParserHelper.ReadCommentsAndWhitespace(
tokenizer,
select);
if (tokenizer.Current.IsCharacter(TSQLCharacters.OpenParentheses))
{
select.Tokens.Add(tokenizer.Current);
tokenizer.MoveNext();
TSQLTokenParserHelper.ReadCommentsAndWhitespace(
tokenizer,
select);
// handling for TOP(@RowsToReturn)
// can also be used in a CROSS APPLY with an outer reference, e.g. TOP(p.RowCount)
if (tokenizer.Current != null &&
tokenizer.Current.Type.In(
TSQLTokenType.NumericLiteral,
TSQLTokenType.Identifier,
TSQLTokenType.IncompleteIdentifier,
TSQLTokenType.SystemVariable,
TSQLTokenType.Variable))
{
select.Tokens.Add(tokenizer.Current);
tokenizer.MoveNext();
TSQLTokenParserHelper.ReadCommentsAndWhitespace(
tokenizer,
select);
}
if (tokenizer.Current.IsCharacter(TSQLCharacters.CloseParentheses))
{
select.Tokens.Add(tokenizer.Current);
tokenizer.MoveNext();
TSQLTokenParserHelper.ReadCommentsAndWhitespace(
tokenizer,
select);
}
}
else if (tokenizer.Current != null &&
tokenizer.Current.Type == TSQLTokenType.NumericLiteral)
{
select.Tokens.Add(tokenizer.Current);
tokenizer.MoveNext();
TSQLTokenParserHelper.ReadCommentsAndWhitespace(
tokenizer,
select);
}
if (tokenizer.Current.IsKeyword(TSQLKeywords.PERCENT))
{
select.Tokens.Add(tokenizer.Current);
tokenizer.MoveNext();
TSQLTokenParserHelper.ReadCommentsAndWhitespace(
tokenizer,
select);
}
if (tokenizer.Current.IsKeyword(TSQLKeywords.WITH))
{
select.Tokens.Add(tokenizer.Current);
tokenizer.MoveNext();
TSQLTokenParserHelper.ReadCommentsAndWhitespace(
tokenizer,
select);
if (tokenizer.Current != null &&
tokenizer.Current.Type == TSQLTokenType.Identifier &&
tokenizer.Current.AsIdentifier.Text.Equals(
"TIES",
StringComparison.InvariantCultureIgnoreCase))
{
select.Tokens.Add(tokenizer.Current);
tokenizer.MoveNext();
TSQLTokenParserHelper.ReadCommentsAndWhitespace(
tokenizer,
select);
}
}
}
while (
tokenizer.Current != null &&
!tokenizer.Current.IsCharacter(TSQLCharacters.Semicolon) &&
!tokenizer.Current.IsCharacter(TSQLCharacters.CloseParentheses) &&
!(
tokenizer.Current.Type == TSQLTokenType.Keyword &&
(
tokenizer.Current.AsKeyword.Keyword.In(
TSQLKeywords.INTO,
TSQLKeywords.FROM,
TSQLKeywords.WHERE,
TSQLKeywords.GROUP,
TSQLKeywords.HAVING,
TSQLKeywords.ORDER,
TSQLKeywords.UNION,
TSQLKeywords.EXCEPT,
TSQLKeywords.INTERSECT,
TSQLKeywords.FOR,
TSQLKeywords.OPTION) ||
tokenizer.Current.AsKeyword.Keyword.IsStatementStart()
)
))
{
TSQLSelectColumn column = new TSQLSelectColumnParser().Parse(tokenizer);
select.Tokens.AddRange(column.Tokens);
select.Columns.Add(column);
TSQLTokenParserHelper.ReadCommentsAndWhitespace(
tokenizer,
select);
if (tokenizer.Current.IsCharacter(TSQLCharacters.Comma))
{
select.Tokens.Add(tokenizer.Current);
tokenizer.MoveNext();
TSQLTokenParserHelper.ReadCommentsAndWhitespace(
tokenizer,
select);
}
}
return(select);
}
public TSQLSelectStatement Parse()
{
TSQLSelectClause selectClause = new TSQLSelectClauseParser().Parse(Tokenizer);
Statement.Select = selectClause;
Statement.Tokens.AddRange(selectClause.Tokens);
if (Tokenizer.Current.IsKeyword(TSQLKeywords.INTO))
{
TSQLIntoClause intoClause = new TSQLIntoClauseParser().Parse(Tokenizer);
Statement.Into = intoClause;
Statement.Tokens.AddRange(intoClause.Tokens);
}
if (Tokenizer.Current.IsKeyword(TSQLKeywords.FROM))
{
TSQLFromClause fromClause = new TSQLFromClauseParser().Parse(Tokenizer);
Statement.From = fromClause;
Statement.Tokens.AddRange(fromClause.Tokens);
}
if (Tokenizer.Current.IsKeyword(TSQLKeywords.WHERE))
{
TSQLWhereClause whereClause = new TSQLWhereClauseParser().Parse(Tokenizer);
Statement.Where = whereClause;
Statement.Tokens.AddRange(whereClause.Tokens);
}
if (Tokenizer.Current.IsKeyword(TSQLKeywords.GROUP))
{
TSQLGroupByClause groupByClause = new TSQLGroupByClauseParser().Parse(Tokenizer);
Statement.GroupBy = groupByClause;
Statement.Tokens.AddRange(groupByClause.Tokens);
}
if (Tokenizer.Current.IsKeyword(TSQLKeywords.HAVING))
{
TSQLHavingClause havingClause = new TSQLHavingClauseParser().Parse(Tokenizer);
Statement.Having = havingClause;
Statement.Tokens.AddRange(havingClause.Tokens);
}
// ORDER not allowed
// FOR not allowed
// OPTION not allowed
TSQLTokenParserHelper.ReadCommentsAndWhitespace(
Tokenizer,
Statement);
return(Statement);
}
public TSQLSelectStatement Parse()
{
// (SELECT 1)
int level = 0;
while (Tokenizer.Current.IsCharacter(TSQLCharacters.OpenParentheses))
{
Statement.Tokens.Add(Tokenizer.Current);
level++;
Tokenizer.MoveNext();
TSQLTokenParserHelper.ReadCommentsAndWhitespace(
Tokenizer,
Statement);
}
TSQLSelectClause selectClause = new TSQLSelectClauseParser().Parse(Tokenizer);
Statement.Select = selectClause;
Statement.Tokens.AddRange(selectClause.Tokens);
if (Tokenizer.Current.IsKeyword(TSQLKeywords.INTO))
{
TSQLIntoClause intoClause = new TSQLIntoClauseParser().Parse(Tokenizer);
Statement.Into = intoClause;
Statement.Tokens.AddRange(intoClause.Tokens);
}
if (Tokenizer.Current.IsKeyword(TSQLKeywords.FROM))
{
TSQLFromClause fromClause = new TSQLFromClauseParser().Parse(Tokenizer);
Statement.From = fromClause;
Statement.Tokens.AddRange(fromClause.Tokens);
}
if (Tokenizer.Current.IsKeyword(TSQLKeywords.WHERE))
{
TSQLWhereClause whereClause = new TSQLWhereClauseParser().Parse(Tokenizer);
Statement.Where = whereClause;
Statement.Tokens.AddRange(whereClause.Tokens);
}
if (Tokenizer.Current.IsKeyword(TSQLKeywords.GROUP))
{
TSQLGroupByClause groupByClause = new TSQLGroupByClauseParser().Parse(Tokenizer);
Statement.GroupBy = groupByClause;
Statement.Tokens.AddRange(groupByClause.Tokens);
}
if (Tokenizer.Current.IsKeyword(TSQLKeywords.HAVING))
{
TSQLHavingClause havingClause = new TSQLHavingClauseParser().Parse(Tokenizer);
Statement.Having = havingClause;
Statement.Tokens.AddRange(havingClause.Tokens);
}
while (level > 0 && Tokenizer.Current.IsCharacter(TSQLCharacters.CloseParentheses))
{
Statement.Tokens.Add(Tokenizer.Current);
level--;
Tokenizer.MoveNext();
}
while (Tokenizer.Current?.AsKeyword != null &&
Tokenizer.Current.AsKeyword.Keyword.In(
TSQLKeywords.UNION,
TSQLKeywords.EXCEPT,
TSQLKeywords.INTERSECT))
{
TSQLSetOperatorClause set = new TSQLSetOperatorClauseParser().Parse(Tokenizer);
Statement.SetOperators.Add(set);
Statement.Tokens.AddRange(set.Tokens);
}
while (level > 0 && Tokenizer.Current.IsCharacter(TSQLCharacters.CloseParentheses))
{
Statement.Tokens.Add(Tokenizer.Current);
level--;
Tokenizer.MoveNext();
}
if (Tokenizer.Current.IsKeyword(TSQLKeywords.ORDER))
{
TSQLOrderByClause orderByClause = new TSQLOrderByClauseParser().Parse(Tokenizer);
Statement.OrderBy = orderByClause;
Statement.Tokens.AddRange(orderByClause.Tokens);
}
// order for OPTION and FOR doesn't seem to matter
while (
Tokenizer.Current.IsKeyword(TSQLKeywords.FOR) ||
Tokenizer.Current.IsKeyword(TSQLKeywords.OPTION))
{
if (Tokenizer.Current.IsKeyword(TSQLKeywords.FOR))
{
TSQLForClause forClause = new TSQLForClauseParser().Parse(Tokenizer);
Statement.For = forClause;
Statement.Tokens.AddRange(forClause.Tokens);
}
if (Tokenizer.Current.IsKeyword(TSQLKeywords.OPTION))
{
TSQLOptionClause optionClause = new TSQLOptionClauseParser().Parse(Tokenizer);
Statement.Option = optionClause;
Statement.Tokens.AddRange(optionClause.Tokens);
}
}
return(Statement);
}
public TSQLExpression ParseNext(
ITSQLTokenizer tokenizer)
{
if (tokenizer.Current == null)
{
return(null);
}
// look at the current/first token to determine what to do
if (tokenizer.Current.Text == "*")
{
TSQLMulticolumnExpression simpleMulti = new TSQLMulticolumnExpression();
simpleMulti.Tokens.Add(tokenizer.Current);
TSQLTokenParserHelper.ReadThroughAnyCommentsOrWhitespace(
tokenizer,
simpleMulti.Tokens);
return(simpleMulti);
// still need to seperately check for p.* below
}
// this checks for unary operators, e.g. +, -, and ~
else if (tokenizer.Current.Type.In(
TSQLTokenType.Operator))
{
return(null);
}
else if (tokenizer.Current.IsCharacter(
TSQLCharacters.OpenParentheses))
{
List <TSQLToken> tokens = new List <TSQLToken>();
tokens.Add(tokenizer.Current);
// read through any whitespace so we can check specifically for a SELECT
TSQLTokenParserHelper.ReadThroughAnyCommentsOrWhitespace(
tokenizer,
tokens);
if (tokenizer.Current.IsKeyword(TSQLKeywords.SELECT))
{
#region parse subquery
TSQLSubqueryExpression subquery = new TSQLSubqueryExpression();
subquery.Tokens.AddRange(tokens);
TSQLSelectStatement select = new TSQLSelectStatementParser(tokenizer).Parse();
subquery.Select = select;
subquery.Tokens.AddRange(select.Tokens);
if (tokenizer.Current.IsCharacter(TSQLCharacters.CloseParentheses))
{
subquery.Tokens.Add(tokenizer.Current);
tokenizer.MoveNext();
}
return(subquery);
#endregion
}
else
{
#region parse expression contained/grouped inside parenthesis
TSQLGroupedExpression group = new TSQLGroupedExpression();
group.Tokens.AddRange(tokens);
group.InnerExpression =
new TSQLValueExpressionParser().Parse(
tokenizer);
group.Tokens.AddRange(group.InnerExpression.Tokens);
if (tokenizer.Current.IsCharacter(
TSQLCharacters.CloseParentheses))
{
group.Tokens.Add(tokenizer.Current);
tokenizer.MoveNext();
}
return(group);
#endregion
}
}
else if (tokenizer.Current.Type.In(
TSQLTokenType.Variable,
TSQLTokenType.SystemVariable))
{
TSQLVariableExpression variable = new TSQLVariableExpression();
variable.Tokens.Add(tokenizer.Current);
variable.Variable = tokenizer.Current.AsVariable;
TSQLTokenParserHelper.ReadThroughAnyCommentsOrWhitespace(
tokenizer,
variable.Tokens);
return(variable);
}
else if (tokenizer.Current.Type.In(
TSQLTokenType.BinaryLiteral,
TSQLTokenType.MoneyLiteral,
TSQLTokenType.NumericLiteral,
TSQLTokenType.StringLiteral,
TSQLTokenType.IncompleteString))
{
TSQLConstantExpression constant = new TSQLConstantExpression();
constant.Literal = tokenizer.Current.AsLiteral;
constant.Tokens.Add(tokenizer.Current);
TSQLTokenParserHelper.ReadThroughAnyCommentsOrWhitespace(
tokenizer,
constant.Tokens);
return(constant);
}
else if (tokenizer.Current.IsKeyword(TSQLKeywords.CASE))
{
return(new TSQLCaseExpressionParser().Parse(tokenizer));
}
else if (tokenizer.Current.Type.In(
TSQLTokenType.SystemColumnIdentifier,
TSQLTokenType.IncompleteIdentifier))
{
TSQLColumnExpression column = new TSQLColumnExpression();
column.Column = tokenizer.Current.AsSystemColumnIdentifier;
column.Tokens.Add(tokenizer.Current);
TSQLTokenParserHelper.ReadThroughAnyCommentsOrWhitespace(
tokenizer,
column.Tokens);
return(column);
}
else if (tokenizer.Current.Type.In(
TSQLTokenType.Identifier,
TSQLTokenType.SystemIdentifier))
{
// column, with or without alias, or with full explicit table name with up to 5 parts
// or function, up to 4 part naming
// find last token up to and including possible first paren
// if *, then multi column
// if paren, then function
// else column
// alias would be any tokens prior to last period, removing whitespace
List <TSQLToken> tokens = new List <TSQLToken>();
tokens.Add(tokenizer.Current);
while (tokenizer.MoveNext())
{
if (tokenizer.Current.IsCharacter(TSQLCharacters.OpenParentheses))
{
#region parse function
TSQLFunctionExpression function = new TSQLFunctionExpression();
function.Tokens.AddRange(tokens);
function.Tokens.Add(tokenizer.Current);
var identityTokens = tokens
.Where(t => !t.IsComment() && !t.IsWhitespace())
.ToList();
function.Function =
identityTokens[identityTokens.Count - 1]
.AsIdentifier;
if (identityTokens.Count > 1)
{
function.QualifiedPath =
identityTokens
.GetRange(
0,
identityTokens.Count - 2);
}
tokenizer.MoveNext();
TSQLArgumentList arguments = null;
// CAST function has it's own very unique argument syntax
if (function.Function.IsIdentifier(TSQLIdentifiers.CAST))
{
arguments = new TSQLValueAsTypeExpressionParser().Parse(
tokenizer);
}
else
{
arguments = new TSQLArgumentListParser().Parse(
tokenizer);
}
function.Tokens.AddRange(arguments.Tokens);
function.Arguments = arguments;
if (tokenizer.Current.IsCharacter(TSQLCharacters.CloseParentheses))
{
function.Tokens.Add(tokenizer.Current);
}
tokenizer.MoveNext();
TSQLTokenParserHelper.ReadCommentsAndWhitespace(
tokenizer,
function);
// look for windowed aggregate
if (tokenizer.Current.IsKeyword(TSQLKeywords.OVER))
{
function.Tokens.Add(tokenizer.Current);
tokenizer.MoveNext();
TSQLTokenParserHelper.ReadCommentsAndWhitespace(
tokenizer,
function);
if (tokenizer.Current.IsCharacter(TSQLCharacters.OpenParentheses))
{
function.Tokens.Add(tokenizer.Current);
// recursively look for final close parens
TSQLTokenParserHelper.ReadUntilStop(
tokenizer,
function,
new List <TSQLFutureKeywords> {
},
new List <TSQLKeywords> {
},
lookForStatementStarts: false);
if (tokenizer.Current != null &&
tokenizer.Current.IsCharacter(TSQLCharacters.CloseParentheses))
{
function.Tokens.Add(tokenizer.Current);
tokenizer.MoveNext();
}
}
}
return(function);
#endregion
}
else if (tokenizer.Current.Text == "*")
{
#region parse multi column reference
// e.g. p.*
TSQLMulticolumnExpression multi = new TSQLMulticolumnExpression();
multi.Tokens.AddRange(tokens);
multi.Tokens.Add(tokenizer.Current);
List <TSQLToken> columnReference = tokens
.Where(t => !t.IsComment() && !t.IsWhitespace())
.ToList();
if (columnReference.Count > 0)
{
// p.* will have the single token p in the final list
// AdventureWorks..ErrorLog.* will have 4 tokens in the final list
// e.g. {AdventureWorks, ., ., ErrorLog}
multi.TableReference = columnReference
.GetRange(0, columnReference
.FindLastIndex(t => t.IsCharacter(TSQLCharacters.Period)))
.ToList();
}
TSQLTokenParserHelper.ReadThroughAnyCommentsOrWhitespace(
tokenizer,
multi.Tokens);
return(multi);
#endregion
}
else if (
tokenizer.Current.IsCharacter(TSQLCharacters.Comma) ||
tokenizer.Current.IsCharacter(TSQLCharacters.CloseParentheses) ||
tokenizer.Current.Type.In(
TSQLTokenType.Keyword,
TSQLTokenType.Operator) ||
// this will be a nasty check, but I don't want to copy the internal logic elsewhere
// two identifiers in a row means that the second one is an alias
(
tokenizer.Current.Type.In(
TSQLTokenType.Identifier,
TSQLTokenType.IncompleteIdentifier) &&
tokens
.Where(t => !t.IsComment() && !t.IsWhitespace())
.LastOrDefault()
?.Type.In(
TSQLTokenType.Identifier,
TSQLTokenType.BinaryLiteral,
TSQLTokenType.MoneyLiteral,
TSQLTokenType.NumericLiteral,
TSQLTokenType.StringLiteral,
TSQLTokenType.SystemColumnIdentifier,
TSQLTokenType.SystemIdentifier,
TSQLTokenType.SystemVariable,
TSQLTokenType.Variable
) == true // Operator '&&' cannot be applied to operands of type 'bool' and 'bool?'
))
{
TSQLColumnExpression column = new TSQLColumnExpression();
column.Tokens.AddRange(tokens);
List <TSQLToken> columnReference = tokens
.Where(t => !t.IsComment() && !t.IsWhitespace())
.ToList();
if (columnReference.Count > 1)
{
// p.ProductID will have the single token p in the final list
// AdventureWorks..ErrorLog.ErrorLogID will have 4 tokens in the final list
// e.g. {AdventureWorks, ., ., ErrorLog}
column.TableReference = columnReference
.GetRange(0, columnReference
.FindLastIndex(t => t.IsCharacter(TSQLCharacters.Period)))
.ToList();
}
column.Column = columnReference
.Last()
.AsIdentifier;
return(column);
}
else
{
tokens.Add(tokenizer.Current);
}
}
// this is the fall through if none of the "returns" hit above
// will also hit if we parse a simple single column expression, e.g. "SELECT blah"
TSQLColumnExpression simpleColumn = new TSQLColumnExpression();
simpleColumn.Tokens.AddRange(tokens);
List <TSQLToken> simpleColumnReference = tokens
.Where(t =>
!t.IsComment() &&
!t.IsWhitespace() &&
!t.IsCharacter(TSQLCharacters.Semicolon))
.ToList();
if (simpleColumnReference.Count > 1)
{
// p.ProductID will have the single token p in the final list
// AdventureWorks..ErrorLog.ErrorLogID will have 4 tokens in the final list
// e.g. {AdventureWorks, ., ., ErrorLog}
simpleColumn.TableReference = simpleColumnReference
.GetRange(0, simpleColumnReference
.FindLastIndex(t => t.IsCharacter(TSQLCharacters.Period)))
.ToList();
}
simpleColumn.Column = simpleColumnReference
.Last()
.AsIdentifier;
return(simpleColumn);
}
else
{
return(null);
}
}
public TSQLSetOperatorClause Parse(ITSQLTokenizer tokenizer)
{
TSQLSetOperatorClause set = null;
if (tokenizer.Current.IsKeyword(TSQLKeywords.UNION))
{
set = new TSQLUnionClause();
set.Tokens.Add(tokenizer.Current);
TSQLTokenParserHelper.ReadThroughAnyCommentsOrWhitespace(
tokenizer,
set.Tokens);
if (tokenizer.Current.IsKeyword(TSQLKeywords.ALL))
{
set.Tokens.Add(tokenizer.Current);
tokenizer.MoveNext();
}
}
else if (tokenizer.Current.IsKeyword(TSQLKeywords.EXCEPT))
{
set = new TSQLExceptClause();
set.Tokens.Add(tokenizer.Current);
tokenizer.MoveNext();
}
else if (tokenizer.Current.IsKeyword(TSQLKeywords.INTERSECT))
{
set = new TSQLIntersectClause();
set.Tokens.Add(tokenizer.Current);
tokenizer.MoveNext();
}
TSQLTokenParserHelper.ReadCommentsAndWhitespace(
tokenizer,
set);
int level = 0;
while (tokenizer.Current.IsCharacter(TSQLCharacters.OpenParentheses))
{
set.Tokens.Add(tokenizer.Current);
level++;
tokenizer.MoveNext();
}
TSQLTokenParserHelper.ReadCommentsAndWhitespace(
tokenizer,
set);
TSQLSelectStatement select = new TSQLLimitedSelectStatementParser(tokenizer).Parse();
set.Select = select;
set.Tokens.AddRange(select.Tokens);
while (level > 0 && tokenizer.Current.IsCharacter(TSQLCharacters.CloseParentheses))
{
set.Tokens.Add(tokenizer.Current);
level--;
tokenizer.MoveNext();
}
TSQLTokenParserHelper.ReadCommentsAndWhitespace(
tokenizer,
set);
return(set);
}
