public override CreateViewStatement Execute()
{
_statement = new CreateViewStatement()
{
Name = GetDotNotationIdentifier(), IsAlter = IsAlter
};
ExpectToken(Constants.As);
if (Tokenizer.IsNextToken(Constants.Select))
{
ReadNextToken();
var parser = new SelectStatementParser(Tokenizer);
_statement.Definition = parser.Execute();
}
else if (Tokenizer.IsNextToken(Constants.With))
{
ReadNextToken();
var parser = new CommonTableExpressionStatementParser(Tokenizer);
_statement.Definition = parser.Execute();
}
return(_statement);
}
private void ProcessSelect()
{
ReadNextToken();
SelectExpression selectExpression = new SelectExpression();
var parser = new SelectStatementParser(Tokenizer);
_statement.SourceStatement = parser.Execute();
}
private Expression GetSelectExpression()
{
ReadNextToken();
SelectExpression selectExpression = new SelectExpression();
var parser = new SelectStatementParser(Tokenizer);
selectExpression.Statement = (SelectStatement)parser.Execute();
return(selectExpression);
}
public override CreateViewStatement Execute()
{
_statement = new CreateViewStatement();
_statement.Name = GetIdentifier();
ExpectTokens(Constants.As, Constants.Select);
SelectStatementParser parser = new SelectStatementParser(Tokenizer);
_statement.SelectBlock = parser.Execute() as SelectStatement;
return(_statement);
}
public override CommonTableExpressionStatement Execute()
{
_statement = new CommonTableExpressionStatement();
do
{
var commonTableExpression = new CommonTableExpression();
commonTableExpression.Name = GetDotNotationIdentifier();
if (Tokenizer.IsNextToken(Constants.OpenBracket))
{
using (Tokenizer.ExpectBrackets())
{
commonTableExpression.ColumnNames.AddRange(GetIdentifierList());
}
}
ExpectToken(Constants.As);
using (Tokenizer.ExpectBrackets())
{
ExpectToken(Constants.Select);
var parser = new SelectStatementParser(Tokenizer);
var statement = parser.Execute();
commonTableExpression.Fields = statement.Fields;
commonTableExpression.From = statement.From;
commonTableExpression.Top = statement.Top;
commonTableExpression.Distinct = statement.Distinct;
commonTableExpression.GroupBy = statement.GroupBy;
commonTableExpression.OrderBy = statement.OrderBy;
commonTableExpression.Having = statement.Having;
commonTableExpression.Where = statement.Where;
commonTableExpression.SetOperation = statement.SetOperation;
}
_statement.CommonTableExpressions.Add(commonTableExpression);
}while (Tokenizer.HasMoreTokens && Tokenizer.TokenEquals(Constants.Comma));
ExpectToken(Constants.Select);
var statementParser = new SelectStatementParser(Tokenizer);
_statement.Statement = statementParser.Execute();
return(_statement);
}
private Expression ReadTerm(Expression parent)
{
Expression factor = ReadFactor(parent);
if (Tokenizer.IsNextToken(Constants.Over))
{
var rankingFunctionExpression = new RankingFunctionExpression(parent);
rankingFunctionExpression.Name = factor.Value;
ReadNextToken();
using (Tokenizer.ExpectBrackets())
{
if (Tokenizer.TokenEquals(Constants.Partition))
{
ExpectToken(Constants.By);
var selectStatementParser = new SelectStatementParser(Tokenizer);
selectStatementParser.ProcessFields(FieldType.OrderBy, rankingFunctionExpression.PartitionBy);
}
if (Tokenizer.IsNextToken(Constants.Order))
{
ReadNextToken();
ExpectToken(Constants.By);
var selectStatementParser = new SelectStatementParser(Tokenizer);
selectStatementParser.ProcessFields(FieldType.OrderBy, rankingFunctionExpression.OrderBy);
}
}
return(rankingFunctionExpression);
}
else if (Tokenizer.IsNextToken("*", "/", "%", "^"))
{
OperatorExpression result = new OperatorExpression(parent);
result.Left = factor;
result.Operator = CurrentToken;
ReadNextToken();
result.Right = ReadExpression(parent);
return(result);
}
return(factor);
}
private void ProcessJoins(Table table)
{
if (!Tokenizer.HasMoreTokens)
{
return;
}
do
{
JoinType?joinType = GetJoinType();
if (joinType == null)
{
return;
}
ExpectToken(Constants.Join);
Join join = null;
if (Tokenizer.IsNextToken(Constants.OpenBracket))
{
using (Tokenizer.ExpectBrackets())
{
join = new DerivedJoin {
Type = joinType.Value
};
Tokenizer.ExpectToken(Constants.Select);
var parser = new SelectStatementParser(Tokenizer);
((DerivedJoin)join).SelectStatement = (SelectStatement)parser.Execute();
}
}
else
{
join = new Join {
Type = joinType.Value
};
join.Name = GetTableName();
}
Debug.Assert(join != null);
Alias alias = new Alias(null);
if (Tokenizer.IsNextToken(Constants.As))
{
alias.Type = AliasType.As;
Tokenizer.ReadNextToken();
}
if (alias.Type != AliasType.Implicit || !Tokenizer.IsNextToken(Constants.On))
{
alias.Name = GetIdentifier();
join.Alias = alias;
}
ProcessTableHints(join);
ExpectToken(Constants.On);
Expression expr = ProcessExpression();
if (!(expr is CriteriaExpression) && !(expr is NestedExpression && (expr as NestedExpression).Expression is CriteriaExpression))
{
throw new SyntaxException("Expected Criteria Expression");
}
join.Condition = expr;
table.Joins.Add(join);
}while (Tokenizer.HasMoreTokens && !Tokenizer.IsNextToken(Constants.Order, Constants.Group));
}
protected void ProcessFrom()
{
if (!Tokenizer.TokenEquals(Constants.From))
{
return;
}
do
{
Table table = null;
if (Tokenizer.IsNextToken(Constants.OpenBracket))
{
using (Tokenizer.ExpectBrackets())
{
DerivedTable derivedTable = new DerivedTable();
Tokenizer.ExpectToken(Constants.Select);
var parser = new SelectStatementParser(Tokenizer);
derivedTable.SelectStatement = (SelectStatement)parser.Execute();
table = derivedTable;
}
}
else
{
table = new Table {
Name = GetTableName()
}
};
_statement.From.Add(table);
// TODO: This needs to be changed to test Tokenizer.Token.Current.TokenType for TokenType.Keyword
// if a new statement is initiated here, do not process the alias
if (IsTerminatingFromExpression())
{
return;
}
Alias alias = new Alias(null);
if (Tokenizer.IsNextToken(Constants.As))
{
alias.Type = AliasType.As;
Tokenizer.ReadNextToken();
}
if (!Tokenizer.IsNextToken(Constants.OpenBracket) && (alias.Type != AliasType.Implicit || !Tokenizer.IsNextToken(FromTerminatorSet)))
{
if (Tokenizer.HasMoreTokens)
{
if (!Tokenizer.Current.IsTypeIn(
TokenType.AlphaNumeric, TokenType.AlphaNumeric, TokenType.BlockedText, TokenType.SingleQuote
)
)
{
throw new SyntaxException(String.Format("Incorrect syntax near '{0}'", CurrentToken));
}
alias.Name = CurrentToken;
table.Alias = alias;
ReadNextToken();
}
}
ProcessTableHints(table);
ProcessJoins(table);
}while (Tokenizer.HasMoreTokens && Tokenizer.TokenEquals(Constants.Comma));
}
