public virtual OperationBuilder <CreateSequenceOperation> CreateSequence(
[NotNull] string name,
[CanBeNull] string schema = null,
[CanBeNull] string type = null,
[CanBeNull] long?startWith = null,
[CanBeNull] int?incrementBy = null,
[CanBeNull] long?minValue = null,
[CanBeNull] long?maxValue = null,
bool cycle = false)
{
Check.NotEmpty(name, nameof(name));
var operation = new CreateSequenceOperation
{
Schema = schema,
Name = name,
Type = type,
StartWith = startWith,
IncrementBy = incrementBy,
MinValue = minValue,
MaxValue = maxValue,
Cycle = cycle
};
Operations.Add(operation);
return(new OperationBuilder <CreateSequenceOperation>(operation));
}
public override void Generate(
CreateSequenceOperation createSequenceOperation,
IndentedStringBuilder stringBuilder)
{
throw new NotSupportedException(Strings.FormatMigrationOperationNotSupported(
GetType(), createSequenceOperation.GetType()));
}
/// <summary>
/// Builds commands for the given <see cref="CreateSequenceOperation" /> by making calls on the given
/// <see cref="MigrationCommandListBuilder" />, and then terminates the final command.
/// </summary>
/// <param name="operation"> The operation. </param>
/// <param name="model"> The target model which may be <c>null</c> if the operations exist without a model. </param>
/// <param name="builder"> The command builder to use to build the commands. </param>
protected override void Generate(
CreateSequenceOperation operation,
IModel model,
MigrationCommandListBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
builder
.Append("CREATE SEQUENCE ")
.Append(Dependencies.SqlGenerationHelper.DelimitIdentifier(operation.Name, operation.Schema));
if (operation.ClrType != typeof(long))
{
var typeMapping = Dependencies.TypeMappingSource.GetMapping(operation.ClrType);
builder
.Append(" AS ")
.Append(typeMapping.StoreType);
}
builder
.Append(" START WITH ")
.Append(IntegerConstant(operation.StartValue));
SequenceOptions(operation, model, builder);
builder.AppendLine(Dependencies.SqlGenerationHelper.StatementTerminator);
EndStatement(builder);
}
void Generate(CreateSequenceOperation operation, [CanBeNull] IModel model, MigrationCommandListBuilder builder, bool endStatement)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
if (operation.ClrType != typeof(long))
{
throw new NotSupportedException("PostgreSQL sequences can only be bigint (long)");
}
builder
.Append("CREATE SEQUENCE ")
.Append(SqlGenerationHelper.DelimitIdentifier(operation.Name, operation.Schema));
builder
.Append(" START WITH ")
.Append(SqlGenerationHelper.GenerateLiteral(operation.StartValue));
SequenceOptions(operation, model, builder);
builder.AppendLine(SqlGenerationHelper.StatementTerminator);
if (endStatement)
{
EndStatement(builder);
}
}
public virtual OperationBuilder <CreateSequenceOperation> CreateSequence <T>(
[NotNull] string name,
[CanBeNull] string schema = null,
long startValue = 1L,
int incrementBy = 1,
[CanBeNull] long?minValue = null,
[CanBeNull] long?maxValue = null,
bool cyclic = false)
{
Check.NotEmpty(name, nameof(name));
var operation = new CreateSequenceOperation
{
Schema = schema,
Name = name,
ClrType = typeof(T),
StartValue = startValue,
IncrementBy = incrementBy,
MinValue = minValue,
MaxValue = maxValue,
IsCyclic = cyclic
};
Operations.Add(operation);
return(new OperationBuilder <CreateSequenceOperation>(operation));
}
public override void Visit(CreateSequenceOperation createSequenceOperation, DatabaseModel databaseModel)
{
Check.NotNull(createSequenceOperation, "createSequenceOperation");
Check.NotNull(databaseModel, "databaseModel");
databaseModel.AddSequence(createSequenceOperation.Sequence.Clone(new CloneContext()));
}
protected virtual void Generate(
[NotNull] CreateSequenceOperation operation,
[CanBeNull] IModel model,
[NotNull] MigrationCommandListBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
builder
.Append("CREATE SEQUENCE ")
.Append(SqlGenerationHelper.DelimitIdentifier(operation.Name, operation.Schema));
if (operation.ClrType != typeof(long))
{
builder
.Append(" AS ")
.Append(TypeMapper.GetMapping(operation.ClrType).DefaultTypeName);
}
builder
.Append(" START WITH ")
.Append(SqlGenerationHelper.GenerateLiteral(operation.StartValue));
SequenceOptions(operation, model, builder);
EndStatement(builder);
}
protected virtual void Generate(
[NotNull] CreateSequenceOperation operation,
[CanBeNull] IModel model,
[NotNull] MigrationCommandListBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
builder
.Append("CREATE SEQUENCE ")
.Append(Dependencies.SqlGenerationHelper.DelimitIdentifier(operation.Name, operation.Schema));
var typeMapping = Dependencies.TypeMapper.GetMapping(operation.ClrType);
if (operation.ClrType != typeof(long))
{
builder
.Append(" AS ")
.Append(typeMapping.StoreType);
// set the typeMapping for use with operation.StartValue (i.e. a long) below
typeMapping = Dependencies.TypeMapper.GetMapping(typeof(long));
}
builder
.Append(" START WITH ")
.Append(typeMapping.GenerateSqlLiteral(operation.StartValue));
SequenceOptions(operation, model, builder);
builder.AppendLine(Dependencies.SqlGenerationHelper.StatementTerminator);
EndStatement(builder);
}
public void Generate_with_create_sequence_not_supported()
{
var operation = new CreateSequenceOperation(new Sequence("EpisodeSequence", "bigint", 0, 1));
Assert.Equal(
Strings.FormatMigrationOperationNotSupported(typeof(SQLiteMigrationOperationSqlGenerator), operation.GetType()),
Assert.Throws <NotSupportedException>(() => Generate(operation)).Message);
}
public void Create_and_initialize_operation()
{
var sequence = new Sequence("dbo.MySequence");
var createSequenceOperation = new CreateSequenceOperation(sequence);
Assert.Same(sequence, createSequenceOperation.Sequence);
Assert.False(createSequenceOperation.IsDestructiveChange);
}
protected override void Generate(CreateSequenceOperation operation, IModel model, MigrationCommandListBuilder builder)
{
builder.Append("CREATE SEQUENCE ");
builder.Append(Dependencies.SqlGenerationHelper.DelimitIdentifier(operation.Name, operation.Schema));
builder.Append(" START WITH ");
builder.Append(operation.StartValue.ToString(CultureInfo.InvariantCulture));
builder.Append(" INCREMENT BY ");
builder.Append(operation.IncrementBy.ToString(CultureInfo.InvariantCulture));
TerminateStatement(builder);
}
public void Generate_when_create_sequence_operation_with_some_defaults()
{
var operation = new CreateSequenceOperation("dbo.MySequence", Sequence.DefaultStartValue, 7);
Assert.Equal(
@"CreateSequence(""dbo.MySequence"", 1, 7)",
CSharpMigrationCodeGenerator.Generate(operation));
GenerateAndValidateCode(operation);
}
public void Generate_when_create_sequence_operation_with_all_defaults()
{
var operation = new CreateSequenceOperation("dbo.MySequence");
Assert.Equal(
@"CreateSequence(""dbo.MySequence"")",
CSharpMigrationCodeGenerator.Generate(operation));
GenerateAndValidateCode(operation);
}
public void Generate_when_create_sequence_operation()
{
var operation = new CreateSequenceOperation(new Sequence("dbo.MySequence", "BIGINT", 10, 5));
Assert.Equal(
@"CreateSequence(""dbo.MySequence"", ""BIGINT"", 10, 5)",
CSharpMigrationCodeGenerator.Generate(operation));
GenerateAndValidateCode(operation);
}
public void Dispatches_visitor()
{
var createSequenceOperation = new CreateSequenceOperation(new Sequence("dbo.MySequence"));
var mockVisitor = new Mock <MigrationOperationSqlGenerator>(new RelationalTypeMapper());
var builder = new Mock <IndentedStringBuilder>();
createSequenceOperation.GenerateSql(mockVisitor.Object, builder.Object);
mockVisitor.Verify(g => g.Generate(createSequenceOperation, builder.Object), Times.Once());
}
public void Generate_when_create_sequence_operation()
{
var operation = new CreateSequenceOperation("dbo.MySequence", 10, 5, 1, 100, typeof(int));
Assert.Equal(
@"CreateSequence(""dbo.MySequence"", 10, 5, 1, 100, typeof(int))",
CSharpMigrationCodeGenerator.Generate(operation));
GenerateAndValidateCode(operation);
}
public void Dispatches_visitor()
{
var createSequenceOperation = new CreateSequenceOperation("dbo.MySequence");
var mockVisitor = MigrationsTestHelpers.MockSqlGenerator();
var builder = new Mock <SqlBatchBuilder>();
createSequenceOperation.GenerateSql(mockVisitor.Object, builder.Object);
mockVisitor.Verify(g => g.Generate(createSequenceOperation, builder.Object), Times.Once());
}
/// <summary>
/// 新建序列号转换。
/// </summary>
/// <param name="operation">操作实例。</param>
/// <param name="builder"><see cref="MigrationCommandListBuilder"/>实例。</param>
protected virtual void SequenceOptions(
[NotNull] CreateSequenceOperation operation,
[NotNull] MigrationCommandListBuilder builder)
=> SequenceOptions(
operation.Schema,
operation.Name,
operation.IncrementBy,
operation.MinValue,
operation.MaxValue,
operation.IsCyclic,
builder);
public void Create_and_initialize_operation_with_defaults()
{
var createSequenceOperation = new CreateSequenceOperation("dbo.MySequence");
Assert.Equal("dbo.MySequence", createSequenceOperation.SequenceName);
Assert.Equal(Sequence.DefaultStartValue, createSequenceOperation.StartValue);
Assert.Equal(Sequence.DefaultIncrement, createSequenceOperation.IncrementBy);
Assert.False(createSequenceOperation.MinValue.HasValue);
Assert.False(createSequenceOperation.MaxValue.HasValue);
Assert.Equal(typeof(long), createSequenceOperation.Type);
Assert.False(createSequenceOperation.IsDestructiveChange);
}
public virtual void SequenceOptions(
[NotNull] CreateSequenceOperation operation,
[CanBeNull] IModel model,
[NotNull] SqlBatchBuilder builder) =>
SequenceOptions(
operation.Schema,
operation.Name,
operation.IncrementBy,
operation.MinValue,
operation.MaxValue,
operation.Cycle,
model,
builder);
public void Create_and_initialize_operation()
{
var createSequenceOperation = new CreateSequenceOperation(
"dbo.MySequence", 13, 7, 3, 103, typeof(int));
Assert.Equal("dbo.MySequence", createSequenceOperation.SequenceName);
Assert.Equal(13, createSequenceOperation.StartValue);
Assert.Equal(7, createSequenceOperation.IncrementBy);
Assert.Equal(3, createSequenceOperation.MinValue);
Assert.Equal(103, createSequenceOperation.MaxValue);
Assert.Equal(typeof(int), createSequenceOperation.Type);
Assert.False(createSequenceOperation.IsDestructiveChange);
}
public void Visit_with_create_sequence_operation()
{
var model = new DatabaseModel();
var sequence = new Sequence("dbo.MySequence");
var operation = new CreateSequenceOperation(sequence);
Assert.Equal(0, model.Sequences.Count);
operation.Accept(new DatabaseModelModifier(), model);
Assert.Equal(1, model.Sequences.Count);
Assert.Same(sequence, model.Sequences[0]);
}
protected virtual void SequenceOptions(
[NotNull] CreateSequenceOperation operation,
[CanBeNull] IModel model,
[NotNull] RelationalCommandListBuilder builder) =>
SequenceOptions(
operation.Schema,
operation.Name,
operation.IncrementBy,
operation.MinValue,
operation.MaxValue,
operation.IsCyclic,
model,
builder);
public async Task CreateSequence()
{
var operation = new CreateSequenceOperation()
{
Name = "MySequence",
StartValue = 34,
IncrementBy = 56,
};
var batch = await Generate(new[] { operation });
Assert.AreEqual(1, batch.Count());
Assert.AreEqual(NewLineEnd(@"CREATE SEQUENCE ""MySequence"" START WITH 34 INCREMENT BY 56;"), batch[0].CommandText);
}
public virtual void Generate([NotNull] CreateSequenceOperation createSequenceOperation, [NotNull] IndentedStringBuilder stringBuilder, bool generateIdempotentSql)
{
Check.NotNull(createSequenceOperation, "createSequenceOperation");
var sequence = createSequenceOperation.Sequence;
stringBuilder
.Append("CREATE SEQUENCE ")
.Append(DelimitIdentifier(sequence.Name))
.Append(" AS ")
.Append(sequence.DataType)
.Append(" START WITH ")
.Append(sequence.StartWith)
.Append(" INCREMENT BY ")
.Append(sequence.IncrementBy);
}
public override void Generate(
[NotNull] CreateSequenceOperation operation,
[CanBeNull] IModel model,
[NotNull] SqlBatchBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
builder
.Append("CREATE SEQUENCE ")
.Append(_sql.DelimitIdentifier(operation.Name, operation.Schema));
builder
.Append(" START WITH ")
.Append(_sql.GenerateLiteral(operation.StartWith));
SequenceOptions(operation, model, builder);
}
public static OperationBuilderSurface <CreateSequenceOperation> CreateSequence(this IMigrationBuilder builder, string name, string schema = null, string catalog = null, DbType dbType = DbType.Int64, long?startValue = null, long?increment = null, long?minValue = null, long?maxValue = null, bool cycle = false, int?cache = null)
{
var op = new CreateSequenceOperation
{
Name = new ObjectName(catalog, schema, name),
Cycle = cycle,
StartWith = startValue,
MaxValue = maxValue,
MinValue = minValue,
Increment = increment,
DbType = dbType,
Cache = cache
};
builder.AddOperation(op);
return(new OperationBuilderSurface <CreateSequenceOperation>(op));
}
public override void Generate([NotNull] CreateSequenceOperation createSequenceOperation, [NotNull] IndentedStringBuilder stringBuilder)
{
Check.NotNull(createSequenceOperation, "createSequenceOperation");
Check.NotNull(stringBuilder, "stringBuilder");
var sequence = createSequenceOperation.Sequence;
stringBuilder
.Append("CreateSequence(")
.Append(GenerateLiteral(sequence.Name))
.Append(", ")
.Append(GenerateLiteral(sequence.DataType))
.Append(", ")
.Append(sequence.StartWith)
.Append(", ")
.Append(sequence.IncrementBy)
.Append(")");
}
public void Visit_with_create_sequence_operation()
{
var model = new DatabaseModel();
var sequence = new Sequence("dbo.MySequence", "bigint", 2, 3);
var operation = new CreateSequenceOperation(sequence);
Assert.Equal(0, model.Sequences.Count);
operation.Accept(new DatabaseModelModifier(), model);
Assert.Equal(1, model.Sequences.Count);
Assert.NotSame(sequence, model.Sequences[0]);
Assert.Equal("dbo.MySequence", model.Sequences[0].Name);
Assert.Equal("bigint", model.Sequences[0].DataType);
Assert.Equal(2, model.Sequences[0].StartWith);
Assert.Equal(3, model.Sequences[0].IncrementBy);
}
protected override void Generate(CreateSequenceOperation operation, IModel model, MigrationCommandListBuilder builder)
{
Check.NotNull(operation, nameof(operation));
if (VersionAtLeast(10, 0))
{
base.Generate(operation, model, builder);
}
else
{
// "CREATE SEQUENCE name AS type" expression is supported only in PostgreSQL 10 or above.
// The base MigrationsSqlGenerator.Generate method generates that expression.
// https://github.com/aspnet/EntityFrameworkCore/blob/master/src/EFCore.Relational/Migrations/MigrationsSqlGenerator.cs#L533-L535
var oldValue = operation.ClrType;
operation.ClrType = typeof(long);
base.Generate(operation, model, builder);
operation.ClrType = oldValue;
}
}
