public static ModelBuilder ForNpgsqlHasEnum <TEnum>(
[NotNull] this ModelBuilder modelBuilder,
[CanBeNull] string schema = null,
[CanBeNull] string name = null,
[CanBeNull] INpgsqlNameTranslator nameTranslator = null)
where TEnum : struct, Enum
=> modelBuilder.HasPostgresEnum <TEnum>(schema, name, nameTranslator);
internal MappedCompositeHandler(INpgsqlNameTranslator nameTranslator, PostgresType pgType, NpgsqlConnection conn)
{
PostgresType = pgType;
_nameTranslator = nameTranslator;
_conn = conn;
_wrappedHandler = (UnmappedCompositeHandler) new UnmappedCompositeTypeHandlerFactory(_nameTranslator).Create(PostgresType, _conn);
}
private void ConvertToLowerCase(INpgsqlNameTranslator mapper, object entity)
{
switch (entity)
{
case IMutableEntityType table:
var relationalTable = table.Relational();
relationalTable.TableName = ConvertGeneralToLowerCase(mapper, relationalTable.TableName);
break;
case IMutableProperty property:
property.Relational().ColumnName = ConvertGeneralToLowerCase(mapper, property.Relational().ColumnName);
break;
case IMutableKey primaryKey:
primaryKey.Relational().Name = ConvertKeyToLowerCase(mapper, primaryKey.Relational().Name);
break;
case IMutableForeignKey foreignKey:
foreignKey.Relational().Name = ConvertKeyToLowerCase(mapper, foreignKey.Relational().Name);
break;
case IMutableIndex indexKey:
indexKey.Relational().Name = ConvertKeyToLowerCase(mapper, indexKey.Relational().Name);
break;
default:
throw new NotImplementedException("Unexpected type was provided to lower case converter");
}
}
internal MappedEnumHandler(PostgresType pgType, INpgsqlNameTranslator nameTranslator, NpgsqlConnection conn)
: base(pgType)
{
_nameTranslator = nameTranslator;
_conn = conn;
_wrappedHandler = (UnmappedEnumHandler) new UnmappedEnumTypeHandlerFactory(_nameTranslator).Create(PostgresType, _conn);
}
public INpgsqlTypeMapper MapEnum <TEnum>(string pgName = null, INpgsqlNameTranslator nameTranslator = null)
where TEnum : struct
{
if (!typeof(TEnum).GetTypeInfo().IsEnum)
{
throw new ArgumentException("An enum type must be provided");
}
if (pgName != null && pgName.Trim() == "")
{
throw new ArgumentException("pgName can't be empty", nameof(pgName));
}
if (nameTranslator == null)
{
nameTranslator = DefaultNameTranslator;
}
if (pgName == null)
{
pgName = GetPgName <TEnum>(nameTranslator);
}
return(AddMapping(new NpgsqlTypeMappingBuilder
{
PgTypeName = pgName,
ClrTypes = new[] { typeof(TEnum) },
TypeHandlerFactory = new EnumTypeHandlerFactory <TEnum>(nameTranslator)
}.Build()));
}
private void ConvertToSnake(INpgsqlNameTranslator mapper, object entity)
{
switch (entity)
{
case IMutableEntityType table:
var relationalTable = table.Relational();
relationalTable.TableName = ConvertGeneralToSnake(mapper, relationalTable.TableName);
if (relationalTable.TableName.StartsWith("asp_net_"))
{
relationalTable.TableName = relationalTable.TableName.Replace("asp_net_", string.Empty);
relationalTable.Schema = "identity";
}
break;
case IMutableProperty property:
property.Relational().ColumnName = ConvertGeneralToSnake(mapper, property.Relational().ColumnName);
break;
case IMutableKey primaryKey:
primaryKey.Relational().Name = ConvertKeyToSnake(mapper, primaryKey.Relational().Name);
break;
case IMutableForeignKey foreignKey:
foreignKey.Relational().Name = ConvertKeyToSnake(mapper, foreignKey.Relational().Name);
break;
case IMutableIndex indexKey:
indexKey.Relational().Name = ConvertKeyToSnake(mapper, indexKey.Relational().Name);
break;
default:
throw new NotImplementedException("Unexpected type was provided to snake case converter");
}
}
private void ConvertToSnake(INpgsqlNameTranslator mapper, object entity)
{
switch (entity)
{
case IMutableEntityType table:
table.SetTableName(ConvertGeneralToSnake(mapper, table.GetTableName() !));
break;
case IMutableProperty property:
var columnName = property.GetColumnName(
StoreObjectIdentifier.Table(property.DeclaringEntityType.GetTableName() !));
property.SetColumnName(ConvertGeneralToSnake(mapper, columnName !));
break;
case IMutableKey primaryKey:
primaryKey.SetName(ConvertKeyToSnake(mapper, primaryKey.GetName() !));
break;
case IMutableForeignKey foreignKey:
foreignKey.SetConstraintName(ConvertKeyToSnake(mapper, foreignKey.GetConstraintName() !));
break;
case IMutableIndex indexKey:
indexKey.SetDatabaseName(ConvertKeyToSnake(mapper, indexKey.GetDatabaseName()));
break;
default:
throw new NotImplementedException("Unexpected type was provided to snake case converter");
}
}
private void ConvertToSnake(INpgsqlNameTranslator mapper, object entity)
{
switch (entity)
{
case IMutableEntityType table:
table.SetTableName(ConvertGeneralToSnake(mapper, table.GetTableName()));
if (table.GetTableName().StartsWith("asp_net_"))
{
table.SetTableName(ConvertGeneralToSnake(mapper, table.GetTableName().Replace("asp_net_", string.Empty)));
table.SetSchema("identity");
}
break;
case IMutableProperty property:
property.SetColumnName(ConvertGeneralToSnake(mapper, property.GetColumnName()));
break;
case IMutableKey primaryKey:
primaryKey.SetName(ConvertGeneralToSnake(mapper, primaryKey.GetName()));
break;
case IMutableForeignKey foreignKey:
foreignKey.SetConstraintName(ConvertGeneralToSnake(mapper, foreignKey.GetConstraintName()));
break;
case IMutableIndex indexKey:
indexKey.SetName(ConvertGeneralToSnake(mapper, indexKey.GetName()));
break;
default:
throw new NotImplementedException("Unexpected type was provided to snake case converter");
}
}
private void ConvertToSnake(INpgsqlNameTranslator mapper, object entity)
{
switch (entity)
{
case IMutableEntityType table:
table.SetTableName(ConvertGeneralToSnake(mapper, table.GetTableName()));
break;
case IMutableProperty property:
#pragma warning disable 618
// https://github.com/dotnet/efcore/issues/23301#issuecomment-727003676
// If you have a model for 3.1 and you haven't changed it to use TPT, then you should be okay calling the implementation above in 5.0.
property.SetColumnName(ConvertGeneralToSnake(mapper, property.GetColumnName()));
#pragma warning restore 618
break;
case IMutableKey primaryKey:
primaryKey.SetName(ConvertKeyToSnake(mapper, primaryKey.GetName()));
break;
case IMutableForeignKey foreignKey:
foreignKey.SetConstraintName(ConvertKeyToSnake(mapper, foreignKey.GetConstraintName()));
break;
case IMutableIndex indexKey:
indexKey.SetDatabaseName(ConvertKeyToSnake(mapper, indexKey.GetDatabaseName()));
break;
default:
throw new NotImplementedException("Unexpected type was provided to snake case converter");
}
}
static string GetPgName <T>(INpgsqlNameTranslator nameTranslator)
{
var attr = typeof(T).GetTypeInfo().GetCustomAttribute <PgNameAttribute>();
return(attr == null
? nameTranslator.TranslateTypeName(typeof(T).Name)
: attr.PgName);
}
internal EnumHandler(IBackendType backendType, INpgsqlNameTranslator nameTranslator)
: base(backendType)
{
Contract.Requires(typeof(TEnum).GetTypeInfo().IsEnum, "EnumHandler instantiated for non-enum type");
_enumToLabel = new Dictionary <TEnum, string>();
_labelToEnum = new Dictionary <string, TEnum>();
GenerateMappings(nameTranslator, _enumToLabel, _labelToEnum);
}
internal EnumHandler(PostgresType postgresType, INpgsqlNameTranslator nameTranslator)
: base(postgresType)
{
Debug.Assert(typeof(TEnum).GetTypeInfo().IsEnum, "EnumHandler instantiated for non-enum type");
_enumToLabel = new Dictionary <TEnum, string>();
_labelToEnum = new Dictionary <string, TEnum>();
GenerateMappings(nameTranslator, _enumToLabel, _labelToEnum);
}
protected TypeMapperBase([NotNull] INpgsqlNameTranslator defaultNameTranslator)
{
if (defaultNameTranslator == null)
{
throw new ArgumentNullException(nameof(defaultNameTranslator));
}
DefaultNameTranslator = defaultNameTranslator;
}
protected NpgsqlEnumTypeMapping(
RelationalTypeMappingParameters parameters,
[NotNull] ISqlGenerationHelper sqlGenerationHelper,
[NotNull] INpgsqlNameTranslator nameTranslator)
: base(parameters)
{
_nameTranslator = nameTranslator;
_sqlGenerationHelper = sqlGenerationHelper;
_members = CreateValueMapping(parameters.CoreParameters.ClrType, nameTranslator);
}
internal UnmappedCompositeHandler(INpgsqlNameTranslator nameTranslator, ConnectorTypeMapper typeMapper)
{
_nameTranslator = nameTranslator;
// After construction the composite handler will have a reference to its PostgresCompositeType,
// which contains information about the fields. But the actual binding of their type OIDs
// to their type handlers is done only very late upon first usage of the handler,
// allowing composite types to be activated in any order regardless of dependencies.
_typeMapper = typeMapper;
}
public DataContext(
DbContextOptions <DataContext> options,
IContainer services,
INpgsqlNameTranslator nameTranslator,
string customConnection = "")
: base(options)
{
_services = services;
_nameTranslator = nameTranslator;
_customConnection = customConnection;
}
public NpgSqlDataContext(string connectionString, INpgsqlNameTranslator translator = null)
{
if (translator == null)
{
translator = new CaseSensitiveTranslator();
}
Translator = translator;
_connection = new NpgsqlConnection(connectionString);
_connection.Open();
}
internal CompositeHandler(PostgresType postgresType, INpgsqlNameTranslator nameTranslator, List <RawCompositeField> rawFields, TypeHandlerRegistry registry)
: base(postgresType)
{
_nameTranslator = nameTranslator;
// At this point the composite handler nows about the fields, but hasn't yet resolved the
// type OIDs to their type handlers. This is done only very late upon first usage of the handler,
// allowing composite types to be registered and activated in any order regardless of dependencies.
_rawFields = rawFields;
_registry = registry;
}
internal static void MapEnumGlobally <TEnum>([CanBeNull] string pgName, [CanBeNull] INpgsqlNameTranslator nameTranslator) where TEnum : struct
{
if (nameTranslator == null)
{
nameTranslator = DefaultNameTranslator;
}
if (pgName == null)
{
pgName = GetPgName <TEnum>(nameTranslator);
}
_globalMappingChangeCounter++;
_globalEnumMappings[pgName] = new EnumHandler <TEnum> .Factory(nameTranslator);
}
internal EnumTypeHandlerFactory(INpgsqlNameTranslator nameTranslator)
{
foreach (var field in typeof(TEnum).GetFields(BindingFlags.Static | BindingFlags.Public))
{
var attribute = (PgNameAttribute)field.GetCustomAttributes(typeof(PgNameAttribute), false).FirstOrDefault();
var enumName = attribute == null
? nameTranslator.TranslateMemberName(field.Name)
: attribute.PgName;
var enumValue = (Enum)field.GetValue(null);
_enumToLabel[(TEnum)(object)enumValue] = enumName;
_labelToEnum[enumName] = (TEnum)(object)enumValue;
}
}
static void GenerateMappings(INpgsqlNameTranslator nameTranslator, Dictionary <TEnum, string> enumToLabel, Dictionary <string, TEnum> labelToEnum)
{
foreach (var field in typeof(TEnum).GetFields(BindingFlags.Static | BindingFlags.Public))
{
var attribute = (PgNameAttribute)field.GetCustomAttributes(typeof(PgNameAttribute), false).FirstOrDefault();
var enumName = attribute == null
? nameTranslator.TranslateMemberName(field.Name)
: attribute.PgName;
var enumValue = (Enum)field.GetValue(null);
enumToLabel[(TEnum)(object)enumValue] = enumName;
labelToEnum[enumName] = (TEnum)(object)enumValue;
}
}
internal static void MapCompositeGlobally <T>([CanBeNull] string pgName, [CanBeNull] INpgsqlNameTranslator nameTranslator) where T : new()
{
if (nameTranslator == null)
{
nameTranslator = DefaultNameTranslator;
}
if (pgName == null)
{
pgName = GetPgName <T>(nameTranslator);
}
_globalMappingChangeCounter++;
_globalCompositeMappings[pgName] = new CompositeHandler <T> .Factory(nameTranslator);
}
internal static void UnmapCompositeGlobally <T>([CanBeNull] string pgName, [CanBeNull] INpgsqlNameTranslator nameTranslator) where T : new()
{
if (nameTranslator == null)
{
nameTranslator = DefaultNameTranslator;
}
if (pgName == null)
{
pgName = GetPgName <T>(nameTranslator);
}
_globalMappingChangeCounter++;
ICompositeHandlerFactory _;
_globalCompositeMappings.TryRemove(pgName, out _);
}
internal static void UnmapCompositeGlobally <T>([CanBeNull] string pgName, [CanBeNull] INpgsqlNameTranslator nameTranslator) where T : new()
{
if (nameTranslator == null)
{
nameTranslator = DefaultNameTranslator;
}
if (pgName == null)
{
pgName = GetPgName <T>(nameTranslator);
}
_globalMappingChangeCounter++;
#pragma warning disable 168
_globalCompositeMappings.TryRemove(pgName, out var _);
#pragma warning restore 168
}
internal static void UnmapEnumGlobally <TEnum>([CanBeNull] string pgName, [CanBeNull] INpgsqlNameTranslator nameTranslator) where TEnum : struct
{
if (nameTranslator == null)
{
nameTranslator = DefaultNameTranslator;
}
if (pgName == null)
{
pgName = GetPgName <TEnum>(nameTranslator);
}
_globalMappingChangeCounter++;
IEnumHandlerFactory _;
_globalEnumMappings.TryRemove(pgName, out _);
}
internal void MapComposite <T>([CanBeNull] string pgName, [CanBeNull] INpgsqlNameTranslator nameTranslator) where T : new()
{
if (nameTranslator == null)
{
nameTranslator = DefaultNameTranslator;
}
if (pgName == null)
{
pgName = GetPgName <T>(nameTranslator);
}
// TODO: Check if already mapped dude
var compositeType = GetCompositeType(pgName);
compositeType.Activate(this, new CompositeHandler <T>(compositeType, nameTranslator, compositeType.RawFields, this));
}
public static ModelBuilder HasPostgresEnum <TEnum>(
[NotNull] this ModelBuilder modelBuilder,
[CanBeNull] string schema = null,
[CanBeNull] string name = null,
[CanBeNull] INpgsqlNameTranslator nameTranslator = null)
where TEnum : struct, Enum
{
if (nameTranslator == null)
{
nameTranslator = NpgsqlConnection.GlobalTypeMapper.DefaultNameTranslator;
}
return(modelBuilder.HasPostgresEnum(
schema,
name ?? GetTypePgName <TEnum>(nameTranslator),
GetMemberPgNames <TEnum>(nameTranslator)));
}
private static void ConvertToSnake(INpgsqlNameTranslator mapper, object entity)
{
switch (entity)
{
case IMutableEntityType table:
//var relationalTable = table.Relational();
var tableName = ConvertGeneralToSnake(mapper, table.GetTableName()).Replace("__", "_");
table.SetTableName(tableName);
break;
case IMutableProperty property:
//property.Relational().ColumnName = ConvertGeneralToSnake(mapper, property.Relational().ColumnName);
var currentName = property.GetColumnName();
if (currentName.IndexOf("_") == -1)
{
var propName = ConvertGeneralToSnake(mapper, property.Name);
property.SetColumnName(propName);
}
break;
case IMutableKey primaryKey:
//primaryKey.Relational().Name = ConvertKeyToSnake(mapper, primaryKey.Relational().Name);
//var keyName = ConvertGeneralToSnake(mapper, primaryKey.);
primaryKey.SetName(ConvertKeyToSnake(mapper, primaryKey.GetName()));
break;
case IMutableForeignKey foreignKey:
//foreignKey.Relational().Name = ConvertKeyToSnake(mapper, foreignKey.Relational().Name);
foreignKey.SetConstraintName(ConvertKeyToSnake(mapper, foreignKey.GetConstraintName()));
break;
case IMutableIndex indexKey:
//indexKey.Relational().Name = ConvertKeyToSnake(mapper, indexKey.Relational().Name);
indexKey.SetName(ConvertKeyToSnake(mapper, indexKey.GetName()));
break;
default:
throw new NotImplementedException("Unexpected type was provided to snake case converter");
}
}
public bool UnmapComposite <T>(string pgName = null, INpgsqlNameTranslator nameTranslator = null)
where T : new()
{
if (pgName != null && pgName.Trim() == "")
{
throw new ArgumentException("pgName can't be empty", nameof(pgName));
}
if (nameTranslator == null)
{
nameTranslator = DefaultNameTranslator;
}
if (pgName == null)
{
pgName = GetPgName <T>(nameTranslator);
}
return(RemoveMapping(pgName));
}
public NpgsqlEnumTypeMapping(
[NotNull] string storeType,
[CanBeNull] string storeTypeSchema,
[NotNull] Type enumType,
[NotNull] ISqlGenerationHelper sqlGenerationHelper,
[CanBeNull] INpgsqlNameTranslator nameTranslator = null)
: base(sqlGenerationHelper.DelimitIdentifier(storeType, storeTypeSchema), enumType)
{
if (!enumType.IsEnum || !enumType.IsValueType)
{
throw new ArgumentException($"Enum type mappings require a CLR enum. {enumType.FullName} is not an enum.");
}
nameTranslator ??= NpgsqlConnection.GlobalTypeMapper.DefaultNameTranslator;
_nameTranslator = nameTranslator;
_sqlGenerationHelper = sqlGenerationHelper;
_members = CreateValueMapping(enumType, nameTranslator);
}
