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