private WhenMatchedSqlCodeExpr GetWhenMatched(IParser parser)
{
if (!parser.MatchTokenList(SqlToken.When, SqlToken.Matched))
{
return(null);
}
SqlCodeExpr clauseSearchCondition = null;
if (parser.Scanner.Match(SqlToken.And))
{
clauseSearchCondition = parser.ParseExpIgnoreComment();
}
parser.Scanner.Consume(SqlToken.Then);
SqlCodeExpr mergeMatched = ParseMergeUpdate(parser);
if (mergeMatched == null)
{
mergeMatched = parser.ParseExpIgnoreComment();
}
return(new WhenMatchedSqlCodeExpr
{
ClauseSearchCondition = clauseSearchCondition,
MergeMatched = mergeMatched
});
}
private IExpression AlterDatabase(TextSpan databaseSpan, IParser parser)
{
SqlCodeExpr databaseName = null;
if (parser.MatchToken(SqlToken.CURRENT))
{
databaseName = new ObjectIdSqlCodeExpr
{
ObjectName = "CURRENT"
};
}
else
{
databaseName = parser.ConsumeObjectId();
}
var actionExpr = parser.ConsumeAny(
ParseSetOnOff,
ParseAddFileGroup);
var isSemicolon = parser.MatchToken(SqlToken.Semicolon);
return(new AlterDatabaseSqlCodeExpr
{
DatabaseName = databaseName,
ActionExpr = actionExpr,
IsSemicolon = isSemicolon,
});
}
public IExpression Parse(TextSpan token, IParser parser)
{
parser.ConsumeToken(SqlToken.XML);
var optionList = new List <XmlOptionSqlCodeExpr>();
do
{
var xmlOption = parser.ConsumeTokenAny(SqlToken.AUTO, SqlToken.PATH, SqlToken.EXPLICIT, SqlToken.RAW,
SqlToken.ROOT);
SqlCodeExpr rightExpr = null;
if (xmlOption.Type == SqlToken.PATH.ToString())
{
rightExpr = parser.ParseExpIgnoreComment();
}
if (xmlOption.Type == SqlToken.ROOT.ToString())
{
rightExpr = parser.ParseExpIgnoreComment();
}
optionList.Add(new XmlOptionSqlCodeExpr
{
Option = xmlOption.GetTokenType(),
RightExpr = rightExpr
});
} while (parser.MatchToken(SqlToken.Comma));
return(new ForXmlSqlCodeExpr
{
OptionList = optionList
});
}
public IExpression Parse(TextSpan token, IParser parser)
{
SqlCodeExpr inputExpr = null;
if (!parser.IsToken(SqlToken.When))
{
inputExpr = parser.ParseExpIgnoreComment();
inputExpr = parser.ParseLRParenExpr(inputExpr);
}
var whenList = ParseWhenList(parser);
SqlCodeExpr elseExpr = null;
if (parser.Scanner.Match(SqlToken.Else))
{
elseExpr = parser.ParseExpIgnoreComment();
elseExpr = parser.ParseLRParenExpr(elseExpr);
}
parser.Scanner.Consume(SqlToken.End);
return(new CaseSqlCodeExpr
{
InputExpr = inputExpr,
WhenList = whenList,
ElseExpr = elseExpr,
});
}
public IExpression Parse(TextSpan joinTypetoken, IParser parser)
{
var outerType = string.Empty;
var joinTypeStr = parser.Scanner.GetSpanString(joinTypetoken);
switch (joinTypeStr.ToUpper())
{
case "LEFT":
case "RIGHT":
case "FULL":
if (parser.Match(SqlToken.Outer))
{
outerType = "OUTER";
}
break;
}
parser.ConsumeToken(SqlToken.Join);
//var secondTable = parser.ConsumeAny(SqlToken.Variable, SqlToken.Identifier, SqlToken.SqlIdentifier) as SqlCodeExpr;
var secondTable = parser.ParseExpIgnoreComment();
// SqlCodeExpr secondTable;
// if (parser.MatchToken(SqlToken.LParen))
// {
// secondTable = parser.ParseExpIgnoreComment();
// parser.ConsumeToken(SqlToken.RParen);
// secondTable = new GroupSqlCodeExpr
// {
// InnerExpr = secondTable,
// };
// }
// else
// {
// secondTable = parser.ParseExpIgnoreComment();
// }
parser.TryConsumeAliasName(out var aliasNameExpr);
var userWithOptions = parser.ParseWithOption();
SqlCodeExpr joinOnExpr = null;
if (parser.Scanner.Match(SqlToken.ON))
{
joinOnExpr = parser.ParseExpIgnoreComment();
joinOnExpr = parser.ParseLRParenExpr(joinOnExpr);
}
return(new JoinTableSqlCodeExpr
{
JoinType = joinTypeStr,
OuterType = outerType,
SecondTable = secondTable,
AliasName = aliasNameExpr,
WithOptions = userWithOptions,
JoinOnExpr = joinOnExpr,
});
}
public IExpression Parse(TextSpan token, IParser parser)
{
SqlCodeExpr returnVariable = null;
if (parser.Scanner.TryConsume(SqlToken.Variable, out var returnVariableSpan))
{
returnVariable = parser.PrefixParse(returnVariableSpan, int.MaxValue) as SqlCodeExpr;
parser.Scanner.Consume(SqlToken.Equal);
}
SqlCodeExpr funcName = null;
if (parser.Scanner.Match(SqlToken.LParen))
{
funcName = new GroupSqlCodeExpr
{
InnerExpr = parser.ParseExpIgnoreComment()
};
parser.Scanner.Consume(SqlToken.RParen);
}
else
{
funcName = parser.ConsumeAny(SqlToken.SqlIdentifier, SqlToken.Identifier) as SqlCodeExpr;
}
var isEnd = parser.IsToken(SqlToken.End);
var parameters = new List <SqlCodeExpr>();
if (!isEnd)
{
do
{
var name = parser.ParseExpIgnoreComment();
if (name == null)
{
break;
}
var isOutput = parser.MatchTokenAny(SqlToken.Out, SqlToken.Output);
parameters.Add(new ParameterSqlCodeExpr
{
Name = name,
IsOutput = isOutput
});
} while (parser.Scanner.Match(SqlToken.Comma));
}
return(new ExecSqlCodeExpr
{
ExecToken = "EXEC",
ReturnVariable = returnVariable,
Name = funcName,
Parameters = parameters
});
}
public IExpression Parse(TextSpan token, IParser parser)
{
var permissionPrincipal = new[]
{
SqlToken.CONNECT,
SqlToken.Delete,
SqlToken.Insert,
SqlToken.Select,
SqlToken.Update,
SqlToken.Execute,
SqlToken.Exec,
SqlToken.Alter
};
var permissionList = parser.Scanner.ConsumeToStringListByDelimiter(SqlToken.Comma, permissionPrincipal)
.ToList();
if (permissionList.Count == 0)
{
var permissionPrincipalStr = string.Join(",", permissionPrincipal);
ThrowHelper.ThrowParseException(parser, $"Expect one of {permissionPrincipalStr}.");
}
SqlCodeExpr onObjectId = null;
if (parser.Scanner.Match(SqlToken.ON))
{
//onObjectId = parser.ConsumeAny(SqlToken.Object, SqlToken.SqlIdentifier, SqlToken.Identifier) as SqlCodeExpr;
onObjectId = parser.ParseExpIgnoreComment();
}
parser.Scanner.Consume(SqlToken.To);
var targetList = parser.ConsumeByDelimiter(SqlToken.Comma, () =>
{
return(parser.ParseExp() as SqlCodeExpr);
}).ToList();
SqlCodeExpr asDbo = null;
if (parser.Scanner.Match(SqlToken.As))
{
asDbo = parser.ConsumeObjectId();
}
var isSemicolon = parser.MatchToken(SqlToken.Semicolon);
return(new GrantSqlCodeExpr
{
PermissionList = permissionList,
OnObjectId = onObjectId,
TargetList = targetList,
AsDbo = asDbo,
IsSemicolon = isSemicolon
});
}
private static SqlCodeExpr ParseConstantList(SqlCodeExpr constantExpr0, IParser parser)
{
var constantList = new List <SqlCodeExpr>();
constantList.Add(constantExpr0);
while (parser.Scanner.Match(SqlToken.Comma))
{
if (!parser.TryConsumeAny(out var constantExpr, SqlToken.Number, SqlToken.NString, SqlToken.QuoteString))
{
break;
}
constantList.Add(constantExpr as SqlCodeExpr);
}
return(new ExprListSqlCodeExpr
{
Items = constantList,
});
}
public IExpression Parse(TextSpan token, IParser parser)
{
var topCount = parser.ParseTopCountExpr();
parser.Scanner.Match(SqlToken.From);
var table = parser.ConsumeTableName();
var withOptions = parser.ParseWithOption();
var outputList = parser.ParseOutputListExpr();
var intoTableExpr = parser.ParseInto_TableExpr();
var outputList1 = parser.ParseOutputListExpr();
var fromSourceList = new List <SqlCodeExpr>();
if (parser.Scanner.Match(SqlToken.From))
{
fromSourceList = parser.ParseFromSourceList();
}
SqlCodeExpr whereExpr = null;
if (parser.Scanner.Match(SqlToken.Where))
{
whereExpr = parser.ParseExp() as SqlCodeExpr;
}
var optionExpr = parser.ParseOptionExpr();
return(new DeleteSqlCodeExpr
{
TopExpr = topCount,
Table = table,
WithOptions = withOptions,
OutputList = outputList,
IntoTableExpr = intoTableExpr,
OutputList1 = outputList1,
FromSourceList = fromSourceList,
WhereExpr = whereExpr,
OptionExpr = optionExpr
});
}
private static IExpression Call(SqlCodeExpr identExpr, IParser parser)
{
var parametersList = new List <SqlCodeExpr>();
if (!parser.Scanner.TryConsume(SqlToken.RParen, out _))
{
do
{
var parameter = parser.ParseExp();
parametersList.Add(parameter as SqlCodeExpr);
} while (parser.Scanner.TryConsume(SqlToken.Comma, out _));
parser.Scanner.Consume(SqlToken.RParen);
}
return(new FuncSqlCodeExpr
{
Name = identExpr,
Parameters = parametersList
});
}
public IExpression Parse(TextSpan token, IParser parser)
{
var startIndex = parser.Scanner.GetOffset();
parser.Scanner.SetOffset(token.Offset - 1);
SqlCodeExpr identExpr = parser.ParseMeetObjectId();
if (identExpr == null)
{
parser.Scanner.SetOffset(startIndex);
ThrowHelper.ThrowParseException(parser, "Expected object id");
}
// if (!parser.TryConsumeObjectId(out var identExpr))
// {
// parser.Scanner.SetOffset(startIndex);
// ThrowHelper.ThrowParseException(parser, "Expected object id");
// }
if (parser.MatchToken(SqlToken.LParen))
{
var parameterList = new List <SqlCodeExpr>();
do
{
if (parser.IsToken(SqlToken.RParen))
{
break;
}
var p = parser.ParseExpIgnoreComment();
parameterList.Add(p);
} while (parser.MatchToken(SqlToken.Comma));
parser.ConsumeToken(SqlToken.RParen);
identExpr = new FuncSqlCodeExpr
{
Name = identExpr,
Parameters = parameterList
};
}
return(identExpr);
}
public IExpression Parse(TextSpan token, IParser parser)
{
var topCount = parser.ParseTopCountExpr();
//parser.TryConsumeObjectId(out var table);
var table = parser.ConsumeTableName();
var withOptions = parser.ParseWithOption();
parser.Scanner.Consume(SqlToken.Set);
var setList = ParseSetItemList(parser);
var outputList = parser.ParseOutputListExpr();
var intoExpr = ParseIntoExpr(parser);
var fromTableList = new List <SqlCodeExpr>();
if (parser.Scanner.Match(SqlToken.From))
{
fromTableList = parser.ParseFromSourceList();
}
SqlCodeExpr whereExpr = null;
if (parser.Scanner.Match(SqlToken.Where))
{
whereExpr = parser.ParseExpIgnoreComment();
}
return(new UpdateSqlCodeExpr
{
TopCount = topCount,
Table = table,
WithOptions = withOptions,
SetColumnsList = setList,
FromTableList = fromTableList,
OutputList = outputList,
IntoExpr = intoExpr,
WhereExpr = whereExpr
});
}
private CreateUserSqlCodeExpr ParseCreateUser(IParser parser)
{
if (!parser.MatchToken(SqlToken.USER))
{
return(null);
}
var userName = parser.ConsumeObjectId();
SqlCodeExpr loginExpr = null;
if (parser.MatchTokenList(SqlToken.FOR, SqlToken.LOGIN))
{
loginExpr = new ForLoginSqlCodeExpr
{
LoginName = parser.ConsumeObjectId()
};
}
if (parser.MatchTokenList(SqlToken.WITHOUT, SqlToken.LOGIN))
{
loginExpr = new WithoutLoginSqlCodeExpr();
}
SqlCodeExpr withExpr = null;
if (parser.MatchTokenList(SqlToken.With, SqlToken.DEFAULT_SCHEMA, SqlToken.Equal))
{
var schemaName = parser.ConsumeObjectId();
withExpr = new WithDefaultSchemaSqlCodeExpr
{
SchemaName = schemaName
};
}
return(new CreateUserSqlCodeExpr
{
UserName = userName,
LoginName = loginExpr,
WithExpr = withExpr
});
}
private WhenNotMatchedSqlCodeExpr GetWhenNotMatched(IParser parser)
{
if (!parser.Scanner.IsTokenList(SqlToken.When, SqlToken.Not, SqlToken.Matched))
{
return(null);
}
parser.Scanner.Consume(SqlToken.When);
parser.Scanner.Consume(SqlToken.Not);
parser.Scanner.Consume(SqlToken.Matched);
var byTarget = false;
if (parser.Scanner.Match(SqlToken.By))
{
parser.Scanner.Consume(SqlToken.Target);
byTarget = true;
}
SqlCodeExpr clauseSearchCondition = null;
if (parser.Scanner.Match(SqlToken.And))
{
clauseSearchCondition = parser.ParseExpIgnoreComment();
}
parser.Scanner.Consume(SqlToken.Then);
SqlCodeExpr mergeNotMatched = GetMergeInsert(parser);
if (mergeNotMatched == null)
{
mergeNotMatched = parser.ParseExpIgnoreComment();
}
return(new WhenNotMatchedSqlCodeExpr
{
ClauseSearchCondition = clauseSearchCondition,
ByTarget = byTarget,
MergeNotMatched = mergeNotMatched
});
}
public IExpression Parse(TextSpan token, IParser parser)
{
var variableList = new List <SqlCodeExpr>();
do
{
var varName = parser.ParseExpIgnoreComment(int.MaxValue);
parser.Scanner.Match(SqlToken.As);
SqlCodeExpr dataTypeExpr = ParseCursorFor(parser);
if (dataTypeExpr == null)
{
dataTypeExpr = parser.ConsumeDataType();
}
SqlCodeExpr variableDataType = new DeclareSqlCodeExpr
{
Name = varName as SqlCodeExpr,
DataType = dataTypeExpr,
};
if (parser.Scanner.Match(SqlToken.Equal))
{
var valueExpr = parser.ParseExpIgnoreComment();
variableDataType = new AssignSqlCodeExpr
{
Left = variableDataType,
Oper = "=",
Right = valueExpr
};
}
variableList.Add(variableDataType);
} while (parser.Scanner.Match(SqlToken.Comma));
return(new ExprListSqlCodeExpr
{
IsComma = false,
Items = variableList
});
}
private SqlCodeExpr ConsumeCreateTrigger(IParser parser)
{
var triggerExpr = parser.ConsumeTrigger();
SqlCodeExpr forTableExpr = null;
if (parser.MatchToken(SqlToken.FOR))
{
forTableExpr = parser.ConsumeObjectId();
}
parser.ConsumeToken(SqlToken.As);
var body = parser.ConsumeBeginBodyOrSingle();
return(new CreateTriggerSqlCodeExpr
{
TriggerExpr = triggerExpr,
ForTableExpr = forTableExpr,
Body = body
});
}
private CreateNonclusteredIndexSqlCodeExpr CreateNonClusteredIndex(TextSpan nonClusteredSpan, IParser parser)
{
parser.ConsumeToken(SqlToken.Index);
var indexName = parser.ConsumeObjectId();
parser.ConsumeToken(SqlToken.ON);
var tableName = parser.ConsumeObjectId();
parser.ConsumeToken(SqlToken.LParen);
var columnList = parser.ParseOrderItemList();
parser.ConsumeToken(SqlToken.RParen);
SqlCodeExpr whereExpr = null;
if (parser.MatchToken(SqlToken.Where))
{
parser.ConsumeToken(SqlToken.LParen);
whereExpr = parser.ParseExpIgnoreComment();
parser.ConsumeToken(SqlToken.RParen);
}
var withExpr = parser.ParseConstraintWithOptions();
var onPrimary = parser.ParseOnPrimary();
var isSemicolon = parser.MatchToken(SqlToken.Semicolon);
return(new CreateNonclusteredIndexSqlCodeExpr
{
IndexName = indexName,
TableName = tableName,
ColumnList = columnList,
WhereExpr = whereExpr,
WithExpr = withExpr,
OnPrimary = onPrimary,
IsSemicolon = isSemicolon,
});
}
public IExpression Parse(TextSpan token, IParser parser)
{
var conditionExpr = parser.ParseExp();
var body = parser.ParseExpIgnoreComment();
var elseIfList = ParseElseIfList(parser);
SqlCodeExpr elseExpr = null;
if (parser.Scanner.TryConsume(SqlToken.Else, out var elseSpan))
{
elseExpr = parser.ParseExpIgnoreComment();
}
return(new IfSqlCodeExpr
{
Condition = conditionExpr as SqlCodeExpr,
Body = body,
ElseIfList = elseIfList,
ElseExpr = elseExpr
});
}
public IExpression Parse(TextSpan token, IParser parser)
{
var intoToken = string.Empty;
if (parser.Scanner.Match(SqlToken.Into))
{
intoToken = "INTO";
}
var targetTable = parser.ConsumeObjectId();
var withOptions = parser.ParseWithOption();
if (!parser.TryConsumeAliasName(out var targetTableAliasName) && parser.Scanner.IsTokenList(SqlToken.As, SqlToken.Target))
{
parser.Scanner.Consume(SqlToken.As);
parser.Scanner.Consume(SqlToken.Target);
targetTableAliasName = new ObjectIdSqlCodeExpr
{
ObjectName = "Target"
};
}
parser.Scanner.Consume(SqlToken.Using);
var tableSource = parser.ParseExpIgnoreComment();
if (!parser.TryConsumeAliasName(out var tableSourceAliasName) && parser.Scanner.IsTokenList(SqlToken.As, SqlToken.Source))
{
parser.Scanner.Consume(SqlToken.As);
parser.Scanner.Consume(SqlToken.Source);
targetTableAliasName = new ObjectIdSqlCodeExpr
{
ObjectName = "Source"
};
}
var sourceColumnList = new List <SqlCodeExpr>();
if (parser.MatchToken(SqlToken.LParen))
{
sourceColumnList = parser.ParseColumnList();
parser.ConsumeToken(SqlToken.RParen);
}
parser.Scanner.Consume(SqlToken.ON);
var mergeSearchCondition = parser.ParseExpIgnoreComment();
var whenList = new List <SqlCodeExpr>();
do
{
SqlCodeExpr whenItem = GetWhenNotMatched(parser);
if (whenItem == null)
{
whenItem = GetWhenMatched(parser);
if (whenItem == null)
{
break;
}
}
whenList.Add(whenItem);
} while (true);
var outputList = parser.ParseOutputListExpr();
parser.Scanner.Consume(SqlToken.Semicolon);
return(new MergeSqlCodeExpr
{
IntoToken = intoToken,
TargetTable = targetTable,
TargetTableAliasName = targetTableAliasName,
WithOptions = withOptions,
TableSource = tableSource,
SourceColumnList = sourceColumnList,
TableSourceAliasName = tableSourceAliasName,
OnMergeSearchCondition = mergeSearchCondition,
WhenList = whenList,
OutputList = outputList,
});
}
public IExpression Parse(TextSpan token, IParser parser)
{
var topCount = parser.ParseTopCountExpr();
var columns = parser.ParseColumnList();
SqlCodeExpr intoTable = null;
if (parser.Scanner.Match(SqlToken.Into))
{
intoTable = parser.ConsumeTableName();
}
var fromSourceList = GetFrom_SourceList(parser);
SqlCodeExpr pivotExpr = null;
if (parser.Scanner.TryConsumeAny(out var pivotSpan, SqlToken.Pivot, SqlToken.UnPivot))
{
pivotExpr = parser.PrefixParse(pivotSpan) as SqlCodeExpr;
}
SqlCodeExpr whereExpr = null;
if (parser.Scanner.TryConsume(SqlToken.Where, out _))
{
whereExpr = parser.ParseExpIgnoreComment();
whereExpr = parser.ParseLRParenExpr(whereExpr);
}
var groupBy = ParseGroupBy(parser);
var having = ParseHaving(parser);
var orderBy = ParseOrderBy(parser);
SqlCodeExpr forXmlExpr = null;
if (parser.TryConsumeToken(out var forSpan, SqlToken.FOR))
{
forXmlExpr = parser.PrefixParse(forSpan) as SqlCodeExpr;
}
var optionExpr = parser.ParseOptionExpr();
var unionSelectList = ParseUnionSelectList(parser);
var isSemicolon = parser.MatchToken(SqlToken.Semicolon);
return(new SelectSqlCodeExpr
{
TopCount = topCount,
Columns = columns,
IntoTable = intoTable,
FromSourceList = fromSourceList,
PivotExpr = pivotExpr,
WhereExpr = whereExpr,
GroupByList = groupBy,
Having = having,
OrderByList = orderBy,
ForXmlExpr = forXmlExpr,
OptionExpr = optionExpr,
UnionSelectList = unionSelectList,
IsSemicolon = isSemicolon,
});
}