public TSQLIntoClause Parse(TSQLTokenizer tokenizer) { TSQLIntoClause into = new TSQLIntoClause(); if ( tokenizer.Current == null || tokenizer.Current.Type != TSQLTokenType.Keyword || tokenizer.Current.AsKeyword.Keyword != TSQLKeywords.INTO) { throw new ApplicationException("INTO expected."); } into.Tokens.Add(tokenizer.Current); while ( tokenizer.Read() && ( tokenizer.Current.Type == TSQLTokenType.Identifier || ( tokenizer.Current.Type == TSQLTokenType.Character && tokenizer.Current.AsCharacter.Character == TSQLCharacters.Period ) || tokenizer.Current.Type == TSQLTokenType.Whitespace || tokenizer.Current.Type == TSQLTokenType.SingleLineComment || tokenizer.Current.Type == TSQLTokenType.MultilineComment )) { into.Tokens.Add(tokenizer.Current); } return into; }
public TSQLIntoClause Parse(TSQLTokenizer tokenizer) { TSQLIntoClause into = new TSQLIntoClause(); if ( tokenizer.Current == null || tokenizer.Current.Type != TSQLTokenType.Keyword || tokenizer.Current.AsKeyword.Keyword != TSQLKeywords.INTO) { throw new ApplicationException("INTO expected."); } into.Tokens.Add(tokenizer.Current); while ( tokenizer.Read() && ( tokenizer.Current.Type == TSQLTokenType.Identifier || ( tokenizer.Current.Type == TSQLTokenType.Character && tokenizer.Current.AsCharacter.Character == TSQLCharacters.Period ) || tokenizer.Current.Type == TSQLTokenType.Whitespace || tokenizer.Current.Type == TSQLTokenType.SingleLineComment || tokenizer.Current.Type == TSQLTokenType.MultilineComment )) { into.Tokens.Add(tokenizer.Current); } return(into); }
public void SelectClause_StopAtFrom() { using (StringReader reader = new StringReader(@"select a from b;")) using (TSQLTokenizer tokenizer = new TSQLTokenizer(reader)) { Assert.IsTrue(tokenizer.Read()); TSQLSelectClause select = new TSQLSelectClauseParser().Parse(tokenizer); Assert.AreEqual(2, select.Tokens.Count); Assert.AreEqual(TSQLKeywords.FROM, tokenizer.Current.AsKeyword.Keyword); } }
public TSQLUnknownStatement Parse(TSQLTokenizer tokenizer) { TSQLUnknownStatement statement = new TSQLUnknownStatement(); while ( tokenizer.Read() && !( tokenizer.Current is TSQLCharacter && tokenizer.Current.AsCharacter.Character == TSQLCharacters.Semicolon )) { statement.Tokens.Add(tokenizer.Current); } if ( tokenizer.Current != null && tokenizer.Current is TSQLCharacter && tokenizer.Current.AsCharacter.Character == TSQLCharacters.Semicolon) { statement.Tokens.Add(tokenizer.Current); } return statement; }
public TSQLUnknownStatement Parse(TSQLTokenizer tokenizer) { TSQLUnknownStatement statement = new TSQLUnknownStatement(); while ( tokenizer.Read() && !( tokenizer.Current is TSQLCharacter && tokenizer.Current.AsCharacter.Character == TSQLCharacters.Semicolon )) { statement.Tokens.Add(tokenizer.Current); } if ( tokenizer.Current != null && tokenizer.Current is TSQLCharacter && tokenizer.Current.AsCharacter.Character == TSQLCharacters.Semicolon) { statement.Tokens.Add(tokenizer.Current); } return(statement); }
public TSQLHavingClause Parse(TSQLTokenizer tokenizer) { TSQLHavingClause having = new TSQLHavingClause(); if ( tokenizer.Current == null || tokenizer.Current.Type != TSQLTokenType.Keyword || tokenizer.Current.AsKeyword.Keyword != TSQLKeywords.HAVING) { throw new ApplicationException("HAVING expected."); } having.Tokens.Add(tokenizer.Current); // subqueries int nestedLevel = 0; while ( tokenizer.Read() && !( tokenizer.Current.Type == TSQLTokenType.Character && tokenizer.Current.AsCharacter.Character == TSQLCharacters.Semicolon ) && !( nestedLevel == 0 && tokenizer.Current.Type == TSQLTokenType.Character && tokenizer.Current.AsCharacter.Character == TSQLCharacters.CloseParentheses ) && ( nestedLevel > 0 || tokenizer.Current.Type != TSQLTokenType.Keyword || ( tokenizer.Current.Type == TSQLTokenType.Keyword && tokenizer.Current.AsKeyword.Keyword.In ( TSQLKeywords.NULL, TSQLKeywords.CASE, TSQLKeywords.WHEN, TSQLKeywords.THEN, TSQLKeywords.ELSE, TSQLKeywords.AND, TSQLKeywords.OR, TSQLKeywords.BETWEEN, TSQLKeywords.EXISTS, TSQLKeywords.END, TSQLKeywords.IN, TSQLKeywords.IS, TSQLKeywords.NOT, TSQLKeywords.LIKE ) ) )) { having.Tokens.Add(tokenizer.Current); if (tokenizer.Current.Type == TSQLTokenType.Character) { TSQLCharacters character = tokenizer.Current.AsCharacter.Character; if (character == TSQLCharacters.OpenParentheses) { // should we recurse for subqueries? nestedLevel++; if (tokenizer.Read()) { if ( tokenizer.Current.Type == TSQLTokenType.Keyword && tokenizer.Current.AsKeyword.Keyword == TSQLKeywords.SELECT) { TSQLSelectStatement selectStatement = new TSQLSelectStatementParser().Parse(tokenizer); having.Tokens.AddRange(selectStatement.Tokens); if ( tokenizer.Current != null && tokenizer.Current.Type == TSQLTokenType.Character && tokenizer.Current.AsCharacter.Character == TSQLCharacters.CloseParentheses) { nestedLevel--; having.Tokens.Add(tokenizer.Current); } } else { having.Tokens.Add(tokenizer.Current); } } } else if (character == TSQLCharacters.CloseParentheses) { nestedLevel--; } } } return(having); }
public TSQLSelectClause Parse(TSQLTokenizer tokenizer) { TSQLSelectClause select = new TSQLSelectClause(); if ( tokenizer.Current == null || tokenizer.Current.Type != TSQLTokenType.Keyword || tokenizer.Current.AsKeyword.Keyword != TSQLKeywords.SELECT) { throw new ApplicationException("SELECT expected."); } select.Tokens.Add(tokenizer.Current); // can contain ALL, DISTINCT, TOP, PERCENT, WITH TIES, AS // ends with FROM, semicolon, or keyword other than those listed above, when used outside of parens // recursively walk down and back up parens int nestedLevel = 0; while ( tokenizer.Read() && !( tokenizer.Current.Type == TSQLTokenType.Character && tokenizer.Current.AsCharacter.Character == TSQLCharacters.Semicolon ) && !( nestedLevel == 0 && tokenizer.Current.Type == TSQLTokenType.Character && tokenizer.Current.AsCharacter.Character == TSQLCharacters.CloseParentheses ) && ( nestedLevel > 0 || tokenizer.Current.Type != TSQLTokenType.Keyword || ( tokenizer.Current.Type == TSQLTokenType.Keyword && tokenizer.Current.AsKeyword.Keyword.In ( TSQLKeywords.ALL, TSQLKeywords.AS, TSQLKeywords.DISTINCT, TSQLKeywords.PERCENT, TSQLKeywords.TOP, TSQLKeywords.WITH, TSQLKeywords.NULL, TSQLKeywords.CASE, TSQLKeywords.WHEN, TSQLKeywords.THEN, TSQLKeywords.ELSE, TSQLKeywords.AND, TSQLKeywords.OR, TSQLKeywords.BETWEEN, TSQLKeywords.EXISTS, TSQLKeywords.END, TSQLKeywords.IN, TSQLKeywords.IS, TSQLKeywords.NOT, TSQLKeywords.OVER, TSQLKeywords.IDENTITY, TSQLKeywords.LIKE ) ) )) { select.Tokens.Add(tokenizer.Current); if (tokenizer.Current.Type == TSQLTokenType.Character) { TSQLCharacters character = tokenizer.Current.AsCharacter.Character; if (character == TSQLCharacters.OpenParentheses) { // should we recurse for correlated subqueries? nestedLevel++; if (tokenizer.Read()) { if ( tokenizer.Current.Type == TSQLTokenType.Keyword && tokenizer.Current.AsKeyword.Keyword == TSQLKeywords.SELECT) { TSQLSelectStatement selectStatement = new TSQLSelectStatementParser().Parse(tokenizer); select.Tokens.AddRange(selectStatement.Tokens); if ( tokenizer.Current != null && tokenizer.Current.Type == TSQLTokenType.Character && tokenizer.Current.AsCharacter.Character == TSQLCharacters.CloseParentheses) { nestedLevel--; select.Tokens.Add(tokenizer.Current); } } else { select.Tokens.Add(tokenizer.Current); } } } else if (character == TSQLCharacters.CloseParentheses) { nestedLevel--; } } } return(select); }
public TSQLHavingClause Parse(TSQLTokenizer tokenizer) { TSQLHavingClause having = new TSQLHavingClause(); if ( tokenizer.Current == null || tokenizer.Current.Type != TSQLTokenType.Keyword || tokenizer.Current.AsKeyword.Keyword != TSQLKeywords.HAVING) { throw new ApplicationException("HAVING expected."); } having.Tokens.Add(tokenizer.Current); // subqueries int nestedLevel = 0; while ( tokenizer.Read() && !( tokenizer.Current.Type == TSQLTokenType.Character && tokenizer.Current.AsCharacter.Character == TSQLCharacters.Semicolon ) && !( nestedLevel == 0 && tokenizer.Current.Type == TSQLTokenType.Character && tokenizer.Current.AsCharacter.Character == TSQLCharacters.CloseParentheses ) && ( nestedLevel > 0 || tokenizer.Current.Type != TSQLTokenType.Keyword || ( tokenizer.Current.Type == TSQLTokenType.Keyword && tokenizer.Current.AsKeyword.Keyword.In ( TSQLKeywords.NULL, TSQLKeywords.CASE, TSQLKeywords.WHEN, TSQLKeywords.THEN, TSQLKeywords.ELSE, TSQLKeywords.AND, TSQLKeywords.OR, TSQLKeywords.BETWEEN, TSQLKeywords.EXISTS, TSQLKeywords.END, TSQLKeywords.IN, TSQLKeywords.IS, TSQLKeywords.NOT, TSQLKeywords.LIKE ) ) )) { having.Tokens.Add(tokenizer.Current); if (tokenizer.Current.Type == TSQLTokenType.Character) { TSQLCharacters character = tokenizer.Current.AsCharacter.Character; if (character == TSQLCharacters.OpenParentheses) { // should we recurse for subqueries? nestedLevel++; if (tokenizer.Read()) { if ( tokenizer.Current.Type == TSQLTokenType.Keyword && tokenizer.Current.AsKeyword.Keyword == TSQLKeywords.SELECT) { TSQLSelectStatement selectStatement = new TSQLSelectStatementParser().Parse(tokenizer); having.Tokens.AddRange(selectStatement.Tokens); if ( tokenizer.Current != null && tokenizer.Current.Type == TSQLTokenType.Character && tokenizer.Current.AsCharacter.Character == TSQLCharacters.CloseParentheses) { nestedLevel--; having.Tokens.Add(tokenizer.Current); } } else { having.Tokens.Add(tokenizer.Current); } } } else if (character == TSQLCharacters.CloseParentheses) { nestedLevel--; } } } return having; }
public TSQLFromClause Parse(TSQLTokenizer tokenizer) { TSQLFromClause from = new TSQLFromClause(); if ( tokenizer.Current == null || tokenizer.Current.Type != TSQLTokenType.Keyword || tokenizer.Current.AsKeyword.Keyword != TSQLKeywords.FROM) { throw new ApplicationException("FROM expected."); } from.Tokens.Add(tokenizer.Current); // derived tables // TVF int nestedLevel = 0; while ( tokenizer.Read() && !( tokenizer.Current.Type == TSQLTokenType.Character && tokenizer.Current.AsCharacter.Character == TSQLCharacters.Semicolon ) && !( nestedLevel == 0 && tokenizer.Current.Type == TSQLTokenType.Character && tokenizer.Current.AsCharacter.Character == TSQLCharacters.CloseParentheses ) && ( nestedLevel > 0 || tokenizer.Current.Type != TSQLTokenType.Keyword || ( tokenizer.Current.Type == TSQLTokenType.Keyword && tokenizer.Current.AsKeyword.Keyword.In ( TSQLKeywords.JOIN, TSQLKeywords.ON, TSQLKeywords.INNER, TSQLKeywords.LEFT, TSQLKeywords.RIGHT, TSQLKeywords.OUTER, TSQLKeywords.CROSS, TSQLKeywords.FULL, TSQLKeywords.AS, TSQLKeywords.PIVOT, TSQLKeywords.UNPIVOT, TSQLKeywords.WITH, TSQLKeywords.MERGE, TSQLKeywords.TABLESAMPLE, TSQLKeywords.FOR, TSQLKeywords.FROM, // FOR SYSTEM_TIME FROM TSQLKeywords.BETWEEN, TSQLKeywords.AND, TSQLKeywords.IN, TSQLKeywords.REPEATABLE, TSQLKeywords.ALL ) ) )) { from.Tokens.Add(tokenizer.Current); if (tokenizer.Current.Type == TSQLTokenType.Character) { TSQLCharacters character = tokenizer.Current.AsCharacter.Character; if (character == TSQLCharacters.OpenParentheses) { // should we recurse for derived tables? nestedLevel++; if (tokenizer.Read()) { if ( tokenizer.Current.Type == TSQLTokenType.Keyword && tokenizer.Current.AsKeyword.Keyword == TSQLKeywords.SELECT) { TSQLSelectStatement selectStatement = new TSQLSelectStatementParser().Parse(tokenizer); from.Tokens.AddRange(selectStatement.Tokens); if ( tokenizer.Current != null && tokenizer.Current.Type == TSQLTokenType.Character && tokenizer.Current.AsCharacter.Character == TSQLCharacters.CloseParentheses) { nestedLevel--; from.Tokens.Add(tokenizer.Current); } } else { from.Tokens.Add(tokenizer.Current); } } } else if (character == TSQLCharacters.CloseParentheses) { nestedLevel--; } } } return(from); }
public TSQLOrderByClause Parse(TSQLTokenizer tokenizer) { TSQLOrderByClause orderBy = new TSQLOrderByClause(); TSQLKeyword keyword = tokenizer.Current.AsKeyword; if (keyword == null || keyword.Keyword != TSQLKeywords.ORDER) { throw new ApplicationException("ORDER expected."); } orderBy.Tokens.Add(keyword); // subqueries int nestedLevel = 0; while ( tokenizer.Read() && !( tokenizer.Current.Type == TSQLTokenType.Character && tokenizer.Current.AsCharacter.Character == TSQLCharacters.Semicolon ) && !( nestedLevel == 0 && tokenizer.Current.Type == TSQLTokenType.Character && tokenizer.Current.AsCharacter.Character == TSQLCharacters.CloseParentheses ) && ( nestedLevel > 0 || tokenizer.Current.Type != TSQLTokenType.Keyword || ( tokenizer.Current.Type == TSQLTokenType.Keyword && tokenizer.Current.AsKeyword.Keyword.In ( TSQLKeywords.BY, TSQLKeywords.NULL, TSQLKeywords.CASE, TSQLKeywords.WHEN, TSQLKeywords.THEN, TSQLKeywords.ELSE, TSQLKeywords.AND, TSQLKeywords.OR, TSQLKeywords.BETWEEN, TSQLKeywords.EXISTS, TSQLKeywords.END, TSQLKeywords.IN, TSQLKeywords.IS, TSQLKeywords.NOT, TSQLKeywords.OVER, TSQLKeywords.LIKE, TSQLKeywords.ASC, TSQLKeywords.DESC, TSQLKeywords.FETCH, TSQLKeywords.COLLATE ) ) )) { orderBy.Tokens.Add(tokenizer.Current); if (tokenizer.Current.Type == TSQLTokenType.Character) { TSQLCharacters character = tokenizer.Current.AsCharacter.Character; if (character == TSQLCharacters.OpenParentheses) { // should we recurse for subqueries? nestedLevel++; if (tokenizer.Read()) { if ( tokenizer.Current.Type == TSQLTokenType.Keyword && tokenizer.Current.AsKeyword.Keyword == TSQLKeywords.SELECT) { TSQLSelectStatement selectStatement = new TSQLSelectStatementParser().Parse(tokenizer); orderBy.Tokens.AddRange(selectStatement.Tokens); if ( tokenizer.Current != null && tokenizer.Current.Type == TSQLTokenType.Character && tokenizer.Current.AsCharacter.Character == TSQLCharacters.CloseParentheses) { nestedLevel--; orderBy.Tokens.Add(tokenizer.Current); } } else { orderBy.Tokens.Add(tokenizer.Current); } } } else if (character == TSQLCharacters.CloseParentheses) { nestedLevel--; } } } return(orderBy); }
public TSQLFromClause Parse(TSQLTokenizer tokenizer) { TSQLFromClause from = new TSQLFromClause(); if ( tokenizer.Current == null || tokenizer.Current.Type != TSQLTokenType.Keyword || tokenizer.Current.AsKeyword.Keyword != TSQLKeywords.FROM) { throw new ApplicationException("FROM expected."); } from.Tokens.Add(tokenizer.Current); // derived tables // TVF int nestedLevel = 0; while ( tokenizer.Read() && !( tokenizer.Current.Type == TSQLTokenType.Character && tokenizer.Current.AsCharacter.Character == TSQLCharacters.Semicolon ) && !( nestedLevel == 0 && tokenizer.Current.Type == TSQLTokenType.Character && tokenizer.Current.AsCharacter.Character == TSQLCharacters.CloseParentheses ) && ( nestedLevel > 0 || tokenizer.Current.Type != TSQLTokenType.Keyword || ( tokenizer.Current.Type == TSQLTokenType.Keyword && tokenizer.Current.AsKeyword.Keyword.In ( TSQLKeywords.JOIN, TSQLKeywords.ON, TSQLKeywords.INNER, TSQLKeywords.LEFT, TSQLKeywords.RIGHT, TSQLKeywords.OUTER, TSQLKeywords.CROSS, TSQLKeywords.FULL, TSQLKeywords.AS, TSQLKeywords.PIVOT, TSQLKeywords.UNPIVOT, TSQLKeywords.WITH, TSQLKeywords.MERGE, TSQLKeywords.TABLESAMPLE, TSQLKeywords.FOR, TSQLKeywords.FROM, // FOR SYSTEM_TIME FROM TSQLKeywords.BETWEEN, TSQLKeywords.AND, TSQLKeywords.IN, TSQLKeywords.REPEATABLE, TSQLKeywords.ALL ) ) )) { from.Tokens.Add(tokenizer.Current); if (tokenizer.Current.Type == TSQLTokenType.Character) { TSQLCharacters character = tokenizer.Current.AsCharacter.Character; if (character == TSQLCharacters.OpenParentheses) { // should we recurse for derived tables? nestedLevel++; if (tokenizer.Read()) { if ( tokenizer.Current.Type == TSQLTokenType.Keyword && tokenizer.Current.AsKeyword.Keyword == TSQLKeywords.SELECT) { TSQLSelectStatement selectStatement = new TSQLSelectStatementParser().Parse(tokenizer); from.Tokens.AddRange(selectStatement.Tokens); if ( tokenizer.Current != null && tokenizer.Current.Type == TSQLTokenType.Character && tokenizer.Current.AsCharacter.Character == TSQLCharacters.CloseParentheses) { nestedLevel--; from.Tokens.Add(tokenizer.Current); } } else { from.Tokens.Add(tokenizer.Current); } } } else if (character == TSQLCharacters.CloseParentheses) { nestedLevel--; } } } return from; }
public TSQLSelectClause Parse(TSQLTokenizer tokenizer) { TSQLSelectClause select = new TSQLSelectClause(); if ( tokenizer.Current == null || tokenizer.Current.Type != TSQLTokenType.Keyword || tokenizer.Current.AsKeyword.Keyword != TSQLKeywords.SELECT) { throw new ApplicationException("SELECT expected."); } select.Tokens.Add(tokenizer.Current); // can contain ALL, DISTINCT, TOP, PERCENT, WITH TIES, AS // ends with FROM, semicolon, or keyword other than those listed above, when used outside of parens // recursively walk down and back up parens int nestedLevel = 0; while ( tokenizer.Read() && !( tokenizer.Current.Type == TSQLTokenType.Character && tokenizer.Current.AsCharacter.Character == TSQLCharacters.Semicolon ) && !( nestedLevel == 0 && tokenizer.Current.Type == TSQLTokenType.Character && tokenizer.Current.AsCharacter.Character == TSQLCharacters.CloseParentheses ) && ( nestedLevel > 0 || tokenizer.Current.Type != TSQLTokenType.Keyword || ( tokenizer.Current.Type == TSQLTokenType.Keyword && tokenizer.Current.AsKeyword.Keyword.In ( TSQLKeywords.ALL, TSQLKeywords.AS, TSQLKeywords.DISTINCT, TSQLKeywords.PERCENT, TSQLKeywords.TOP, TSQLKeywords.WITH, TSQLKeywords.NULL, TSQLKeywords.CASE, TSQLKeywords.WHEN, TSQLKeywords.THEN, TSQLKeywords.ELSE, TSQLKeywords.AND, TSQLKeywords.OR, TSQLKeywords.BETWEEN, TSQLKeywords.EXISTS, TSQLKeywords.END, TSQLKeywords.IN, TSQLKeywords.IS, TSQLKeywords.NOT, TSQLKeywords.OVER, TSQLKeywords.IDENTITY, TSQLKeywords.LIKE ) ) )) { select.Tokens.Add(tokenizer.Current); if (tokenizer.Current.Type == TSQLTokenType.Character) { TSQLCharacters character = tokenizer.Current.AsCharacter.Character; if (character == TSQLCharacters.OpenParentheses) { // should we recurse for correlated subqueries? nestedLevel++; if (tokenizer.Read()) { if ( tokenizer.Current.Type == TSQLTokenType.Keyword && tokenizer.Current.AsKeyword.Keyword == TSQLKeywords.SELECT) { TSQLSelectStatement selectStatement = new TSQLSelectStatementParser().Parse(tokenizer); select.Tokens.AddRange(selectStatement.Tokens); if ( tokenizer.Current != null && tokenizer.Current.Type == TSQLTokenType.Character && tokenizer.Current.AsCharacter.Character == TSQLCharacters.CloseParentheses) { nestedLevel--; select.Tokens.Add(tokenizer.Current); } } else { select.Tokens.Add(tokenizer.Current); } } } else if (character == TSQLCharacters.CloseParentheses) { nestedLevel--; } } } return select; }
public TSQLOrderByClause Parse(TSQLTokenizer tokenizer) { TSQLOrderByClause orderBy = new TSQLOrderByClause(); TSQLKeyword keyword = tokenizer.Current.AsKeyword; if (keyword == null || keyword.Keyword != TSQLKeywords.ORDER) { throw new ApplicationException("ORDER expected."); } orderBy.Tokens.Add(keyword); // subqueries int nestedLevel = 0; while ( tokenizer.Read() && !( tokenizer.Current.Type == TSQLTokenType.Character && tokenizer.Current.AsCharacter.Character == TSQLCharacters.Semicolon ) && !( nestedLevel == 0 && tokenizer.Current.Type == TSQLTokenType.Character && tokenizer.Current.AsCharacter.Character == TSQLCharacters.CloseParentheses ) && ( nestedLevel > 0 || tokenizer.Current.Type != TSQLTokenType.Keyword || ( tokenizer.Current.Type == TSQLTokenType.Keyword && tokenizer.Current.AsKeyword.Keyword.In ( TSQLKeywords.BY, TSQLKeywords.NULL, TSQLKeywords.CASE, TSQLKeywords.WHEN, TSQLKeywords.THEN, TSQLKeywords.ELSE, TSQLKeywords.AND, TSQLKeywords.OR, TSQLKeywords.BETWEEN, TSQLKeywords.EXISTS, TSQLKeywords.END, TSQLKeywords.IN, TSQLKeywords.IS, TSQLKeywords.NOT, TSQLKeywords.OVER, TSQLKeywords.LIKE, TSQLKeywords.ASC, TSQLKeywords.DESC, TSQLKeywords.FETCH, TSQLKeywords.COLLATE ) ) )) { orderBy.Tokens.Add(tokenizer.Current); if (tokenizer.Current.Type == TSQLTokenType.Character) { TSQLCharacters character = tokenizer.Current.AsCharacter.Character; if (character == TSQLCharacters.OpenParentheses) { // should we recurse for subqueries? nestedLevel++; if (tokenizer.Read()) { if ( tokenizer.Current.Type == TSQLTokenType.Keyword && tokenizer.Current.AsKeyword.Keyword == TSQLKeywords.SELECT) { TSQLSelectStatement selectStatement = new TSQLSelectStatementParser().Parse(tokenizer); orderBy.Tokens.AddRange(selectStatement.Tokens); if ( tokenizer.Current != null && tokenizer.Current.Type == TSQLTokenType.Character && tokenizer.Current.AsCharacter.Character == TSQLCharacters.CloseParentheses) { nestedLevel--; orderBy.Tokens.Add(tokenizer.Current); } } else { orderBy.Tokens.Add(tokenizer.Current); } } } else if (character == TSQLCharacters.CloseParentheses) { nestedLevel--; } } } return orderBy; }