/// <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); }