public DropIndexOperation(SchemaQualifiedName tableName, [NotNull] string indexName) { Check.NotNull(indexName, "indexName"); _tableName = tableName; _indexName = indexName; }
public AddColumnOperation(SchemaQualifiedName tableName, [NotNull] Column column) { Check.NotNull(column, "column"); _tableName = tableName; _column = column; }
private void HandleTransitiveRenames() { const string temporaryNamePrefix = "__mig_tmp__"; var temporaryNameIndex = 0; _operations.Set( HandleTransitiveRenames( _operations.Get <RenameTableOperation>(), getParentName: op => null, getName: op => op.TableName, getNewName: op => new SchemaQualifiedName(op.NewTableName, op.TableName.Schema), generateTempName: (op) => new SchemaQualifiedName(temporaryNamePrefix + temporaryNameIndex++, op.TableName.Schema), createRenameOperation: (parentName, name, newName) => new RenameTableOperation(name, SchemaQualifiedName.Parse(newName).Name))); _operations.Set( HandleTransitiveRenames( _operations.Get <RenameColumnOperation>(), getParentName: op => op.TableName, getName: op => op.ColumnName, getNewName: op => op.NewColumnName, generateTempName: (op) => temporaryNamePrefix + temporaryNameIndex++, createRenameOperation: (parentName, name, newName) => new RenameColumnOperation(parentName, name, newName))); _operations.Set( HandleTransitiveRenames( _operations.Get <RenameIndexOperation>(), getParentName: op => op.TableName, getName: op => op.IndexName, getNewName: op => op.NewIndexName, generateTempName: (op) => temporaryNamePrefix + temporaryNameIndex++, createRenameOperation: (parentName, name, newName) => new RenameIndexOperation(parentName, name, newName))); }
public AlterSequenceOperation(SchemaQualifiedName sequenceName, int newIncrementBy) { Check.NotNull(newIncrementBy, "newIncrementBy"); _sequenceName = sequenceName; _newIncrementBy = newIncrementBy; }
public DropForeignKeyOperation(SchemaQualifiedName tableName, [NotNull] string foreignKeyName) { Check.NotEmpty(foreignKeyName, "foreignKeyName"); _tableName = tableName; _foreignKeyName = foreignKeyName; }
public DropColumnOperation(SchemaQualifiedName tableName, [NotNull] string columnName) { Check.NotEmpty(columnName, "columnName"); _tableName = tableName; _columnName = columnName; }
public DropPrimaryKeyOperation(SchemaQualifiedName tableName, [NotNull] string primaryKeyName) { Check.NotEmpty(primaryKeyName, "primaryKeyName"); _tableName = tableName; _primaryKeyName = primaryKeyName; }
public DropUniqueConstraintOperation(SchemaQualifiedName tableName, [NotNull] string uniqueConstraintName) { Check.NotEmpty(uniqueConstraintName, "uniqueConstraintName"); _tableName = tableName; _uniqueConstraintName = uniqueConstraintName; }
public RenameTableOperation(SchemaQualifiedName tableName, [NotNull] string newTableName) { Check.NotEmpty(newTableName, "newTableName"); _tableName = tableName; _newTableName = newTableName; }
protected virtual void GenerateColumn( SchemaQualifiedName tableName, [NotNull] Column column, [NotNull] IndentedStringBuilder stringBuilder) { Check.NotNull(column, "column"); Check.NotNull(stringBuilder, "stringBuilder"); stringBuilder .Append(DelimitIdentifier(column.Name)) .Append(" "); stringBuilder.Append(column.DataType ?? GenerateDataType(tableName, column)); if (!column.IsNullable) { stringBuilder.Append(" NOT NULL"); } GenerateColumnTraits(column, stringBuilder); if (column.DefaultSql != null) { stringBuilder .Append(" DEFAULT ") .Append(column.DefaultSql); } else if (column.DefaultValue != null) { stringBuilder .Append(" DEFAULT ") .Append(GenerateLiteral(column.DefaultValue)); } }
public void Parse_parses_name_with_escaped_delimeters() { var schemaQualifiedName = SchemaQualifiedName.Parse("[a.]].]]].[.b.[c]]d]"); Assert.Equal("a.].]", schemaQualifiedName.Schema); Assert.Equal(".b.[c]d", schemaQualifiedName.Name); }
public RenameSequenceOperation(SchemaQualifiedName sequenceName, [NotNull] string newSequenceName) { Check.NotEmpty(newSequenceName, "newSequenceName"); _sequenceName = sequenceName; _newSequenceName = newSequenceName; }
public MoveSequenceOperation(SchemaQualifiedName sequenceName, [NotNull] string newSchema) { Check.NotEmpty(newSchema, "newSchema"); _sequenceName = sequenceName; _newSchema = newSchema; }
public MoveTableOperation(SchemaQualifiedName tableName, [NotNull] string newSchema) { Check.NotEmpty(newSchema, "newSchema"); _tableName = tableName; _newSchema = newSchema; }
public void Equals_returns_false_when_names_equal_and_schemas_not_equal() { var schemaQualifiedName1 = new SchemaQualifiedName("T", "S1"); var schemaQualifiedName2 = new SchemaQualifiedName("T", "S2"); Assert.NotEqual(schemaQualifiedName1, schemaQualifiedName2); }
public void Parse_parses_table_name() { var schemaQualifiedName = SchemaQualifiedName.Parse("A"); Assert.Equal(null, schemaQualifiedName.Schema); Assert.Equal("A", schemaQualifiedName.Name); }
public virtual TableOperationHandler EnsureHandler(SchemaQualifiedName tableName, bool supported) { var handler = GetHandler(tableName); if (handler == null) { var table = _generator.Database.TryGetTable(tableName); var columnNames = table != null?table.Columns.Select(c => c.Name) : Enumerable.Empty <string>(); SetHandler(handler = supported ? (TableOperationHandler) new AlterTableHandler(tableName, columnNames) : new RebuildTableHandler(tableName, columnNames)); } else if (!supported) { var alterTableHandler = handler as AlterTableHandler; if (alterTableHandler != null) { SetHandler(handler = new RebuildTableHandler(alterTableHandler)); } } return(handler); }
public override IEnumerable <MigrationOperation> HandleOperations(Context context) { Check.NotNull(context, "context"); context.Generator.DatabaseModelModifier.Modify(context.Database, Operations); var targetTable = context.Database.GetTable(TableName); var sourceTableName = InitialTableName; var targetColumnNames = targetTable.Columns .Where(c => ColumnNamePairs.ContainsKey(c.Name)) .Select(c => c.Name) .ToArray(); var sourceColumnNames = targetColumnNames .Select(n => ColumnNamePairs[n]) .ToArray(); if (sourceTableName == targetTable.Name) { sourceTableName = new SchemaQualifiedName("__mig_tmp__" + sourceTableName.Name, sourceTableName.Schema); yield return(new RenameTableOperation(targetTable.Name, sourceTableName.Name)); } yield return(new CreateTableOperation(targetTable)); yield return(new CopyDataOperation( sourceTableName, sourceColumnNames, targetTable.Name, targetColumnNames)); context.AddDeferredOperation(new DropTableOperation(sourceTableName)); }
public void Equals_returns_true_when_names_equal_and_no_schema_specified() { var schemaQualifiedName1 = new SchemaQualifiedName("T"); var schemaQualifiedName2 = new SchemaQualifiedName("T"); Assert.Equal(schemaQualifiedName1, schemaQualifiedName2); }
public RenameTableOperation(SchemaQualifiedName tableName, [NotNull] string newTableName) { Check.NotEmpty(tableName, "tableName"); _tableName = tableName; _newTableName = newTableName; }
public override void AppendUpdateOperation( StringBuilder commandStringBuilder, SchemaQualifiedName schemaQualifiedName, IReadOnlyList <ColumnModification> operations) { Check.NotNull(commandStringBuilder, "commandStringBuilder"); Check.NotNull(operations, "operations"); var writeOperations = operations.Where(o => o.IsWrite).ToArray(); var conditionOperations = operations.Where(o => o.IsCondition).ToArray(); var readOperations = operations.Where(o => o.IsRead).ToArray(); AppendUpdateCommandHeader(commandStringBuilder, schemaQualifiedName, writeOperations); if (readOperations.Length > 0) { AppendOutputClause(commandStringBuilder, readOperations); } AppendWhereClause(commandStringBuilder, conditionOperations); commandStringBuilder.Append(BatchCommandSeparator).AppendLine(); if (readOperations.Length == 0) { AppendSelectAffectedCountCommand(commandStringBuilder, schemaQualifiedName); } }
protected virtual void GenerateColumn( SchemaQualifiedName tableName, [NotNull] Column column, [NotNull] SqlBatchBuilder batchBuilder) { Check.NotNull(column, "column"); Check.NotNull(batchBuilder, "batchBuilder"); if (column.IsComputed && column.DefaultSql != null) { GenerateComputedColumn(tableName, column, batchBuilder); return; } batchBuilder .Append(DelimitIdentifier(column.Name)) .Append(" "); GenerateColumnType(tableName, column, batchBuilder); GenerateNullConstraint(tableName, column, batchBuilder); GenerateColumnTraits(tableName, column, batchBuilder); GenerateDefaultConstraint(tableName, column, batchBuilder); }
public void Parse_parses_schema_dot_table_name() { var schemaQualifiedName = SchemaQualifiedName.Parse("S.A"); Assert.Equal("S", schemaQualifiedName.Schema); Assert.Equal("A", schemaQualifiedName.Name); Assert.True(schemaQualifiedName.IsSchemaQualified); }
protected TableOperationHandler(SchemaQualifiedName tableName, [NotNull] IEnumerable <string> columnNames) { Check.NotNull(columnNames, "columnNames"); TableName = _initialTableName = tableName; _operations = new List <MigrationOperation>(); _columnNamePairs = columnNames.ToDictionary(n => n); }
public override string DelimitIdentifier(SchemaQualifiedName schemaQualifiedName) { return(DelimitIdentifier( (schemaQualifiedName.IsSchemaQualified ? schemaQualifiedName.Schema + "." : string.Empty) + schemaQualifiedName.Name)); }
public ModificationCommand(SchemaQualifiedName schemaQualifiedName, [NotNull] ParameterNameGenerator parameterNameGenerator) { Check.NotEmpty(schemaQualifiedName, "schemaQualifiedName"); Check.NotNull(parameterNameGenerator, "parameterNameGenerator"); _schemaQualifiedName = schemaQualifiedName; _parameterNameGenerator = parameterNameGenerator; }
public virtual void AddUniqueConstraint(SchemaQualifiedName tableName, [NotNull] string uniqueConstraintName, [NotNull] IReadOnlyList <string> columnNames) { Check.NotEmpty(uniqueConstraintName, "uniqueConstraintName"); Check.NotNull(columnNames, "columnNames"); AddOperation(new AddUniqueConstraintOperation(tableName, uniqueConstraintName, columnNames)); }
public virtual void RenameIndex(SchemaQualifiedName tableName, [NotNull] string indexName, [NotNull] string newIndexName) { Check.NotEmpty(indexName, "indexName"); Check.NotEmpty(newIndexName, "newIndexName"); AddOperation(new RenameIndexOperation(tableName, indexName, newIndexName)); }
public virtual string DelimitIdentifier(SchemaQualifiedName schemaQualifiedName) { return ((schemaQualifiedName.IsSchemaQualified ? DelimitIdentifier(schemaQualifiedName.Schema) + "." : string.Empty) + DelimitIdentifier(schemaQualifiedName.Name)); }
public virtual void CreateIndex(SchemaQualifiedName tableName, [NotNull] string indexName, [NotNull] IReadOnlyList <string> columnNames, bool isUnique, bool isClustered) { Check.NotEmpty(indexName, "indexName"); Check.NotNull(columnNames, "columnNames"); AddOperation(new CreateIndexOperation(tableName, indexName, columnNames, isUnique, isClustered)); }
public AddUniqueConstraintOperation([NotNull] UniqueConstraint uniqueConstraint) { Check.NotNull(uniqueConstraint, "uniqueConstraint"); _tableName = uniqueConstraint.Table.Name; _uniqueConstraintName = uniqueConstraint.Name; _columnNames = uniqueConstraint.Columns.Select(c => c.Name).ToArray(); }
public RenameColumnOperation(SchemaQualifiedName tableName, [NotNull] string columnName, [NotNull] string newColumnName) { Check.NotEmpty(columnName, "columnName"); Check.NotEmpty(newColumnName, "newColumnName"); _tableName = tableName; _columnName = columnName; _newColumnName = newColumnName; }
public Sequence(SchemaQualifiedName name, [NotNull] string dataType, int startWith, int incrementBy) { Check.NotEmpty(dataType, "dataType"); _name = name; _dataType = dataType; StartWith = startWith; _incrementBy = incrementBy; }
public Table(SchemaQualifiedName name, [NotNull] IEnumerable<Column> columns) { Check.NotNull(columns, "columns"); _name = name; foreach (var column in columns) { AddColumn(column); } }
public AlterColumnOperation( SchemaQualifiedName tableName, [NotNull] Column newColumn, bool isDestructiveChange) { Check.NotNull(newColumn, "newColumn"); _tableName = tableName; _newColumn = newColumn; _isDestructiveChange = isDestructiveChange; }
public RenameIndexOperation( SchemaQualifiedName tableName, [NotNull] string indexName, [NotNull] string newIndexName) { Check.NotEmpty(indexName, "indexName"); Check.NotEmpty(newIndexName, "newIndexName"); _tableName = tableName; _indexName = indexName; _newIndexName = newIndexName; }
public AddPrimaryKeyOperation( SchemaQualifiedName tableName, [NotNull] string primaryKeyName, [NotNull] IReadOnlyList<string> columnNames, bool isClustered) { Check.NotEmpty(primaryKeyName, "primaryKeyName"); Check.NotNull(columnNames, "columnNames"); _tableName = tableName; _primaryKeyName = primaryKeyName; _columnNames = columnNames; _isClustered = isClustered; }
public AddDefaultConstraintOperation( SchemaQualifiedName tableName, [NotNull] string columnName, [CanBeNull] object defaultValue, [CanBeNull] string defaultSql) { Check.NotEmpty(columnName, "columnName"); // TODO: Validate input. Either defaultValue or defaultSql must not be null, but not both. _tableName = tableName; _columnName = columnName; _defaultValue = defaultValue; _defaultSql = defaultSql; }
public CreateIndexOperation( SchemaQualifiedName tableName, [NotNull] string indexName, [NotNull] IReadOnlyList<string> columnNames, bool isUnique, bool isClustered) { Check.NotEmpty(indexName, "indexName"); Check.NotNull(columnNames, "columnNames"); _tableName = tableName; _indexName = indexName; _columnNames = columnNames; _isUnique = isUnique; _isClustered = isClustered; }
public AddForeignKeyOperation( SchemaQualifiedName tableName, [NotNull] string foreignKeyName, [NotNull] IReadOnlyList<string> columnNames, SchemaQualifiedName referencedTableName, [NotNull] IReadOnlyList<string> referencedColumnNames, bool cascadeDelete) { Check.NotEmpty(foreignKeyName, "foreignKeyName"); Check.NotNull(columnNames, "columnNames"); Check.NotNull(referencedColumnNames, "referencedColumnNames"); _foreignKeyName = foreignKeyName; _tableName = tableName; _referencedTableName = referencedTableName; _columnNames = columnNames; _referencedColumnNames = referencedColumnNames; _cascadeDelete = cascadeDelete; }
public Sequence(SchemaQualifiedName name) { _name = name; }
public Table(SchemaQualifiedName name) { _name = name; }
public void To_string_returns_schema_and_table_name_when_schema_specified() { var schemaQualifiedName = new SchemaQualifiedName("T", "S"); Assert.Equal("S.T", schemaQualifiedName.ToString()); }
public DropSequenceOperation(SchemaQualifiedName sequenceName) { _sequenceName = sequenceName; }
public void DelimitIdentifier_with_schema_qualified_name_works_when_no_schema() { var name = new SchemaQualifiedName("Pony"); var sql = CreateGenerator().DelimitIdentifier(name); Assert.Equal("\"Pony\"", sql); }
public void DelimitIdentifier_with_schema_qualified_name_concatenates_parts_when_schema() { var name = new SchemaQualifiedName("Pony", "my"); var sql = CreateGenerator().DelimitIdentifier(name); Assert.Equal("\"my.Pony\"", sql); }
public virtual string GenerateDataType(SchemaQualifiedName tableName, [NotNull] Column column) { Check.NotNull(column, "column"); if (!string.IsNullOrEmpty(column.DataType)) { return column.DataType; } var isKey = false; if (Database != null) { var table = Database.GetTable(tableName); isKey = table.PrimaryKey != null && table.PrimaryKey.Columns.Contains(column) || table.ForeignKeys.SelectMany(k => k.Columns).Contains(column); } return _typeMapper.GetTypeMapping(column.DataType, column.Name, column.ClrType, isKey, column.IsTimestamp).StoreTypeName; }
protected virtual void GenerateColumns( SchemaQualifiedName tableName, [NotNull] IReadOnlyList<Column> columns, [NotNull] IndentedStringBuilder stringBuilder) { Check.NotNull(columns, "columns"); Check.NotNull(stringBuilder, "stringBuilder"); if (columns.Count == 0) { return; } GenerateColumn(tableName, columns[0], stringBuilder); for (var i = 1; i < columns.Count; i++) { stringBuilder.AppendLine(","); GenerateColumn(tableName, columns[i], stringBuilder); } }
public override string DelimitIdentifier(SchemaQualifiedName schemaQualifiedName) { return DelimitIdentifier( (schemaQualifiedName.IsSchemaQualified ? schemaQualifiedName.Schema + "." : string.Empty) + schemaQualifiedName.Name); }
public DropTableOperation(SchemaQualifiedName tableName) { _tableName = tableName; }
// TODO: Consider adding a base class for all SQL generators (DDL, DML), // to avoid duplicating the five methods below. public virtual string DelimitIdentifier(SchemaQualifiedName schemaQualifiedName) { return (schemaQualifiedName.IsSchemaQualified ? DelimitIdentifier(schemaQualifiedName.Schema) + "." : string.Empty) + DelimitIdentifier(schemaQualifiedName.Name); }