protected SqlColRefListItem ParseColListItem(SymbolPosition commapos)
{
var expr = ParseExpression();
SqlMultiKeyWord modifier = ParseMultiKeyword("asc") ?? ParseMultiKeyword("desc");
return(new SqlColRefListItem(commapos == null, commapos, expr, modifier));
}
protected SqlSourceItem ParseSourceItem()
{
if (IsSymbol("("))
{
SymbolPosition leftb = SkipSymbol("(");
if (IsKeyword("select"))
{
SqlSelect select = ParseSelect();
SymbolPosition rightb = SkipSymbol(")");
var expr = new SqlSelectExpression(leftb, select, rightb);
var alias = ParseAlias();
return(new SqlSelectSourceItem(expr, alias));
}
else
{
var lst = ParseSourceList();
SymbolPosition rightb = SkipSymbol(")");
var alias = ParseAlias();
return(new SqlSourceListSourceItem(leftb, lst, rightb, alias));
}
}
else
{
var expr = ParseExpression();
var alias = ParseAlias();
return(new SqlTableSourceItem(expr, alias));
}
}
private SqlSourceList ParseSourceList()
{
var src1 = ParseSourceItem();
List <SqlJoin> joins = new List <SqlJoin>();
for (; ;)
{
SqlJoin join;
if (IsSymbol(","))
{
var cpos = SkipSymbol(",");
var src = ParseSourceItem();
var cpre = new SqlMultiKeyWord(new SymbolPosition[] { cpos }, new string[] { "," });
join = new SqlJoin(cpre, src, null, null);
}
else
{
SymbolPosition natpos = null;
if (IsKeyword("natural"))
{
natpos = SkipKeyword("natural");
}
var pre = ParseMultiKeyword("left", "join")
?? ParseMultiKeyword("right", "join")
?? ParseMultiKeyword("left", "outer", "join")
?? ParseMultiKeyword("right", "outer", "join")
?? ParseMultiKeyword("inner", "join")
?? ParseMultiKeyword("outer", "join")
?? ParseMultiKeyword("cross", "join")
?? ParseMultiKeyword("join");
if (pre == null)
{
if (natpos != null)
{
GoBack(1);
}
break;
}
if (natpos != null)
{
pre.ClauseWords.Insert(0, "natural");
pre.ClauseWordsPos.Insert(0, natpos);
}
var src = ParseSourceItem();
SymbolPosition onpos = null;
SqlExpression cond = null;
if (IsKeyword("on"))
{
onpos = SkipKeyword("on");
cond = ParseExpression();
}
join = new SqlJoin(pre, src, onpos, cond);
}
joins.Add(join);
}
return(new SqlSourceList(src1, joins));
}
public SqlCaseWhenClause(SymbolPosition whenpos, SqlExpression whenexpr, SymbolPosition thenpos, SqlExpression thenexpr)
{
WhenPos = whenpos;
WhenExpr = whenexpr;
ThenPos = thenpos;
ThenExpr = thenexpr;
WhenExpr.Parent = this;
ThenExpr.Parent = this;
}
public SqlQualificator(SqlIdentifierOrExprSymbol ident, SymbolPosition dotpos)
{
Ident = ident;
DotPos = dotpos;
if (Ident != null)
{
Ident.Parent = this;
}
}
public SqlFunctionCall(SqlNameExpression name, SymbolPosition leftb, SqlExpressionList args, SymbolPosition rignhtb)
{
FunctionName = name;
LeftBracket = leftb;
Arguments = args;
RightBracket = rignhtb;
FunctionName.Parent = this;
Arguments.Parent = this;
}
public SqlBetweenExpression(SqlExpression value, SymbolPosition betweenpos, SqlExpression lowerbound, SymbolPosition andpos, SqlExpression upperbound)
{
Value = value;
BetweenPos = betweenpos;
LowerBound = lowerbound;
AndPos = andpos;
UpperBound = upperbound;
Value.Parent = this;
LowerBound.Parent = this;
UpperBound.Parent = this;
}
protected SqlResultField ParseResultField(SymbolPosition commapos)
{
var expr = ParseExpression();
if (IsKeyword("as"))
{
var aspos = SkipKeyword("as");
var alias = ParseIdentifier();
return(new SqlResultField(commapos != null, commapos, expr, aspos, alias));
}
return(new SqlResultField(commapos != null, commapos, expr, null, null));
}
public SqlColRefListItem(bool isfirst, SymbolPosition commapos, SqlExpression argument, SqlMultiKeyWord modifier)
{
CommaPos = commapos;
Argument = argument;
IsFirst = isfirst;
Modifier = modifier;
Argument.Parent = this;
if (Modifier != null)
{
Modifier.Parent = this;
}
}
protected ConstStringSqlExpression ParseString()
{
if (Current != TokenType.StringSingle)
{
return(null);
}
SymbolPosition pos = CurrentOriginal;
var data = CurrentData;
object specdata = CurrentSpecData; // specdata zatim neumime vyuzit
NextToken();
return(new ConstStringSqlExpression(data, pos));
}
public SqlJoin(SqlMultiKeyWord joinPrefix, SqlSourceItem source, SymbolPosition onpos, SqlExpression cond)
{
JoinPrefix = joinPrefix;
Source = source;
OnPos = onpos;
Condition = cond;
JoinPrefix.Parent = this;
Source.Parent = this;
if (Condition != null)
{
Condition.Parent = this;
}
}
public SqlResultField(bool isComma, SymbolPosition commaPos, SqlExpression value, SymbolPosition aspos, SqlIdentifier alias)
{
IsComma = isComma;
CommaPos = commaPos;
Value = value;
AsPos = aspos;
Alias = alias;
Value.Parent = this;
if (Alias != null)
{
Alias.Parent = this;
}
}
public SqlSelect(SymbolPosition selectpos, IEnumerable <SqlResultField> resflds, IEnumerable <SqlCommandClause> clauses)
{
SelectPos = selectpos;
ResultFields = new List <SqlResultField>(resflds);
Clauses = new List <SqlCommandClause>(clauses);
foreach (var clause in Clauses)
{
clause.Parent = this;
}
foreach (var resfld in ResultFields)
{
resfld.Parent = this;
}
}
public SqlCaseExpression(SymbolPosition casepos, SqlExpression caseval, IEnumerable <SqlCaseWhenClause> whens, SymbolPosition elsepos, SqlExpression elseval, SymbolPosition endpos)
{
CasePos = casepos;
CaseVal = caseval;
Whens = new List <SqlCaseWhenClause>(whens);
ElsePos = elsepos;
ElseVal = elseval;
EndPos = endpos;
foreach (var when in Whens) when .Parent = this;
CaseVal.Parent = this;
if (ElseVal != null)
{
ElseVal.Parent = this;
}
}
protected SymbolPosition SkipKeyword(string keyword, bool mandatory)
{
if (Current != TokenType.IdentOrKeyword && CurrentData.ToUpper() != keyword.ToUpper())
{
if (!mandatory)
{
return(null);
}
throw CreateParseError("DAE-00253 " + keyword + " expected");
}
SymbolPosition res = CurrentOriginal;
NextToken();
return(res);
}
public SqlSelect ParseSelect()
{
SymbolPosition selectpos = SkipKeyword("select");
var resflds = ParseResultFields();
List <SqlCommandClause> clauses = new List <SqlCommandClause>();
for (; ;)
{
SqlCommandClause clause = ParseSelectClause();
if (clause == null)
{
break;
}
clauses.Add(clause);
}
return(new SqlSelect(selectpos, resflds, clauses));
}
internal SqlExpression ParseComplexExpr(ComplexOperatorGroup group)
{
// LL(1) parsing CASE
if ((group.Type & ComplexOperatorType.Case) != 0 && IsKeyword("CASE"))
{
SymbolPosition casepos = CurrentOriginal;
NextToken();
SqlExpression caseval = ParseInnerExpression(group);
List <SqlCaseWhenClause> whens = new List <SqlCaseWhenClause>();
while (IsKeyword("WHEN"))
{
SymbolPosition whenpos = CurrentOriginal;
NextToken();
SqlExpression cmpval = ParseInnerExpression(group);
SymbolPosition thenpos = SkipKeyword("THEN");
SqlExpression thenval = ParseInnerExpression(group);
SqlCaseWhenClause when = new SqlCaseWhenClause(whenpos, cmpval, thenpos, thenval);
whens.Add(when);
}
SqlExpression elseExpr = null;
SymbolPosition elsePos = null;
if (IsKeyword("ELSE"))
{
elsePos = CurrentOriginal;
NextToken();
elseExpr = ParseInnerExpression(group);
}
SymbolPosition endpos = CurrentOriginal;
SkipKeyword("END");
return(new SqlCaseExpression(casepos, caseval, whens, elsePos, elseExpr, endpos));
}
SqlExpression left = ParseInnerExpression(group);
if ((group.Type & ComplexOperatorType.Between) != 0 && IsKeyword("BETWEEN"))
{
SymbolPosition betpos = CurrentOriginal;
NextToken();
SqlExpression lower = ParseInnerExpression(group);
SymbolPosition andpos = SkipKeyword("AND");
SqlExpression upper = ParseInnerExpression(group);
return(new SqlBetweenExpression(left, betpos, lower, andpos, upper));
}
return(left);
}
private SqlColRefList ParseCoRefList()
{
List <SqlColRefListItem> args = new List <SqlColRefListItem>();
for (; ;)
{
SymbolPosition commapos = null;
if (args.Count > 0)
{
if (!IsSymbol(","))
{
break; // no next expression
}
commapos = SkipSymbol(",");
}
SqlColRefListItem arg = ParseColListItem(commapos);
args.Add(arg);
}
return(new SqlColRefList(args));
}
protected SqlExpression ParseExprInBracket()
{
if (!IsSymbol("("))
{
return(null);
}
var leftb = SkipSymbol("(");
if (IsKeyword("select"))
{
SqlSelect select = ParseSelect();
SymbolPosition rightb = SkipSymbol(")");
return(new SqlSelectExpression(leftb, select, rightb));
}
else
{
SqlExpressionList inner = ParseExprList(IsCloseBracket);
SymbolPosition rightb = SkipSymbol(")");
return(new SqlExpressionInBracket(leftb, inner, rightb));
}
}
protected SqlNameExpression ParseName()
{
//bool quoted = Current == SqlTokenType.QuotedIdent;
//string first = CurrentData;
List <SqlQualificator> quals = new List <SqlQualificator>();
SqlIdentifierOrExprSymbol ident = ParseIdentifier();
while (IsSymbol("."))
{
SymbolPosition dotpos = CurrentOriginal;
NextToken();
SqlIdentifierOrExprSymbol nextid = null;
if (Current == TokenType.IdentOrKeyword || Current == TokenType.QuotedIdent)
{
nextid = ParseIdentifier();
}
else if (IsSymbol("*"))
{
nextid = new SqlStarSymbol(SkipSymbol("*"));
}
quals.Add(new SqlQualificator(ident, dotpos));
ident = nextid;
}
SqlNameExpression name;
if (quals.Count > 0)
{
name = new SqlQualifiedName(quals, ident);
}
else
{
name = ident;
}
return(name);
}
public ConstNumberSqlExpression(double value, SymbolPosition original)
: base(original)
{
m_value = value;
}
public SqlStarSymbol(SymbolPosition starpos)
{
Original = starpos;
}
public SqlQuotedStringExpression(SymbolPosition original, string data, TokenType token)
: base(original)
{
Data = data;
Token = token;
}
public SqlIdentifier(bool isQuoted, string ident, SymbolPosition original)
{
Identifier = ident;
Original = original;
IsQuoted = isQuoted;
}
public SqlSelectExpression(SymbolPosition leftb, SqlSelect select, SymbolPosition rightb)
{
LeftBracket = leftb;
Select = select;
RightBracket = rightb;
}
public ConstStringSqlExpression(string value, SymbolPosition original)
: base(original)
{
m_value = value;
}
public NullSqlExpression(SymbolPosition original)
: base(original)
{
}
public SpecificSqlExpression(string expr, string dialect, SymbolPosition original)
: base(original)
{
m_expr = expr;
m_dialect = dialect;
}
public SqlLeafExpression(SymbolPosition original)
{
this.Original = original;
}
public SpecialConstantSqlExpression(SqlSpecialConstant specConst, SymbolPosition original)
: base(original)
{
m_specConst = specConst;
}
