public static Dictionary <string, object> GetStorageParameters([NotNull] this IReadOnlyEntityType entityType)
=> entityType.GetAnnotations()
.Where(a => a.Name.StartsWith(NpgsqlAnnotationNames.StorageParameterPrefix))
.ToDictionary(
a => a.Name.Substring(NpgsqlAnnotationNames.StorageParameterPrefix.Length),
a => a.Value
);
public static Dictionary <string, object?> GetStorageParameters(this IReadOnlyEntityType entityType)
=> entityType.GetAnnotations()
.Where(a => a.Name.StartsWith(NpgsqlAnnotationNames.StorageParameterPrefix, StringComparison.Ordinal))
.ToDictionary(
a => a.Name.Substring(NpgsqlAnnotationNames.StorageParameterPrefix.Length),
a => a.Value
);
/// <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 ParameterBinding Bind(
IReadOnlyEntityType entityType,
Type parameterType,
string parameterName)
=> new ContextParameterBinding(
parameterType,
entityType.GetServiceProperties().Cast <IPropertyBase>().Where(p => p.ClrType == parameterType).ToArray());
public virtual ParameterBinding Bind(
IReadOnlyEntityType entityType,
Type parameterType,
string parameterName)
=> new ContextParameterBinding(
parameterType,
(IPropertyBase?)entityType.GetServiceProperties().FirstOrDefault(p => p.ClrType == parameterType));
private bool TryBindConstructor(
IReadOnlyEntityType entityType,
ConstructorInfo constructor,
Func<IParameterBindingFactory?, IReadOnlyEntityType, Type, string, ParameterBinding?> bind,
[CA.NotNullWhen(true)] out InstantiationBinding? binding,
[CA.NotNullWhen(false)] out IEnumerable<ParameterInfo>? unboundParameters)
{
IEnumerable<(ParameterInfo Parameter, ParameterBinding? Binding)> bindings
= constructor.GetParameters().Select(
p => (p, string.IsNullOrEmpty(p.Name)
? null
: _propertyFactory.FindParameter((IEntityType)entityType, p.ParameterType, p.Name)
?? bind(_factories.FindFactory(p.ParameterType, p.Name), entityType, p.ParameterType, p.Name)))
.ToList();
if (bindings.Any(b => b.Binding == null))
{
unboundParameters = bindings.Where(b => b.Binding == null).Select(b => b.Parameter);
binding = null;
return false;
}
unboundParameters = null;
binding = new ConstructorBinding(constructor, bindings.Select(b => b.Binding).ToList()!);
return true;
}
public static bool UseEagerSnapshots([NotNull] this IReadOnlyEntityType entityType)
{
var changeTrackingStrategy = entityType.GetChangeTrackingStrategy();
return(changeTrackingStrategy == ChangeTrackingStrategy.Snapshot ||
changeTrackingStrategy == ChangeTrackingStrategy.ChangedNotifications);
}
public static bool IsStrictlyDerivedFrom([NotNull] this IReadOnlyEntityType entityType, [NotNull] IReadOnlyEntityType baseType)
{
Check.NotNull(entityType, nameof(entityType));
Check.NotNull(baseType, nameof(baseType));
return(entityType == baseType ? false : baseType.IsAssignableFrom(entityType));
}
public static IReadOnlyEntityType ResolveEntityTypeInHierarchy(
this IReadOnlyForeignKey foreignKey, IReadOnlyEntityType entityType)
{
if (!foreignKey.DeclaringEntityType.IsAssignableFrom(entityType) &&
!foreignKey.PrincipalEntityType.IsAssignableFrom(entityType))
{
throw new InvalidOperationException(
CoreStrings.EntityTypeNotInRelationship(
entityType.DisplayName(),
foreignKey.DeclaringEntityType.DisplayName(),
foreignKey.PrincipalEntityType.DisplayName()));
}
if (foreignKey.DeclaringEntityType.IsAssignableFrom(foreignKey.PrincipalEntityType) ||
foreignKey.PrincipalEntityType.IsAssignableFrom(foreignKey.DeclaringEntityType))
{
throw new InvalidOperationException(
CoreStrings.IntraHierarchicalAmbiguousTargetEntityType(
entityType.DisplayName(), foreignKey.Properties.Format(),
foreignKey.PrincipalEntityType.DisplayName(),
foreignKey.DeclaringEntityType.DisplayName()));
}
return(foreignKey.DeclaringEntityType.IsAssignableFrom(entityType)
? foreignKey.DeclaringEntityType
: foreignKey.PrincipalEntityType);
}
/// <summary>
/// Returns the default table name that would be used for this entity type.
/// </summary>
/// <param name="entityType">The entity type to get the table name for.</param>
/// <param name="truncate">A value indicating whether the name should be truncated to the max identifier length.</param>
/// <returns>The default name of the table to which the entity type would be mapped.</returns>
public static string?GetDefaultTableName(this IReadOnlyEntityType entityType, bool truncate = true)
{
var ownership = entityType.FindOwnership();
if (ownership != null &&
ownership.IsUnique)
{
return(ownership.PrincipalEntityType.GetTableName());
}
var name = entityType.ShortName();
if (entityType.HasSharedClrType &&
ownership != null
#pragma warning disable EF1001 // Internal EF Core API usage.
&& entityType.Name == ownership.PrincipalEntityType.GetOwnedName(name, ownership.PrincipalToDependent !.Name))
#pragma warning restore EF1001 // Internal EF Core API usage.
{
var ownerTypeTable = ownership.PrincipalEntityType.GetTableName();
name = ownerTypeTable != null
? $"{ownerTypeTable}_{ownership.PrincipalToDependent.Name}"
: $"{ownership.PrincipalToDependent.Name}_{name}";
}
return(truncate
? Uniquifier.Truncate(name, entityType.Model.GetMaxIdentifierLength())
: name);
}
/// <summary>
/// Creates an id for the store object that the given entity type is mapped to.
/// </summary>
/// <param name="entityType"> The entity type. </param>
/// <param name="type"> The store object type. </param>
/// <returns> The store object id. </returns>
public static StoreObjectIdentifier?Create(IReadOnlyEntityType entityType, StoreObjectType type)
{
Check.NotNull(entityType, nameof(entityType));
switch (type)
{
case StoreObjectType.Table:
var tableName = entityType.GetTableName();
return(tableName == null ? null : Table(tableName, entityType.GetSchema()));
case StoreObjectType.View:
var viewName = entityType.GetViewName();
return(viewName == null ? null : View(viewName, entityType.GetViewSchema()));
case StoreObjectType.SqlQuery:
var query = entityType.GetSqlQuery();
return(query == null ? null : SqlQuery(entityType));
case StoreObjectType.Function:
var functionName = entityType.GetFunctionName();
return(functionName == null ? null : DbFunction(functionName));
default:
return(null);
}
}
/// <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 static IReadOnlyTrigger?FindDeclaredTrigger(IReadOnlyEntityType entityType, string name)
{
var triggers = (SortedDictionary <string, ITrigger>?)entityType[RelationalAnnotationNames.Triggers];
return(triggers is not null && triggers.TryGetValue(name, out var trigger)
? trigger
: null);
}
/// <summary>
/// Constructs the event payload.
/// </summary>
/// <param name="eventDefinition"> The event definition. </param>
/// <param name="messageGenerator"> A delegate that generates a log message for this event. </param>
/// <param name="entityType"> The entityType. </param>
public EntityTypeEventData(
EventDefinitionBase eventDefinition,
Func <EventDefinitionBase, EventData, string> messageGenerator,
IReadOnlyEntityType entityType)
: base(eventDefinition, messageGenerator)
{
EntityType = entityType;
}
/// <summary>
/// Finds an <see cref="IReadOnlyCheckConstraint" /> with the given name.
/// </summary>
/// <param name="entityType">The entity type to find the check constraint for.</param>
/// <param name="name">The check constraint name.</param>
/// <returns>
/// The <see cref="IReadOnlyCheckConstraint" /> or <see langword="null" /> if no check constraint with the
/// given name in the given entity type was found.
/// </returns>
public static IReadOnlyCheckConstraint?FindCheckConstraint(
this IReadOnlyEntityType entityType,
string name)
{
Check.NotEmpty(name, nameof(name));
return(CheckConstraint.FindCheckConstraint(entityType, name));
}
/// <summary>
/// Creates a <see cref="ParameterBinding" /> for the given type and name on the given entity type.
/// </summary>
/// <param name="entityType">The entity type.</param>
/// <param name="parameterType">The parameter type.</param>
/// <param name="parameterName">The parameter name.</param>
/// <returns>The binding.</returns>
public virtual ParameterBinding Bind(
IReadOnlyEntityType entityType,
Type parameterType,
string parameterName)
=> new DependencyInjectionParameterBinding(
_serviceType,
_serviceType,
entityType.GetServiceProperties().Cast <IPropertyBase>().Where(p => p.ClrType == _serviceType).ToArray());
/// <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 static IEnumerable <IReadOnlyCheckConstraint> GetDeclaredCheckConstraints(IReadOnlyEntityType entityType)
{
if (entityType is RuntimeEntityType)
{
throw new InvalidOperationException(CoreStrings.RuntimeModelMissingData);
}
return(GetConstraintsDictionary(entityType)?.Values ?? Enumerable.Empty <ICheckConstraint>());
}
/// <summary>
/// Gets the foreign keys for the given entity type that point to other entity types
/// sharing the same table-like store object.
/// </summary>
/// <param name="entityType">The entity type.</param>
/// <param name="storeObject">The identifier of the store object.</param>
public static IEnumerable <IReadOnlyForeignKey> FindRowInternalForeignKeys(
this IReadOnlyEntityType entityType,
StoreObjectIdentifier storeObject)
{
var primaryKey = entityType.FindPrimaryKey();
if (primaryKey == null)
{
yield break;
}
foreach (var foreignKey in entityType.GetForeignKeys())
{
var principalEntityType = foreignKey.PrincipalEntityType;
if (!foreignKey.PrincipalKey.IsPrimaryKey() ||
principalEntityType == foreignKey.DeclaringEntityType ||
!foreignKey.IsUnique
#pragma warning disable EF1001 // Internal EF Core API usage.
|| !PropertyListComparer.Instance.Equals(foreignKey.Properties, primaryKey.Properties))
#pragma warning restore EF1001 // Internal EF Core API usage.
{
continue;
}
switch (storeObject.StoreObjectType)
{
case StoreObjectType.Table:
if (storeObject.Name == principalEntityType.GetTableName() &&
storeObject.Schema == principalEntityType.GetSchema())
{
yield return(foreignKey);
}
break;
case StoreObjectType.View:
if (storeObject.Name == principalEntityType.GetViewName() &&
storeObject.Schema == principalEntityType.GetViewSchema())
{
yield return(foreignKey);
}
break;
case StoreObjectType.Function:
if (storeObject.Name == principalEntityType.GetFunctionName())
{
yield return(foreignKey);
}
break;
default:
throw new NotSupportedException(storeObject.StoreObjectType.ToString());
}
}
}
public static IReadOnlyEntityType?GetClosestCommonParent([NotNull] this IReadOnlyEntityType entityType1, [NotNull] IReadOnlyEntityType entityType2)
{
Check.NotNull(entityType1, nameof(entityType1));
Check.NotNull(entityType2, nameof(entityType2));
return(entityType1
.GetAllBaseTypesInclusiveAscending()
.FirstOrDefault(i => entityType2.GetAllBaseTypesInclusiveAscending().Any(j => j == i)));
}
/// <summary>
/// Returns the default view name that would be used for this entity type.
/// </summary>
/// <param name="entityType">The entity type to get the table name for.</param>
/// <returns>The default name of the table to which the entity type would be mapped.</returns>
public static string?GetDefaultViewName(this IReadOnlyEntityType entityType)
{
var ownership = entityType.FindOwnership();
return(ownership != null &&
ownership.IsUnique
? ownership.PrincipalEntityType.GetViewName()
: null);
}
private static void CloneIndexes(IReadOnlyEntityType sourceEntityType, IMutableEntityType targetEntityType)
{
foreach (var index in sourceEntityType.GetDeclaredIndexes())
{
var clonedIndex = targetEntityType.AddIndex(
index.Properties.Select(p => targetEntityType.FindProperty(p.Name)).ToList());
clonedIndex.IsUnique = index.IsUnique;
index.GetAnnotations().ForEach(annotation => clonedIndex[annotation.Name] = annotation.Value);
}
}
/// <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 static IReadOnlyCheckConstraint?FindDeclaredCheckConstraint(IReadOnlyEntityType entityType, string name)
{
var dataDictionary = GetConstraintsDictionary(entityType);
return(dataDictionary == null
? null
: dataDictionary.TryGetValue(name, out var checkConstraint)
? checkConstraint
: null);
}
public static IReadOnlyEntityType?LeastDerivedType([NotNull] this IReadOnlyEntityType entityType, [NotNull] IReadOnlyEntityType otherEntityType)
{
Check.NotNull(entityType, nameof(entityType));
Check.NotNull(otherEntityType, nameof(otherEntityType));
return(entityType.IsAssignableFrom(otherEntityType)
? entityType
: otherEntityType.IsAssignableFrom(entityType)
? otherEntityType
: null);
}
public static IReadOnlyNavigation?FindDefiningNavigation([NotNull] this IReadOnlyEntityType entityType)
{
if (!entityType.HasDefiningNavigation())
{
return(null);
}
var definingNavigation = entityType.DefiningEntityType !.FindNavigation(entityType.DefiningNavigationName !);
return(definingNavigation?.TargetEntityType == entityType ? definingNavigation : null);
}
/// <summary>
/// Creates a <see cref="ParameterBinding" /> for the given type and name on the given entity type.
/// </summary>
/// <param name="entityType"> The entity type. </param>
/// <param name="parameterType"> The parameter type. </param>
/// <param name="parameterName"> The parameter name. </param>
/// <returns> The binding. </returns>
public override ParameterBinding Bind(
IReadOnlyEntityType entityType,
Type parameterType,
string parameterName)
{
Check.NotNull(entityType, nameof(entityType));
Check.NotNull(parameterType, nameof(parameterType));
Check.NotEmpty(parameterName, nameof(parameterName));
return(Bind((IEntityType)entityType, parameterType));
}
private void ProcessElement(IReadOnlyEntityType entityType, string version)
{
ProcessElement((IReadOnlyAnnotatable)entityType, version);
if ((version.StartsWith("2.0", StringComparison.Ordinal) ||
version.StartsWith("2.1", StringComparison.Ordinal)) &&
entityType is IMutableEntityType mutableEntityType &&
!entityType.IsOwned())
{
UpdateOwnedTypes(mutableEntityType);
}
}
/// <summary>
/// Returns the default database schema that would be used for this entity view.
/// </summary>
/// <param name="entityType">The entity type to get the view schema for.</param>
/// <returns>The default database schema to which the entity type would be mapped.</returns>
public static string?GetDefaultViewSchema(this IReadOnlyEntityType entityType)
{
var ownership = entityType.FindOwnership();
if (ownership != null &&
ownership.IsUnique)
{
return(ownership.PrincipalEntityType.GetViewSchema());
}
return(GetViewName(entityType) != null?entityType.Model.GetDefaultSchema() : null);
}
public static string?GetSchemaQualifiedTableName([NotNull] this IReadOnlyEntityType entityType)
{
var tableName = entityType.GetTableName();
if (tableName == null)
{
return(null);
}
var schema = entityType.GetSchema();
return((string.IsNullOrEmpty(schema) ? "" : schema + ".") + tableName);
}
/// <summary>
/// Returns the database schema that contains the mapped view.
/// </summary>
/// <param name="entityType">The entity type to get the view schema for.</param>
/// <returns>The database schema that contains the mapped view.</returns>
public static string?GetViewSchema(this IReadOnlyEntityType entityType)
{
var schemaAnnotation = entityType.FindAnnotation(RelationalAnnotationNames.ViewSchema);
if (schemaAnnotation != null)
{
return((string?)schemaAnnotation.Value ?? GetDefaultViewSchema(entityType));
}
return(entityType.BaseType != null
? entityType.GetRootType().GetViewSchema()
: GetDefaultViewSchema(entityType));
}
/// <summary>
/// Returns the name of the view to which the entity type is mapped prepended by the schema
/// or <see langword="null" /> if not mapped to a view.
/// </summary>
/// <param name="entityType">The entity type to get the table name for.</param>
/// <returns>The name of the table to which the entity type is mapped prepended by the schema.</returns>
public static string?GetSchemaQualifiedViewName(this IReadOnlyEntityType entityType)
{
var viewName = entityType.GetViewName();
if (viewName == null)
{
return(null);
}
var schema = entityType.GetViewSchema();
return((string.IsNullOrEmpty(schema) ? "" : schema + ".") + viewName);
}
private static void CloneProperties(IReadOnlyEntityType sourceEntityType, IMutableEntityType targetEntityType)
{
foreach (var property in sourceEntityType.GetDeclaredProperties())
{
var clonedProperty = targetEntityType.AddProperty(property.Name, property.ClrType);
clonedProperty.IsNullable = property.IsNullable;
clonedProperty.IsConcurrencyToken = property.IsConcurrencyToken;
clonedProperty.ValueGenerated = property.ValueGenerated;
clonedProperty.SetBeforeSaveBehavior(property.GetBeforeSaveBehavior());
clonedProperty.SetAfterSaveBehavior(property.GetAfterSaveBehavior());
property.GetAnnotations().ForEach(annotation => clonedProperty[annotation.Name] = annotation.Value);
}
}
public static MemberInfo GetNavigationMemberInfo(
[NotNull] this IReadOnlyEntityType entityType,
[NotNull] string navigationName)
{
var memberInfo = entityType.ClrType.GetMembersInHierarchy(navigationName).FirstOrDefault();
if (memberInfo == null)
{
throw new InvalidOperationException(
CoreStrings.NoClrNavigation(navigationName, entityType.DisplayName()));
}
return(memberInfo);
}
