public Main.Sequence Map(IDatabaseSequence sequence)
{
if (sequence == null)
{
throw new ArgumentNullException(nameof(sequence));
}
return(new Main.Sequence(
sequence.Name,
sequence.Start,
sequence.Increment,
sequence.MinValue,
sequence.MaxValue,
sequence.Cache,
sequence.Cycle
));
}
/// <summary>
/// Analyses a database sequence. Reports messages when a sequence has a reserved keyword name.
/// </summary>
/// <param name="sequence">A database sequence.</param>
/// <returns>A set of linting messages used for reporting. An empty set indicates no issues discovered.</returns>
/// <exception cref="ArgumentNullException"><paramref name="sequence"/> is <c>null</c>.</exception>
protected IEnumerable <IRuleMessage> AnalyseSequence(IDatabaseSequence sequence)
{
if (sequence == null)
{
throw new ArgumentNullException(nameof(sequence));
}
var result = new List <IRuleMessage>();
var sequenceNameIsKeyword = Dialect.IsReservedKeyword(sequence.Name.LocalName);
if (sequenceNameIsKeyword)
{
var message = BuildSequenceMessage(sequence.Name);
result.Add(message);
}
return(result);
}
/// <summary>
/// Analyses a database sequence. Reports messages when a sequence has whitespace in its name.
/// </summary>
/// <param name="sequence">A database sequence.</param>
/// <returns>A set of linting messages used for reporting. An empty set indicates no issues discovered.</returns>
/// <exception cref="ArgumentNullException"><paramref name="sequence"/> is <c>null</c>.</exception>
protected IEnumerable <IRuleMessage> AnalyseSequence(IDatabaseSequence sequence)
{
if (sequence == null)
{
throw new ArgumentNullException(nameof(sequence));
}
var result = new List <IRuleMessage>();
var sequenceNameHasWs = HasWhiteSpace(sequence.Name.LocalName);
if (sequenceNameHasWs)
{
var message = BuildSequenceMessage(sequence.Name);
result.Add(message);
}
return(result);
}
private static InvocationExpressionSyntax BuildSequenceConfiguration(IDatabaseSequence sequence)
{
if (sequence == null)
{
throw new ArgumentNullException(nameof(sequence));
}
var hasSequenceArgs = new List <ArgumentSyntax>
{
Argument(
LiteralExpression(
SyntaxKind.StringLiteralExpression,
Literal(sequence.Name.LocalName)))
};
if (!sequence.Name.Schema.IsNullOrWhiteSpace())
{
var schemaArg = Argument(
LiteralExpression(
SyntaxKind.StringLiteralExpression,
Literal(sequence.Name.Schema)))
.WithNameColon(
NameColon(
IdentifierName("schema")));
hasSequenceArgs.Add(schemaArg);
}
var hasSequence = InvocationExpression(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
IdentifierName(ModelBuilderParameterName),
GenericName(
Identifier(nameof(RelationalModelBuilderExtensions.HasSequence)))
.WithTypeArgumentList(
TypeArgumentList(
SingletonSeparatedList <TypeSyntax>(
PredefinedType(Token(SyntaxKind.DecimalKeyword)))))))
.WithArgumentList(
ArgumentList(SeparatedList(hasSequenceArgs)));
var startsAtArgs = ArgumentList(
SingletonSeparatedList(
Argument(
LiteralExpression(
SyntaxKind.NumericLiteralExpression,
Literal(sequence.Start)))));
var startsAt = InvocationExpression(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
hasSequence,
IdentifierName(nameof(SequenceBuilder.StartsAt))))
.WithArgumentList(startsAtArgs);
var incrementsByArgs = ArgumentList(
SingletonSeparatedList(
Argument(
LiteralExpression(
SyntaxKind.NumericLiteralExpression,
Literal(sequence.Increment)))));
return(InvocationExpression(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
startsAt,
IdentifierName(nameof(SequenceBuilder.IncrementsBy))))
.WithArgumentList(incrementsByArgs));
}
