private SqlNode ParseSelectItemAlias()
{
SqlNode node = new SqlNode(SqlNodeType.SelectItemAlias);
switch (this._token.Type)
{
case SqlTokenType.AS:
{
node.Nodes.Add(ParseAS());
node.Nodes.Add(ParseIDENTIFIER());
return(node);
}
case SqlTokenType.IDENTIFIER:
{
node.Nodes.Add(ParseIDENTIFIER());
return(node);
}
default:
{
return(node);
}
}
}
private SqlNode ParseLogicalOperator()
{
SqlNode node = new SqlNode(SqlNodeType.LogicalOperator);
switch (this._token.Type)
{
case SqlTokenType.AND:
{
node.Nodes.Add(ParseAND());
return(node);
}
case SqlTokenType.OR:
{
node.Nodes.Add(ParseOR());
return(node);
}
case SqlTokenType.NOT:
{
node.Nodes.Add(ParseNOT());
return(node);
}
default:
{
throw new System.Exception("Syntax error.");
}
}
}
private SqlNode ParseJoinList()
{
SqlNode node = new SqlNode(SqlNodeType.JoinList);
switch (this._token.Type)
{
case SqlTokenType.INNER:
{
node.Nodes.Add(ParseINNER());
node.Nodes.Add(ParseJOIN());
node.Nodes.Add(ParseIDENTIFIER());
node.Nodes.Add(ParseTableTail());
node.Nodes.Add(ParseON());
node.Nodes.Add(ParseIDENTIFIER());
node.Nodes.Add(ParseComparisonOperator());
node.Nodes.Add(ParseIDENTIFIER());
node.Nodes.Add(ParseJoinList());
return(node);
}
case SqlTokenType.LEFT:
{
node.Nodes.Add(ParseLEFT());
node.Nodes.Add(ParseOUTER());
node.Nodes.Add(ParseJOIN());
node.Nodes.Add(ParseIDENTIFIER());
node.Nodes.Add(ParseTableTail());
node.Nodes.Add(ParseON());
node.Nodes.Add(ParseIDENTIFIER());
node.Nodes.Add(ParseComparisonOperator());
node.Nodes.Add(ParseIDENTIFIER());
node.Nodes.Add(ParseJoinList());
return(node);
}
case SqlTokenType.RIGHT:
{
node.Nodes.Add(ParseRIGHT());
node.Nodes.Add(ParseOUTER());
node.Nodes.Add(ParseJOIN());
node.Nodes.Add(ParseIDENTIFIER());
node.Nodes.Add(ParseTableTail());
node.Nodes.Add(ParseON());
node.Nodes.Add(ParseIDENTIFIER());
node.Nodes.Add(ParseComparisonOperator());
node.Nodes.Add(ParseIDENTIFIER());
node.Nodes.Add(ParseJoinList());
return(node);
}
default:
{
return(node);
}
}
}
protected override object EvaluateSelectUnionStatementTail(SqlNode node)
{
if (node.Nodes[1].Nodes.Count == 0)
{
return(this.Evaluate(node.Nodes[0]));
}
else
{
return(new UnionStatement(this.Evaluate(node.Nodes[0]), this.Evaluate(node.Nodes[1].Nodes[1])));
}
}
private SqlNode ParseComparisonOperator()
{
SqlNode node = new SqlNode(SqlNodeType.ComparisonOperator);
switch (this._token.Type)
{
case SqlTokenType.EQUALS:
{
node.Nodes.Add(ParseEQUALS());
return(node);
}
case SqlTokenType.GREATER_THAN:
{
node.Nodes.Add(ParseGREATER_THAN());
return(node);
}
case SqlTokenType.GREATER_THAN_OR_EQUAL:
{
node.Nodes.Add(ParseGREATER_THAN_OR_EQUAL());
return(node);
}
case SqlTokenType.LESS_THAN:
{
node.Nodes.Add(ParseLESS_THAN());
return(node);
}
case SqlTokenType.LESS_THAN_OR_EQUAL:
{
node.Nodes.Add(ParseLESS_THAN_OR_EQUAL());
return(node);
}
case SqlTokenType.NOT_EQUALS:
{
node.Nodes.Add(ParseNOT_EQUALS());
return(node);
}
case SqlTokenType.LIKE:
{
node.Nodes.Add(ParseLIKE());
return(node);
}
default:
{
throw new System.Exception("Syntax error.");
}
}
}
private SqlNode ParseLESS_THAN_OR_EQUAL()
{
if (this._token.Type == SqlTokenType.LESS_THAN_OR_EQUAL)
{
SqlNode node = new SqlNode(SqlNodeType.LESS_THAN_OR_EQUAL, this._token.Value);
this._token = this._tokenizer.Tokenize(this._reader);
return(node);
}
else
{
throw new System.Exception("Syntax error.");
}
}
private SqlNode ParseCOMMA()
{
if (this._token.Type == SqlTokenType.COMMA)
{
SqlNode node = new SqlNode(SqlNodeType.COMMA, this._token.Value);
this._token = this._tokenizer.Tokenize(this._reader);
return(node);
}
else
{
throw new System.Exception("Syntax error.");
}
}
protected override object EvaluateCOMMAIDENTIFIERGroupByTail(SqlNode node)
{
List <Identifier> columns = new List <Identifier>();
columns.Add((Identifier)this.Evaluate(node.Nodes[1]));
if (node.Nodes[2].Nodes.Count > 0)
{
foreach (Identifier column in (List <Identifier>) this.Evaluate(node.Nodes[2]))
{
columns.Add(column);
}
}
return(columns);
}
protected override object EvaluateCOMMAVALUEFunctionParameterListTail(SqlNode node)
{
List <object> functionParameters = new List <object>();
functionParameters.Add(this.Evaluate(node.Nodes[1]));
if (node.Nodes[2].Nodes.Count > 0)
{
foreach (object functionParameter in (List <object>) this.Evaluate(node.Nodes[2]))
{
functionParameters.Add(functionParameter);
}
}
return(functionParameters);
}
protected override object EvaluateCOMMASelectItemSelectListTail(SqlNode node)
{
List <object> columns = new List <object>();
columns.Add(this.Evaluate(node.Nodes[1]));
if (node.Nodes[2].Nodes.Count > 0)
{
foreach (object column in (List <object>) this.Evaluate(node.Nodes[2]))
{
columns.Add(column);
}
}
return(columns);
}
protected override object EvaluateCOMMAIDENTIFIERColumnListTail(SqlNode node)
{
Identifier column = (Identifier)Evaluate(node.Nodes[1]);
if (node.Nodes[2].Nodes.Count == 0)
{
return(new Identifier[] { column });
}
else
{
Identifier[] columns = (Identifier[])Evaluate(node.Nodes[2]);
return(cons(column, columns));
}
}
protected override object EvaluateCOMMAVALUEValueListTail(SqlNode node)
{
object value = Evaluate(node.Nodes[1]);
if (node.Nodes[2].Nodes.Count == 0)
{
return(new object[] { value });
}
else
{
object[] values = (object[])Evaluate(node.Nodes[2]);
return(cons(value, values));
}
}
protected override object EvaluateIDENTIFIERPredicateIdentifierTail(SqlNode node)
{
Predicate predicate = new Predicate((string)this.Evaluate(node.Nodes[1].Nodes[0]), this.Evaluate(node.Nodes[0]), this.Evaluate(node.Nodes[1].Nodes[1]));
if (node.Nodes[1].Nodes[0].Value == "BETWEEN")
{
predicate = new Predicate("AND", predicate, this.Evaluate(node.Nodes[1].Nodes[3]));
}
else if (node.Nodes[1].Nodes[2].Nodes.Count > 0)
{
string op = (string)this.Evaluate(node.Nodes[1].Nodes[2].Nodes[0]);
Predicate predicate2 = (Predicate)this.Evaluate(node.Nodes[1].Nodes[2].Nodes[1]);
predicate = new Predicate(op, predicate, predicate2);
}
return(predicate);
}
protected override object EvaluateCOMMAIDENTIFIERAscDescOrderByTail(SqlNode node)
{
List <Sort> sorts = new List <Sort>();
Identifier column = (Identifier)this.Evaluate(node.Nodes[1]);
bool asc = (node.Nodes[2].Nodes.Count == 0) ? true : (bool)this.Evaluate(node.Nodes[2]);
sorts.Add(new Sort(column, asc));
if (node.Nodes[3].Nodes.Count > 0)
{
foreach (Sort sort in (List <Sort>) this.Evaluate(node.Nodes[3]))
{
sorts.Add(sort);
}
}
return(sorts);
}
private SqlNode ParseStatementTail()
{
SqlNode node = new SqlNode(SqlNodeType.StatementTail);
switch (this._token.Type)
{
case SqlTokenType.SEMICOLON:
{
node.Nodes.Add(ParseSEMICOLON());
return(node);
}
default:
{
return(node);
}
}
}
protected override object EvaluateIDENTIFIERSelectItemTailSelectItemAlias(SqlNode node)
{
object column = this.Evaluate(node.Nodes[0]);
if (node.Nodes[1].Nodes.Count == 3 && node.Nodes[1].Nodes[0].Type == SqlNodeType.LEFT_PAREN && node.Nodes[1].Nodes[2].Type == SqlNodeType.RIGHT_PAREN)
{
column = new Function((Identifier)column, (List <object>) this.Evaluate(node.Nodes[1].Nodes[1]));
}
if (node.Nodes[2].Nodes.Count == 1)
{
column = new Alias(column, (Identifier)this.Evaluate(node.Nodes[2].Nodes[0]));
}
else if (node.Nodes[2].Nodes.Count == 2)
{
column = new Alias(column, (Identifier)this.Evaluate(node.Nodes[2].Nodes[1]));
}
return(column);
}
private SqlNode ParseTableTail()
{
SqlNode node = new SqlNode(SqlNodeType.TableTail);
switch (this._token.Type)
{
case SqlTokenType.IDENTIFIER:
{
node.Nodes.Add(ParseIDENTIFIER());
return(node);
}
default:
{
return(node);
}
}
}
private SqlNode ParseSelectList()
{
SqlNode node = new SqlNode(SqlNodeType.SelectList);
switch (this._token.Type)
{
case SqlTokenType.IDENTIFIER:
{
node.Nodes.Add(ParseSelectItem());
node.Nodes.Add(ParseSelectListTail());
return(node);
}
default:
{
throw new System.Exception("Syntax error.");
}
}
}
private SqlNode ParsePredicate()
{
SqlNode node = new SqlNode(SqlNodeType.Predicate);
switch (this._token.Type)
{
case SqlTokenType.IDENTIFIER:
{
node.Nodes.Add(ParseIDENTIFIER());
node.Nodes.Add(ParsePredicateIdentifierTail());
return(node);
}
default:
{
throw new System.Exception("Syntax error.");
}
}
}
private SqlNode ParseFrom()
{
SqlNode node = new SqlNode(SqlNodeType.From);
switch (this._token.Type)
{
case SqlTokenType.FROM:
{
node.Nodes.Add(ParseFROM());
node.Nodes.Add(ParseTableList());
return(node);
}
default:
{
throw new System.Exception("Syntax error.");
}
}
}
protected override object EvaluateCOMMAIDENTIFIERTableTailTableListTail(SqlNode node)
{
List <object> tables = new List <object>();
object table = this.Evaluate(node.Nodes[1]);
if (node.Nodes[2].Nodes.Count > 0)
{
table = new Alias(table, (Identifier)this.Evaluate(node.Nodes[2]));
}
tables.Add(table);
if (node.Nodes[3].Nodes.Count > 0)
{
foreach (object table2 in (List <object>) this.Evaluate(node.Nodes[3]))
{
tables.Add(table2);
}
}
return(tables);
}
private SqlNode ParseWhereClause()
{
SqlNode node = new SqlNode(SqlNodeType.WhereClause);
switch (this._token.Type)
{
case SqlTokenType.WHERE:
{
node.Nodes.Add(ParseWHERE());
node.Nodes.Add(ParsePredicate());
return(node);
}
default:
{
return(node);
}
}
}
private SqlNode ParseUnion()
{
SqlNode node = new SqlNode(SqlNodeType.Union);
switch (this._token.Type)
{
case SqlTokenType.UNION:
{
node.Nodes.Add(ParseUNION());
node.Nodes.Add(ParseSelect());
return(node);
}
default:
{
return(node);
}
}
}
private SqlNode ParseVALUE()
{
SqlNode node = new SqlNode(SqlNodeType.VALUE);
switch (this._token.Type)
{
case SqlTokenType.INTEGER:
{
node.Nodes.Add(ParseINTEGER());
return(node);
}
case SqlTokenType.FLOAT:
{
node.Nodes.Add(ParseFLOAT());
return(node);
}
case SqlTokenType.IDENTIFIER:
{
node.Nodes.Add(ParseIDENTIFIER());
return(node);
}
case SqlTokenType.QUOTED_STRING:
{
node.Nodes.Add(ParseQUOTED_STRING());
return(node);
}
case SqlTokenType.DATE:
{
node.Nodes.Add(ParseDATE());
return(node);
}
default:
{
throw new System.Exception("Syntax error.");
}
}
}
private SqlNode ParseValueListTail()
{
SqlNode node = new SqlNode(SqlNodeType.ValueListTail);
switch (this._token.Type)
{
case SqlTokenType.COMMA:
{
node.Nodes.Add(ParseCOMMA());
node.Nodes.Add(ParseVALUE());
node.Nodes.Add(ParseValueListTail());
return(node);
}
default:
{
return(node);
}
}
}
private SqlNode ParseSelectItemTail()
{
SqlNode node = new SqlNode(SqlNodeType.SelectItemTail);
switch (this._token.Type)
{
case SqlTokenType.LEFT_PAREN:
{
node.Nodes.Add(ParseLEFT_PAREN());
node.Nodes.Add(ParseFunctionParameterList());
node.Nodes.Add(ParseRIGHT_PAREN());
return(node);
}
default:
{
return(node);
}
}
}
private SqlNode ParseColumnListTail()
{
SqlNode node = new SqlNode(SqlNodeType.ColumnListTail);
switch (this._token.Type)
{
case SqlTokenType.COMMA:
{
node.Nodes.Add(ParseCOMMA());
node.Nodes.Add(ParseIDENTIFIER());
node.Nodes.Add(ParseColumnListTail());
return(node);
}
default:
{
return(node);
}
}
}
private SqlNode ParsePredicateTail()
{
SqlNode node = new SqlNode(SqlNodeType.PredicateTail);
switch (this._token.Type)
{
case SqlTokenType.AND:
case SqlTokenType.NOT:
case SqlTokenType.OR:
{
node.Nodes.Add(ParseLogicalOperator());
node.Nodes.Add(ParsePredicate());
return(node);
}
default:
{
return(node);
}
}
}
private SqlNode ParseGroupByClause()
{
SqlNode node = new SqlNode(SqlNodeType.GroupByClause);
switch (this._token.Type)
{
case SqlTokenType.GROUP:
{
node.Nodes.Add(ParseGROUP());
node.Nodes.Add(ParseBY());
node.Nodes.Add(ParseIDENTIFIER());
node.Nodes.Add(ParseGroupByTail());
return(node);
}
default:
{
return(node);
}
}
}
private SqlNode ParseSetListTail()
{
SqlNode node = new SqlNode(SqlNodeType.SetListTail);
switch (this._token.Type)
{
case SqlTokenType.COMMA:
{
node.Nodes.Add(ParseCOMMA());
node.Nodes.Add(ParseIDENTIFIER());
node.Nodes.Add(ParseComparisonOperator());
node.Nodes.Add(ParseVALUE());
node.Nodes.Add(ParseSetListTail());
return(node);
}
default:
{
return(node);
}
}
}
