/// <summary>
/// Insert a <see cref="IMigrationExpression"/> into the list
/// </summary>
/// <param name="list"></param>
/// <param name="indexItem"></param>
/// <param name="newItemToInsert"></param>
/// <param name="after"></param>
/// <returns></returns>
public static IList <IMigrationExpression> Insert(this IList <IMigrationExpression> list,
IMigrationExpression indexItem,
IMigrationExpression newItemToInsert,
bool after = false)
{
if (list?.Contains(newItemToInsert) ?? true)
{
return(list);
}
var index = list.IndexOf(indexItem);
if (index < 0)
{
list.Add(newItemToInsert);
}
else
{
if (after)
{
index++;
}
list.Insert(index, newItemToInsert);
}
return(list);
}
public void SetExistingRows_AddsAllRowsExpression()
{
var builderMock = new Mock <IColumnExpressionBuilder>();
var contextMock = new Mock <IMigrationContext>();
IMigrationExpression addedExpression = null;
contextMock
.Setup(n => n.Expressions.Add(It.IsAny <IMigrationExpression>()))
.Callback((IMigrationExpression ex) => addedExpression = ex);
builderMock.SetupGet(n => n.SchemaName).Returns("Fred");
builderMock.SetupGet(n => n.TableName).Returns("Flinstone");
builderMock.SetupGet(n => n.Column.Name).Returns("ColName");
builderMock.SetupGet(n => n.Column.ModificationType).Returns(ColumnModificationType.Create);
var helper = new ColumnExpressionBuilderHelper(builderMock.Object, contextMock.Object);
helper.SetExistingRowsTo(5);
contextMock.Verify(n => n.Expressions.Add(It.IsAny <IMigrationExpression>()), Times.Once());
//Check that the update data expression was added as expected. Maybe there's a cleaner way to do this?
Assert.IsInstanceOf <UpdateDataExpression>(addedExpression);
UpdateDataExpression updateDataExpr = (UpdateDataExpression)addedExpression;
Assert.IsNotNull(updateDataExpr);
Assert.AreEqual("Fred", updateDataExpr.SchemaName);
Assert.AreEqual("Flinstone", updateDataExpr.TableName);
Assert.AreEqual(true, updateDataExpr.IsAllRows);
Assert.AreEqual(1, updateDataExpr.Set.Count);
Assert.AreEqual("ColName", updateDataExpr.Set[0].Key);
Assert.AreEqual(5, updateDataExpr.Set[0].Value);
}
/// <summary>
/// Common constructor
/// </summary>
/// <param name="changeLog">The <see cref="ChangeLogContext"/> object</param>
/// <param name="expression">The <see cref="IMigrationExpression"/> object</param>
protected ChangeLogLinkedExpression(ChangeLogContext changeLog, IMigrationExpression expression)
{
Operation = (connection, transaction) => { };
Expression = expression;
ChangeLogContext = changeLog;
DbOperation = Expression.GetDbOperationFromExpression();
GetColumns = () => new List <ColumnDefinition>();
}
protected FirebirdProcessedExpressionBase(IMigrationExpression expression, Type expressionType, FirebirdProcessor processor)
{
Processor = processor;
Expression = expression;
this.expressionType = expressionType;
if (processor.FBOptions.UndoEnabled && !processor.IsRunningOutOfMigrationScope())
{
SetupUndoExpressions();
}
}
/// <summary>
/// Resolve Database operation from <paramref name="expression"/><br/>
/// <br/>
/// i.e: AlterColumnExpression => AlterColumn, CreateTableExpression => CreateTable, AlterTableExpression => AlterTable
/// </summary>
/// <param name="expression"></param>
/// <returns></returns>
public static string GetDbOperationFromExpression(this IMigrationExpression expression)
{
var dbOperation = expression.GetType().Name;
var index = dbOperation.IndexOf("Expression", StringExtensions.CurrentIgnoreCaseStringComparison);
if (index > -1)
{
dbOperation = dbOperation.Substring(0, index);
}
return(dbOperation);
}
/// <summary>
/// Replace a <see cref="IMigrationExpression"/> in the list
/// </summary>
/// <param name="list"></param>
/// <param name="itemToBeReplaced"></param>
/// <param name="newItem"></param>
/// <returns></returns>
public static IList <IMigrationExpression> Replace(this IList <IMigrationExpression> list,
IMigrationExpression itemToBeReplaced,
IMigrationExpression newItem)
{
var index = list.IndexOf(itemToBeReplaced);
if (index < 0)
{
list.Add(newItem);
}
else
{
list[index] = newItem;
}
return(list);
}
/// <inheritdoc />
public virtual IEnumerable <ValidationResult> Validate(IMigrationExpression expression)
{
var items = new Dictionary <object, object>();
var context = new ValidationContext(expression, items);
if (_serviceProvider != null)
{
context.InitializeServiceProvider(_serviceProvider.GetService);
}
var result = new List <ValidationResult>();
if (!ValidationUtilities.TryCollectResults(context, expression, result))
{
return(result);
}
return(Enumerable.Empty <ValidationResult>());
}
protected void Run(IMigrationExpression expression, IDbConnection connection, IDbTransaction transaction)
{
if (expression is PerformDBOperationExpression)
{
(expression as PerformDBOperationExpression).Operation(connection, transaction);
return;
}
string sql = GenerateSql(expression);
if (String.IsNullOrEmpty(sql))
{
return;
}
Processor.Announcer.Sql(sql);
using (var command = Processor.Factory.CreateCommand(sql, connection, transaction, Processor.Options))
{
command.ExecuteNonQuery();
}
}
protected string GenerateSql(IMigrationExpression expression)
{
string result = null;
try
{
MethodInfo generatorMethod = Processor.Generator.GetType().GetMethod("Generate", new Type[] { expression.GetType() });
if (generatorMethod == null)
{
throw new ArgumentOutOfRangeException(String.Format("Can't find generator for {0}", expression.ToString()));
}
result = generatorMethod.Invoke(Processor.Generator, new object[] { expression }) as string;
}
catch (Exception e)
{
throw new ArgumentOutOfRangeException(String.Format("Can't find generator for {0}", expression.ToString()), e);
}
return(result);
}
public static string GetSqlEquivalent(this IMigrationExpression migrationExpression, IMigrationGenerator migrationGenerator)
{
if (migrationExpression is ExecuteSqlScriptExpression executeSqlScriptExpression)
{
return(executeSqlScriptExpression.SqlScript);
}
else if (migrationExpression is ExecuteSqlStatementExpression executeSqlStatementExpression)
{
return(executeSqlStatementExpression.SqlStatement);
}
else
{
if (migrationExpression is CreateForeignKeyExpression cfke)
{
cfke.ForeignKey.ForeignColumns = cfke.ForeignKey.ForeignColumns.Select(c => c.ToSnakeCase()).ToList();
cfke.ForeignKey.PrimaryColumns = cfke.ForeignKey.PrimaryColumns.Select(c => c.ToSnakeCase()).ToList();
cfke.ForeignKey.ForeignTable = cfke.ForeignKey.ForeignTable.ToSnakeCase();
cfke.ForeignKey.PrimaryTable = cfke.ForeignKey.PrimaryTable.ToSnakeCase();
cfke.ForeignKey.Name = cfke.ForeignKey.Name ??
$"FK_{cfke.ForeignKey.ForeignTable}_{cfke.ForeignKey.ForeignColumns.First()}_{cfke.ForeignKey.PrimaryTable}_{cfke.ForeignKey.PrimaryColumns.First()}";
}
else if (migrationExpression is CreateTableExpression cte)
{
List <ColumnDefinition> columnDefinitions = cte.Columns.ToList();
columnDefinitions.ForEach(cd => cd.Name = cd.Name.ToSnakeCase());
cte.Columns = columnDefinitions;
}
else if (migrationExpression is CreateConstraintExpression cce && cce.Constraint.IsPrimaryKeyConstraint)
{
cce.Constraint.Columns = cce.Constraint.Columns.Select(c => c.ToSnakeCase()).ToList();
cce.Constraint.ConstraintName = $"PK_{cce.Constraint.TableName}";
}
MethodInfo processMethod = migrationGenerator.GetType().GetMethod("Generate", new[] { migrationExpression.GetType() });
string sql = (string)processMethod.Invoke(migrationGenerator, new[] { migrationExpression });
return(sql);
}
}
public void AddUndoExpression(IMigrationExpression expression)
{
CanUndo = true;
UndoExpressions.Add(expression);
}
private void ApplyDefaultConventions(IMigrationExpression expression)
{
expression.ApplyConventions(new MigrationConventions());
}
public DifferentialExpression(IMigrationExpression up, MigrationExpressionBase down) : this((MigrationExpressionBase)up, down)
{
}
protected FirebirdProcessedExpressionBase(IMigrationExpression expression, Type expressionType, FirebirdProcessor processor)
{
Processor = processor;
Expression = expression;
this.expressionType = expressionType;
}
public ExecutableBuilder(IMigrationExpression expression) => _expression = expression;
protected void RegisterExpression(IMigrationExpression expression, Type expressionType)
{
RegisterExpression(new FirebirdProcessedExpression(expression, expressionType, this) as FirebirdProcessedExpressionBase);
}
private void ApplyDefaultConventions(IMigrationExpression expression)
{
expression.ApplyConventions(new MigrationConventions());
}
