Add TPC support to update pipeline

src/EFCore.Relational/Infrastructure/EntityFrameworkRelationalServicesBuilder.cs

@@ -44,7 +44,9 @@ public class EntityFrameworkRelationalServicesBuilder : EntityFrameworkServicesB
  public static readonly IDictionary<Type, ServiceCharacteristics> RelationalServices
  = new Dictionary<Type, ServiceCharacteristics>
  {
- { typeof(IKeyValueIndexFactorySource), new ServiceCharacteristics(ServiceLifetime.Singleton) },
+ { typeof(IRowKeyValueFactoryFactory), new ServiceCharacteristics(ServiceLifetime.Singleton) },
+ { typeof(IRowForeignKeyValueFactoryFactory), new ServiceCharacteristics(ServiceLifetime.Singleton) },
+ { typeof(IRowIndexValueFactoryFactory), new ServiceCharacteristics(ServiceLifetime.Singleton) },
  { typeof(IParameterNameGeneratorFactory), new ServiceCharacteristics(ServiceLifetime.Singleton) },
  { typeof(IComparer<IReadOnlyModificationCommand>), new ServiceCharacteristics(ServiceLifetime.Singleton) },
  { typeof(IMigrationsIdGenerator), new ServiceCharacteristics(ServiceLifetime.Singleton) },
@@ -125,7 +127,9 @@ public override EntityFrameworkServicesBuilder TryAddCoreServices()
  TryAdd<IParameterNameGeneratorFactory, ParameterNameGeneratorFactory>();
  TryAdd<IComparer<IReadOnlyModificationCommand>, ModificationCommandComparer>();
  TryAdd<IMigrationsIdGenerator, MigrationsIdGenerator>();
- TryAdd<IKeyValueIndexFactorySource, KeyValueIndexFactorySource>();
+ TryAdd<IRowKeyValueFactoryFactory, RowKeyValueFactoryFactory>();
+ TryAdd<IRowForeignKeyValueFactoryFactory, RowForeignKeyValueFactoryFactory>();
+ TryAdd<IRowIndexValueFactoryFactory, RowIndexValueFactoryFactory>();
  TryAdd<IModelCustomizer, RelationalModelCustomizer>();
  TryAdd<IModelRuntimeInitializer, RelationalModelRuntimeInitializer>();
  TryAdd<IRelationalAnnotationProvider, RelationalAnnotationProvider>();

src/EFCore.Relational/Infrastructure/RelationalModelDependencies.cs

@@ -1,6 +1,8 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using Microsoft.EntityFrameworkCore.Update.Internal;
+
 namespace Microsoft.EntityFrameworkCore.Infrastructure;
 
 /// <summary>
@@ -45,7 +47,40 @@ public sealed record RelationalModelDependencies
  /// the constructor at any point in this process.
  /// </remarks>
  [EntityFrameworkInternal]
- public RelationalModelDependencies()
+ public RelationalModelDependencies(
+ IRowKeyValueFactoryFactory rowKeyValueFactoryFactory,
+ IRowForeignKeyValueFactoryFactory foreignKeyRowValueFactorySource,
+ IRowIndexValueFactoryFactory rowIndexValueFactoryFactory)
  {
+ RowKeyValueFactoryFactory = rowKeyValueFactoryFactory;
+ RowForeignKeyValueFactoryFactory = foreignKeyRowValueFactorySource;
+ RowIndexValueFactoryFactory = rowIndexValueFactoryFactory;
  }
+
+ /// <summary>
+ /// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+ /// the same compatibility standards as public APIs. It may be changed or removed without notice in
+ /// any release. You should only use it directly in your code with extreme caution and knowing that
+ /// doing so can result in application failures when updating to a new Entity Framework Core release.
+ /// </summary>
+ [EntityFrameworkInternal]
+ public IRowKeyValueFactoryFactory RowKeyValueFactoryFactory { get; init; }
+
+ /// <summary>
+ /// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+ /// the same compatibility standards as public APIs. It may be changed or removed without notice in
+ /// any release. You should only use it directly in your code with extreme caution and knowing that
+ /// doing so can result in application failures when updating to a new Entity Framework Core release.
+ /// </summary>
+ [EntityFrameworkInternal]
+ public IRowForeignKeyValueFactoryFactory RowForeignKeyValueFactoryFactory { get; init; }
+
+ /// <summary>
+ /// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+ /// the same compatibility standards as public APIs. It may be changed or removed without notice in
+ /// any release. You should only use it directly in your code with extreme caution and knowing that
+ /// doing so can result in application failures when updating to a new Entity Framework Core release.
+ /// </summary>
+ [EntityFrameworkInternal]
+ public IRowIndexValueFactoryFactory RowIndexValueFactoryFactory { get; init; }
 }

src/EFCore.Relational/Infrastructure/RelationalModelValidator.cs

@@ -559,10 +559,10 @@ protected virtual void ValidateSharedViewCompatibility(
  mappedTypes.Add(entityType);
  }
 
- foreach (var (table, mappedTypes) in views)
+ foreach (var (view, mappedTypes) in views)
  {
- ValidateSharedViewCompatibility(mappedTypes, table.Name, table.Schema, logger);
- ValidateSharedColumnsCompatibility(mappedTypes, table, logger);
+ ValidateSharedViewCompatibility(mappedTypes, view.Name, view.Schema, logger);
+ ValidateSharedColumnsCompatibility(mappedTypes, view, logger);
  }
  }
 
@@ -866,10 +866,12 @@ protected virtual void ValidateCompatible(
  storeObject.DisplayName()));
  }
 
+ var typeMapping = property.GetRelationalTypeMapping();
+ var duplicateTypeMapping = duplicateProperty.GetRelationalTypeMapping();
  var currentTypeString = property.GetColumnType(storeObject)
- ?? property.GetRelationalTypeMapping().StoreType;
+ ?? typeMapping.StoreType;
  var previousTypeString = duplicateProperty.GetColumnType(storeObject)
- ?? duplicateProperty.GetRelationalTypeMapping().StoreType;
+ ?? duplicateTypeMapping.StoreType;
  if (!string.Equals(currentTypeString, previousTypeString, StringComparison.OrdinalIgnoreCase))
  {
  throw new InvalidOperationException(
@@ -884,6 +886,22 @@ protected virtual void ValidateCompatible(
  currentTypeString));
  }
 
+ var currentProviderType = typeMapping.Converter?.ProviderClrType ?? typeMapping.ClrType;
+ var previousProviderType = duplicateTypeMapping.Converter?.ProviderClrType ?? duplicateTypeMapping.ClrType;
+ if (currentProviderType != previousProviderType)
+ {
+ throw new InvalidOperationException(
+ RelationalStrings.DuplicateColumnNameProviderTypeMismatch(
+ duplicateProperty.DeclaringEntityType.DisplayName(),
+ duplicateProperty.Name,
+ property.DeclaringEntityType.DisplayName(),
+ property.Name,
+ columnName,
+ storeObject.DisplayName(),
+ previousProviderType.ShortDisplayName(),
+ currentProviderType.ShortDisplayName()));
+ }
+
  var currentComputedColumnSql = property.GetComputedColumnSql(storeObject) ?? "";
  var previousComputedColumnSql = duplicateProperty.GetComputedColumnSql(storeObject) ?? "";
  if (!currentComputedColumnSql.Equals(previousComputedColumnSql, StringComparison.OrdinalIgnoreCase))
@@ -1340,8 +1358,8 @@ protected override void ValidateInheritanceMapping(
  RelationalStrings.NonTphMappingStrategy(mappingStrategy, entityType.DisplayName()));
  }
 
- ValidateTPHMapping(entityType, forTables: false);
- ValidateTPHMapping(entityType, forTables: true);
+ ValidateTphMapping(entityType, forTables: false);
+ ValidateTphMapping(entityType, forTables: true);
  ValidateDiscriminatorValues(entityType);
  }
  else
@@ -1362,8 +1380,8 @@ protected override void ValidateInheritanceMapping(
  RelationalStrings.KeylessMappingStrategy(mappingStrategy ?? RelationalAnnotationNames.TptMappingStrategy, entityType.DisplayName()));
  }
 
- ValidateNonTPHMapping(entityType, forTables: false);
- ValidateNonTPHMapping(entityType, forTables: true);
+ ValidateNonTphMapping(entityType, forTables: false);
+ ValidateNonTphMapping(entityType, forTables: true);
  }
  }
  }
@@ -1387,7 +1405,7 @@ protected virtual void ValidateMappingStrategy(string? mappingStrategy, IEntityT
  };
  }
 
- private static void ValidateNonTPHMapping(IEntityType rootEntityType, bool forTables)
+ private static void ValidateNonTphMapping(IEntityType rootEntityType, bool forTables)
  {
  var derivedTypes = new Dictionary<(string, string?), IEntityType>();
  foreach (var entityType in rootEntityType.GetDerivedTypesInclusive())
@@ -1413,7 +1431,7 @@ private static void ValidateNonTPHMapping(IEntityType rootEntityType, bool forTa
  }
  }
 
- private static void ValidateTPHMapping(IEntityType rootEntityType, bool forTables)
+ private static void ValidateTphMapping(IEntityType rootEntityType, bool forTables)
  {
  string? firstName = null;
  string? firstSchema = null;

src/EFCore.Relational/Metadata/IColumn.cs

@@ -98,8 +98,7 @@ public virtual bool TryGetDefaultValue(out object? defaultValue)
  continue;
  }
 
- var converter = property.GetValueConverter() ?? PropertyMappings.First().TypeMapping.Converter;
-
+ var converter = property.GetValueConverter() ?? mapping.TypeMapping.Converter;
  if (converter != null)
  {
  defaultValue = converter.ConvertToProvider(defaultValue);
@@ -148,6 +147,24 @@ public virtual string? Collation
  => PropertyMappings.First().Property
  .GetCollation(StoreObjectIdentifier.Table(Table.Name, Table.Schema));
 
+ /// <summary>
+ /// Returns the property mapping for the given entity type.
+ /// </summary>
+ /// <param name="entityType"> An entity type. </param>
+ /// <returns> The property mapping or <see langword="null"/> if not found. </returns>
+ public virtual IColumnMapping? FindColumnMapping(IReadOnlyEntityType entityType)
+ {
+ foreach (var mapping in PropertyMappings)
+ {
+ if (mapping.Property.DeclaringEntityType.IsAssignableFrom(entityType))
+ {
+ return mapping;
+ }
+ }
+
+ return null;
+ }
+
  /// <summary>
  /// <para>
  /// Creates a human-readable representation of the given metadata.

src/EFCore.Relational/Metadata/IColumnBase.cs

@@ -21,6 +21,11 @@ public interface IColumnBase : IAnnotatable
  /// </summary>
  string StoreType { get; }
 
+ /// <summary>
+ /// Gets the provider type.
+ /// </summary>
+ Type ProviderClrType { get; }
+
  /// <summary>
  /// Gets the value indicating whether the column can contain NULL.
  /// </summary>

src/EFCore.Relational/Metadata/IForeignKeyConstraint.cs

@@ -42,7 +42,12 @@ public interface IForeignKeyConstraint : IAnnotatable
  /// <summary>
  /// Gets the columns that are referenced by the foreign key constraint.
  /// </summary>
- IReadOnlyList<IColumn> PrincipalColumns { get; }
+ IReadOnlyList<IColumn> PrincipalColumns => PrincipalUniqueConstraint.Columns;
+
+ /// <summary>
+ /// Gets the unique constraint on the columns referenced by the foreign key constraint.
+ /// </summary>
+ IUniqueConstraint PrincipalUniqueConstraint { get; }
 
  /// <summary>
  /// Gets the action to be performed when the referenced row is deleted.

src/EFCore.Relational/Metadata/ITable.cs

@@ -33,6 +33,11 @@ public interface ITable : ITableBase
  /// </summary>
  IEnumerable<IForeignKeyConstraint> ForeignKeyConstraints { get; }
 
+ /// <summary>
+ /// Gets the foreign key constraints referencing this table.
+ /// </summary>
+ IEnumerable<IForeignKeyConstraint> ReferencingForeignKeyConstraints { get; }
+
  /// <summary>
  /// Gets the unique constraints including the primary key for this table.
  /// </summary>

src/EFCore.Relational/Metadata/ITableBase.cs

@@ -21,6 +21,12 @@ public interface ITableBase : IAnnotatable
  /// </summary>
  string? Schema { get; }
 
+ /// <summary>
+ /// Gets the schema-qualified name of the table in the database.
+ /// </summary>
+ string SchemaQualifiedTableName
+ => Schema == null ? Name : Schema + "." + Name;
+
  /// <summary>
  /// Gets the database model.
  /// </summary>

src/EFCore.Relational/Metadata/Internal/Column.cs

@@ -1,6 +1,9 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using Microsoft.EntityFrameworkCore.Internal;
+using Microsoft.EntityFrameworkCore.Update.Internal;
+
 namespace Microsoft.EntityFrameworkCore.Metadata.Internal;
 
 /// <summary>
@@ -11,6 +14,9 @@ namespace Microsoft.EntityFrameworkCore.Metadata.Internal;
 /// </summary>
 public class Column : ColumnBase, IColumn
 {
+ // Warning: Never access these fields directly as access needs to be thread-safe
+ private ColumnAccessors? _accessors;
+
  /// <summary>
  /// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
  /// the same compatibility standards as public APIs. It may be changed or removed without notice in
@@ -31,6 +37,17 @@ public Column(string name, string type, Table table)
  public new virtual Table Table
  => (Table)base.Table;
 
+ /// <summary>
+ /// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+ /// the same compatibility standards as public APIs. It may be changed or removed without notice in
+ /// any release. You should only use it directly in your code with extreme caution and knowing that
+ /// doing so can result in application failures when updating to a new Entity Framework Core release.
+ /// </summary>
+ public virtual ColumnAccessors Accessors
+ => NonCapturingLazyInitializer.EnsureInitialized(
+ ref _accessors, this, static column =>
+ ColumnAccessorsFactory.Create(column));
+
  /// <summary>
  /// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
  /// the same compatibility standards as public APIs. It may be changed or removed without notice in

src/EFCore.Relational/Metadata/Internal/ColumnBase.cs

@@ -11,6 +11,8 @@ namespace Microsoft.EntityFrameworkCore.Metadata.Internal;
 /// </summary>
 public class ColumnBase : Annotatable, IColumnBase
 {
+ private Type? _providerClrType;
+
  /// <summary>
  /// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
  /// the same compatibility standards as public APIs. It may be changed or removed without notice in
@@ -65,6 +67,28 @@ public override bool IsReadOnly
  /// </summary>
  public virtual bool IsNullable { get; set; }
 
+ /// <summary>
+ /// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+ /// the same compatibility standards as public APIs. It may be changed or removed without notice in
+ /// any release. You should only use it directly in your code with extreme caution and knowing that
+ /// doing so can result in application failures when updating to a new Entity Framework Core release.
+ /// </summary>
+ public virtual Type ProviderClrType
+ {
+ get
+ {
+ if (_providerClrType != null)
+ {
+ return _providerClrType;
+ }
+
+ var typeMapping = PropertyMappings.First().TypeMapping;
+ var providerType = typeMapping.Converter?.ProviderClrType ?? typeMapping.ClrType;
+
+ return _providerClrType = providerType;
+ }
+ }
+
  /// <summary>
  /// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
  /// the same compatibility standards as public APIs. It may be changed or removed without notice in

src/EFCore.Relational/Metadata/Internal/ForeignKeyConstraint.cs

@@ -1,6 +1,9 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using Microsoft.EntityFrameworkCore.Internal;
+using Microsoft.EntityFrameworkCore.Update.Internal;
+
 namespace Microsoft.EntityFrameworkCore.Metadata.Internal;
 
 /// <summary>
@@ -22,14 +25,14 @@ public ForeignKeyConstraint(
  Table table,
  Table principalTable,
  IReadOnlyList<Column> columns,
- IReadOnlyList<Column> principalColumns,
+ UniqueConstraint principalUniqueConstraint,
  ReferentialAction onDeleteAction)
  {
  Name = name;
  Table = table;
  PrincipalTable = principalTable;
  Columns = columns;
- PrincipalColumns = principalColumns;
+ PrincipalUniqueConstraint = principalUniqueConstraint;
  OnDeleteAction = onDeleteAction;
  }
 
@@ -74,7 +77,15 @@ public ForeignKeyConstraint(
  /// any release. You should only use it directly in your code with extreme caution and knowing that
  /// doing so can result in application failures when updating to a new Entity Framework Core release.
  /// </summary>
- public virtual IReadOnlyList<Column> PrincipalColumns { get; }
+ public virtual IReadOnlyList<Column> PrincipalColumns => PrincipalUniqueConstraint.Columns;
+
+ /// <summary>
+ /// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+ /// the same compatibility standards as public APIs. It may be changed or removed without notice in
+ /// any release. You should only use it directly in your code with extreme caution and knowing that
+ /// doing so can result in application failures when updating to a new Entity Framework Core release.
+ /// </summary>
+ public virtual UniqueConstraint PrincipalUniqueConstraint { get; }
 
  /// <summary>
  /// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
@@ -88,6 +99,19 @@ public override bool IsReadOnly
  /// <inheritdoc />
  public virtual ReferentialAction OnDeleteAction { get; set; }
 
+ private IRowForeignKeyValueFactory? _foreignKeyRowValueFactory;
+
+ /// <summary>
+ /// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+ /// the same compatibility standards as public APIs. It may be changed or removed without notice in
+ /// any release. You should only use it directly in your code with extreme caution and knowing that
+ /// doing so can result in application failures when updating to a new Entity Framework Core release.
+ /// </summary>
+ public virtual IRowForeignKeyValueFactory GetRowForeignKeyValueFactory()
+ => NonCapturingLazyInitializer.EnsureInitialized(
+ ref _foreignKeyRowValueFactory, this,
+ static constraint => constraint.Table.Model.Model.GetRelationalDependencies().RowForeignKeyValueFactoryFactory.Create(constraint));
+
  /// <summary>
  /// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
  /// the same compatibility standards as public APIs. It may be changed or removed without notice in
@@ -116,4 +140,8 @@ IReadOnlyList<IColumn> IForeignKeyConstraint.Columns
  /// <inheritdoc />
  IReadOnlyList<IColumn> IForeignKeyConstraint.PrincipalColumns
  => PrincipalColumns;
+
+ /// <inheritdoc />
+ IUniqueConstraint IForeignKeyConstraint.PrincipalUniqueConstraint
+ => PrincipalUniqueConstraint;
 }