/// <summary> /// Determines if this column is a narrower data type than another column. /// Used to determine if altering the supplied column definition to this definition will result in data loss. /// </summary> /// <param name="column"> The column to compare to. </param> /// <param name="providerManifest"> Details of the database provider being used. </param> /// <returns> True if this column is of a narrower data type. </returns> public bool IsNarrowerThan(ColumnModel column, DbProviderManifest providerManifest) { Check.NotNull <ColumnModel>(column, nameof(column)); Check.NotNull <DbProviderManifest>(providerManifest, nameof(providerManifest)); TypeUsage storeType1 = providerManifest.GetStoreType(this.TypeUsage); TypeUsage storeType2 = providerManifest.GetStoreType(column.TypeUsage); if (ColumnModel._typeSize[this.Type] >= ColumnModel._typeSize[column.Type]) { bool?isUnicode1 = this.IsUnicode; if ((isUnicode1.HasValue ? (isUnicode1.GetValueOrDefault() ? 1 : 0) : 1) == 0) { bool?isUnicode2 = column.IsUnicode; if ((isUnicode2.HasValue ? (isUnicode2.GetValueOrDefault() ? 1 : 0) : 1) != 0) { goto label_6; } } bool?isNullable1 = this.IsNullable; if ((isNullable1.HasValue ? (isNullable1.GetValueOrDefault() ? 1 : 0) : 1) == 0) { bool?isNullable2 = column.IsNullable; if ((isNullable2.HasValue ? (isNullable2.GetValueOrDefault() ? 1 : 0) : 1) != 0) { goto label_6; } } return(ColumnModel.IsNarrowerThan(storeType1, storeType2)); } label_6: return(true); }
internal void Configure( DbDatabaseMapping databaseMapping, MappingFragment fragment, EntityType entityType, DbProviderManifest providerManifest) { EdmProperty edmProperty = fragment.Table.Properties.SingleOrDefault <EdmProperty>((Func <EdmProperty, bool>)(c => string.Equals(c.Name, this.Discriminator, StringComparison.Ordinal))); if (edmProperty != null && ValueConditionConfiguration.GetMappingFragmentsWithColumnAsDefaultDiscriminator(databaseMapping, fragment.Table, edmProperty).Any <MappingFragment>()) { edmProperty.Name = fragment.Table.Properties.Select <EdmProperty, string>((Func <EdmProperty, string>)(p => p.Name)).Uniquify(edmProperty.Name); edmProperty = (EdmProperty)null; } if (edmProperty == null) { edmProperty = new EdmProperty(this.Discriminator, providerManifest.GetStoreType(DatabaseMappingGenerator.DiscriminatorTypeUsage)) { Nullable = false }; TablePrimitiveOperations.AddColumn(fragment.Table, edmProperty); } if (ValueConditionConfiguration.AnyBaseTypeToTableWithoutColumnCondition(databaseMapping, entityType, fragment.Table, edmProperty)) { edmProperty.Nullable = true; } System.Data.Entity.ModelConfiguration.Configuration.Properties.Primitive.PrimitivePropertyConfiguration configuration = edmProperty.GetConfiguration() as System.Data.Entity.ModelConfiguration.Configuration.Properties.Primitive.PrimitivePropertyConfiguration; if (this.Value != null) { this.ConfigureColumnType(providerManifest, configuration, edmProperty); fragment.AddDiscriminatorCondition(edmProperty, this.Value); } else { if (string.IsNullOrWhiteSpace(edmProperty.TypeName)) { TypeUsage storeType = providerManifest.GetStoreType(DatabaseMappingGenerator.DiscriminatorTypeUsage); edmProperty.PrimitiveType = (PrimitiveType)storeType.EdmType; edmProperty.MaxLength = new int?(128); edmProperty.Nullable = false; } this.GetOrCreateConfiguration <System.Data.Entity.ModelConfiguration.Configuration.Properties.Primitive.PrimitivePropertyConfiguration>().IsNullable = new bool?(true); fragment.AddNullabilityCondition(edmProperty, true); } if (this._configuration == null) { return; } string errorMessage; if (configuration != null && (configuration.OverridableConfigurationParts & OverridableConfigurationParts.OverridableInCSpace) != OverridableConfigurationParts.OverridableInCSpace && !configuration.IsCompatible(this._configuration, true, out errorMessage)) { throw Error.ConflictingColumnConfiguration((object)edmProperty, (object)fragment.Table, (object)errorMessage); } if (this._configuration.IsNullable.HasValue) { edmProperty.Nullable = this._configuration.IsNullable.Value; } this._configuration.Configure(edmProperty, fragment.Table, providerManifest, false, false); }
/// <summary> /// Determines if this column is a narrower data type than another column. /// Used to determine if altering the supplied column definition to this definition will result in data loss. /// </summary> /// <param name="column"> The column to compare to. </param> /// <param name="providerManifest"> Details of the database provider being used. </param> /// <returns> True if this column is of a narrower data type. </returns> public bool IsNarrowerThan(ColumnModel column, DbProviderManifest providerManifest) { Check.NotNull(column, "column"); Check.NotNull(providerManifest, "providerManifest"); var typeUsage = providerManifest.GetStoreType(TypeUsage); var otherTypeUsage = providerManifest.GetStoreType(column.TypeUsage); return((_typeSize[Type] < _typeSize[column.Type]) || !(IsUnicode ?? true) && (column.IsUnicode ?? true) || !(IsNullable ?? true) && (column.IsNullable ?? true) || IsNarrowerThan(typeUsage, otherTypeUsage)); }
private void ConfigureRowsAffectedParameter( ModificationFunctionMapping modificationStoredProcedureMapping, DbProviderManifest providerManifest) { DebugCheck.NotNull(modificationStoredProcedureMapping); DebugCheck.NotNull(providerManifest); if (!string.IsNullOrWhiteSpace(_rowsAffectedParameter)) { if (modificationStoredProcedureMapping.RowsAffectedParameter == null) { var rowsAffectedParameter = new FunctionParameter( "_RowsAffected_", providerManifest.GetStoreType( TypeUsage.CreateDefaultTypeUsage( PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32))), ParameterMode.Out); modificationStoredProcedureMapping.Function.AddParameter(rowsAffectedParameter); modificationStoredProcedureMapping.RowsAffectedParameter = rowsAffectedParameter; } modificationStoredProcedureMapping.RowsAffectedParameter.Name = _rowsAffectedParameter; _configuredParameters.Add(modificationStoredProcedureMapping.RowsAffectedParameter); } }
protected EdmProperty MapTableColumn( EdmProperty property, string columnName, bool isInstancePropertyOnDerivedType) { DebugCheck.NotNull(property); DebugCheck.NotEmpty(columnName); var underlyingTypeUsage = TypeUsage.Create(property.UnderlyingPrimitiveType, property.TypeUsage.Facets); var storeTypeUsage = _providerManifest.GetStoreType(underlyingTypeUsage); var tableColumnMetadata = new EdmProperty(columnName, storeTypeUsage) { Nullable = isInstancePropertyOnDerivedType || property.Nullable }; if (tableColumnMetadata.IsPrimaryKeyColumn) { tableColumnMetadata.Nullable = false; } var storeGeneratedPattern = property.GetStoreGeneratedPattern(); if (storeGeneratedPattern != null) { tableColumnMetadata.StoreGeneratedPattern = storeGeneratedPattern.Value; } MapPrimitivePropertyFacets(property, tableColumnMetadata, storeTypeUsage); return(tableColumnMetadata); }
private void ConfigureColumnType( DbProviderManifest providerManifest, Properties.Primitive.PrimitivePropertyConfiguration existingConfiguration, EdmProperty discriminatorColumn) { if (((existingConfiguration != null) && existingConfiguration.ColumnType != null) || ((_configuration != null) && (_configuration.ColumnType != null))) { return; } PrimitiveType primitiveType; Value.GetType().IsPrimitiveType(out primitiveType); var edmType = (PrimitiveType)providerManifest.GetStoreType( (primitiveType == PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)) ? DatabaseMappingGenerator.DiscriminatorTypeUsage : TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(primitiveType.PrimitiveTypeKind))).EdmType; if ((existingConfiguration != null) && !discriminatorColumn.TypeName.Equals(edmType.Name, StringComparison.OrdinalIgnoreCase)) { throw Error.ConflictingInferredColumnType( discriminatorColumn.Name, discriminatorColumn.TypeName, edmType.Name); } discriminatorColumn.PrimitiveType = edmType; }
private static TypeUsage GetStoreTypeUsage(this EdmMember edmMember, DbProviderManifest providerManifest) { TypeUsage storeType = null; var conceptualType = edmMember.TypeUsage; Debug.Assert(conceptualType != null, "EdmMember's TypeUsage is null"); if (conceptualType != null) { // if the EDM type is an enum, then we need to pass in the underlying type to the GetStoreType API. var enumType = conceptualType.EdmType as EnumType; storeType = (enumType != null) ? providerManifest.GetStoreType(TypeUsage.CreateDefaultTypeUsage(enumType.UnderlyingType)) : providerManifest.GetStoreType(conceptualType); } return(storeType); }
/// <summary> /// Generates SQL to specify the data type of a column. /// This method just generates the actual type, not the SQL to create the column. /// </summary> /// <param name="defaultValue"> The definition of the column. </param> /// <returns> SQL representing the data type. </returns> protected virtual string BuildColumnType(ColumnModel column) { Check.NotNull(column, "column"); if (column.IsTimestamp) { return("rowversion"); } var originalStoreTypeName = column.StoreType; if (string.IsNullOrWhiteSpace(originalStoreTypeName)) { var typeUsage = _providerManifest.GetStoreType(column.TypeUsage).EdmType; originalStoreTypeName = typeUsage.Name; } var storeTypeName = originalStoreTypeName; const string MaxSuffix = "(max)"; if (storeTypeName.EndsWith(MaxSuffix, StringComparison.Ordinal)) { storeTypeName = Quote(storeTypeName.Substring(0, storeTypeName.Length - MaxSuffix.Length)) + MaxSuffix; } else { storeTypeName = Quote(storeTypeName); } switch (originalStoreTypeName) { case "decimal": case "numeric": storeTypeName += "(" + (column.Precision ?? DefaultNumericPrecision) + ", " + (column.Scale ?? DefaultScale) + ")"; break; case "datetime2": case "datetimeoffset": case "time": storeTypeName += "(" + (column.Precision ?? DefaultTimePrecision) + ")"; break; case "binary": case "varbinary": case "nvarchar": case "varchar": case "char": case "nchar": storeTypeName += "(" + (column.MaxLength ?? DefaultMaxLength) + ")"; break; } return(storeTypeName); }
private string BuildPropertyType(PropertyModel propertyModel) { DebugCheck.NotNull(propertyModel); var originalStoreTypeName = propertyModel.StoreType; if (string.IsNullOrWhiteSpace(originalStoreTypeName)) { var typeUsage = _providerManifest.GetStoreType(propertyModel.TypeUsage).EdmType; originalStoreTypeName = typeUsage.Name; } var storeTypeName = originalStoreTypeName; const string MaxSuffix = "(max)"; if (storeTypeName.EndsWith(MaxSuffix, StringComparison.Ordinal)) { storeTypeName = Quote(storeTypeName.Substring(0, storeTypeName.Length - MaxSuffix.Length)) + MaxSuffix; } else { storeTypeName = Quote(storeTypeName); } switch (originalStoreTypeName) { case "decimal": case "numeric": storeTypeName += "(" + (propertyModel.Precision ?? DefaultNumericPrecision) + ", " + (propertyModel.Scale ?? DefaultScale) + ")"; break; case "datetime2": case "datetimeoffset": case "time": storeTypeName += "(" + (propertyModel.Precision ?? DefaultTimePrecision) + ")"; break; case "binary": case "varbinary": case "nvarchar": case "varchar": case "char": case "nchar": storeTypeName += "(" + (propertyModel.MaxLength ?? DefaultMaxLength) + ")"; break; } return(storeTypeName); }
private string BuildParamType(ParameterModel param) { string type = MySqlProviderServices.Instance.GetColumnType(_providerManifest.GetStoreType(param.TypeUsage)); StringBuilder sb = new StringBuilder(); sb.Append(type); if (new string[] { "char", "varchar" }.Contains(type.ToLower())) { if (param.MaxLength.HasValue) { sb.AppendFormat("({0}) ", param.MaxLength.Value); } } if (param.Precision.HasValue && param.Scale.HasValue) { sb.AppendFormat("( {0}, {1} ) ", param.Precision.Value, param.Scale.Value); } return(sb.ToString()); }
/// <summary> /// Builds a SQL property type fragment from the specified <see cref="ColumnModel"/>. /// </summary> public static string BuildPropertyType(DbProviderManifest providerManifest, PropertyModel column) { if (providerManifest == null || column == null) { return(string.Empty); } var originalStoreType = column.StoreType; if (string.IsNullOrWhiteSpace(originalStoreType)) { var typeUsage = providerManifest.GetStoreType(column.TypeUsage).EdmType; originalStoreType = typeUsage.Name; } var storeType = originalStoreType; const string maxSuffix = "(max)"; if (storeType.EndsWith(maxSuffix, StringComparison.Ordinal)) { storeType = storeType.Substring(0, storeType.Length - maxSuffix.Length) + maxSuffix; } switch (originalStoreType.ToUpperInvariant()) { case "DECIMAL": case "NUMERIC": storeType += "(" + (column.Precision ?? _defaultNumericPrecision) + ", " + (column.Scale ?? _defaultNumericScale) + ")"; break; case "DATETIME": case "TIME": storeType += "(" + (column.Precision ?? _defaultTimePrecision) + ")"; break; case "BLOB": case "VARCHAR2": case "VARCHAR": case "CHAR": case "NVARCHAR": case "NVARCHAR2": storeType += "(" + (column.MaxLength ?? _defaultStringMaxLength) + ")"; break; } return(storeType); }
private string ConstruirTipoPropriedade(ColumnModel propModeloPropriedade) { var lstrOriginalStoreTypeName = propModeloPropriedade.StoreType; if (string.IsNullOrWhiteSpace(lstrOriginalStoreTypeName)) { var ltypeUsage = pprovProviderManifest.GetStoreType(propModeloPropriedade.TypeUsage).EdmType; lstrOriginalStoreTypeName = ltypeUsage.Name; } var lstrStoreTypeName = lstrOriginalStoreTypeName; const string lstrSufixoMax = "(max)"; if (lstrStoreTypeName.EndsWith(lstrSufixoMax, StringComparison.Ordinal)) { lstrStoreTypeName = lstrStoreTypeName.Substring(0, lstrStoreTypeName.Length - lstrSufixoMax.Length) + lstrSufixoMax; } switch (lstrOriginalStoreTypeName.ToLowerInvariant()) { case "decimal": case "numeric": lstrStoreTypeName += "(" + (propModeloPropriedade.Precision ?? pintDefaultPrecisaoNumerica) + ", " + (propModeloPropriedade.Scale ?? pintDefaultEscala) + ")"; break; case "datetime": case "time": lstrStoreTypeName += "(" + (propModeloPropriedade.Precision ?? pbytDefaultPrecisaoTempo) + ")"; break; case "blob": case "varchar2": case "varchar": case "char": case "nvarchar": case "nvarchar2": lstrStoreTypeName += "(" + (propModeloPropriedade.MaxLength ?? pintDefaultStringMaxLength) + ")"; break; } return(lstrStoreTypeName); }
/// <summary> /// Builds a SQL property type fragment from the specified <see cref="ColumnModel" />. /// </summary> /// <param name="column"></param> /// <returns></returns> private string BuildPropertyType(ColumnModel column) { var originalStoreType = column.StoreType; if (string.IsNullOrWhiteSpace(originalStoreType)) { var typeUsage = _providerManifest.GetStoreType(column.TypeUsage).EdmType; originalStoreType = typeUsage.Name; } var storeType = originalStoreType; const string maxSuffix = "(max)"; if (storeType.EndsWith(maxSuffix, StringComparison.Ordinal)) { storeType = storeType.Substring(0, storeType.Length - maxSuffix.Length) + maxSuffix; } switch (originalStoreType.ToLowerInvariant()) { case "decimal": case "numeric": storeType += "(" + (column.Precision ?? DefaultNumericPrecision) + ", " + (column.Scale ?? DefaultNumericScale) + ")"; break; case "datetime": case "time": storeType += "(" + (column.Precision ?? DefaultTimePrecision) + ")"; break; case "blob": case "varchar2": case "varchar": case "char": case "nvarchar": case "nvarchar2": storeType += "(" + (column.MaxLength ?? DefaultStringMaxLength) + ")"; break; } return(storeType); }
private void ConfigureColumnType( DbProviderManifest providerManifest, System.Data.Entity.ModelConfiguration.Configuration.Properties.Primitive.PrimitivePropertyConfiguration existingConfiguration, EdmProperty discriminatorColumn) { if (existingConfiguration != null && existingConfiguration.ColumnType != null || this._configuration != null && this._configuration.ColumnType != null) { return; } PrimitiveType primitiveType; this.Value.GetType().IsPrimitiveType(out primitiveType); PrimitiveType edmType = (PrimitiveType)providerManifest.GetStoreType(primitiveType == PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String) ? DatabaseMappingGenerator.DiscriminatorTypeUsage : TypeUsage.Create((EdmType)PrimitiveType.GetEdmPrimitiveType(primitiveType.PrimitiveTypeKind))).EdmType; if (existingConfiguration != null && !discriminatorColumn.TypeName.Equals(edmType.Name, StringComparison.OrdinalIgnoreCase)) { throw Error.ConflictingInferredColumnType((object)discriminatorColumn.Name, (object)discriminatorColumn.TypeName, (object)edmType.Name); } discriminatorColumn.PrimitiveType = edmType; }
private void GenerateDiscriminators(DbDatabaseMapping databaseMapping) { DebugCheck.NotNull(databaseMapping); foreach (var entitySetMapping in databaseMapping.GetEntitySetMappings()) { if (entitySetMapping.EntityTypeMappings.Count() == 1) { continue; } var typeUsage = _providerManifest.GetStoreType(DiscriminatorTypeUsage); var discriminatorColumn = new EdmProperty(DiscriminatorColumnName, typeUsage) { Nullable = false }; entitySetMapping .EntityTypeMappings .First() .MappingFragments .Single() .Table .AddColumn(discriminatorColumn); foreach (var entityTypeMapping in entitySetMapping.EntityTypeMappings) { var entityTypeMappingFragment = entityTypeMapping.MappingFragments.Single(); entityTypeMappingFragment.SetDefaultDiscriminator(discriminatorColumn); entityTypeMappingFragment .AddDiscriminatorCondition(discriminatorColumn, entityTypeMapping.EntityType.Name); } } }
private void ConfigureRowsAffectedParameter( ModificationFunctionMapping modificationStoredProcedureMapping, DbProviderManifest providerManifest) { if (string.IsNullOrWhiteSpace(this._rowsAffectedParameter)) { return; } if (modificationStoredProcedureMapping.RowsAffectedParameter == null) { FunctionParameter functionParameter = new FunctionParameter("_RowsAffected_", providerManifest.GetStoreType(TypeUsage.CreateDefaultTypeUsage((EdmType)PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32))), ParameterMode.Out); modificationStoredProcedureMapping.Function.AddParameter(functionParameter); modificationStoredProcedureMapping.RowsAffectedParameter = functionParameter; } modificationStoredProcedureMapping.RowsAffectedParameter.Name = this._rowsAffectedParameter; this._configuredParameters.Add(modificationStoredProcedureMapping.RowsAffectedParameter); }
protected virtual string Generate(ColumnModel op) { TypeUsage typeUsage = _providerManifest.GetStoreType(op.TypeUsage); StringBuilder sb = new StringBuilder(); string type = MySqlProviderServices.Instance.GetColumnType(typeUsage); sb.Append(type); if (!type.EndsWith(")", StringComparison.InvariantCulture)) { if ((op.ClrType == typeof(string)) || ((op.ClrType == typeof(byte)) && (op.ClrType.IsArray))) { if (op.MaxLength.HasValue) { sb.AppendFormat("({0}) ", op.MaxLength.Value); } } if (op.Precision.HasValue && op.Scale.HasValue) { sb.AppendFormat("( {0}, {1} ) ", op.Precision.Value, op.Scale.Value); } else { if (type == "datetime" || type == "timestamp" || type == "time") { if (op.Precision.HasValue && op.Precision.Value >= 1) { sb.AppendFormat("({0}) ", op.Precision.Value <= 6 ? op.Precision.Value : 6); } if (op.IsIdentity && (String.Compare(type, "datetime", true) == 0 || String.Compare(type, "timestamp", true) == 0)) { sb.AppendFormat(" DEFAULT CURRENT_TIMESTAMP{0}", op.Precision.HasValue && op.Precision.Value >= 1 ? "( " + op.Precision.Value.ToString() + " )" : ""); } } } } if (!(op.IsNullable ?? true)) { sb.Append(string.Format("{0} not null ", ((!primaryKeyCols.Contains(op.Name) && op.IsIdentity) ? " unsigned" : ""))); } if (op.IsIdentity && (new string[] { "tinyint", "smallint", "mediumint", "int", "bigint" }).Contains(type.ToLower())) { sb.Append(" auto_increment "); autoIncrementCols.Add(op.Name); } else { if (op.IsIdentity && String.Compare(type, "CHAR(36) BINARY", true) == 0) { var createTrigger = new StringBuilder(); createTrigger.AppendLine(string.Format("DROP TRIGGER IF EXISTS `{0}_IdentityTgr`;", TrimSchemaPrefix(_tableName))); createTrigger.AppendLine(string.Format("CREATE TRIGGER `{0}_IdentityTgr` BEFORE INSERT ON `{0}`", TrimSchemaPrefix(_tableName))); createTrigger.AppendLine("FOR EACH ROW BEGIN"); createTrigger.AppendLine(string.Format("SET NEW.{0} = UUID();", op.Name)); createTrigger.AppendLine(string.Format("DROP TEMPORARY TABLE IF EXISTS tmpIdentity_{0};", TrimSchemaPrefix(_tableName))); createTrigger.AppendLine(string.Format("CREATE TEMPORARY TABLE tmpIdentity_{0} (guid CHAR(36))ENGINE=MEMORY;", TrimSchemaPrefix(_tableName))); createTrigger.AppendLine(string.Format("INSERT INTO tmpIdentity_{0} VALUES(New.{1});", TrimSchemaPrefix(_tableName), op.Name)); createTrigger.AppendLine("END"); var sqlOp = new SqlOperation(createTrigger.ToString()); _specialStmts.Add(Generate(sqlOp)); } } if (!string.IsNullOrEmpty(op.DefaultValueSql)) { sb.Append(string.Format(" default {0}", op.DefaultValueSql)); } return(sb.ToString()); }
public void GetStoreType_returns_correct_default_type_usages_for_all_primitive_types() { // SqlProvider does not support SByte foreach (var legacyEdmPrimitiveType in LegacyEdmPrimitiveTypes.Where(t => t.Key != "SByte")) { TypeUsageVerificationHelper.VerifyTypeUsagesEquivalent( LegacyProviderManifest.GetStoreType( LegacyMetadata.TypeUsage.CreateDefaultTypeUsage(legacyEdmPrimitiveType.Value)), ProviderManifestWrapper.GetStoreType( TypeUsage.CreateDefaultTypeUsage(EdmPrimitiveTypes[legacyEdmPrimitiveType.Key]))); } }
internal void Configure( DbDatabaseMapping databaseMapping, StorageMappingFragment fragment, EntityType entityType, DbProviderManifest providerManifest) { DebugCheck.NotNull(fragment); DebugCheck.NotNull(providerManifest); var discriminatorColumn = fragment.Table.Properties .SingleOrDefault(c => string.Equals(c.Name, Discriminator, StringComparison.Ordinal)); if (discriminatorColumn == null) { var typeUsage = providerManifest.GetStoreType(DatabaseMappingGenerator.DiscriminatorTypeUsage); discriminatorColumn = new EdmProperty(Discriminator, typeUsage) { Nullable = false }; TablePrimitiveOperations.AddColumn(fragment.Table, discriminatorColumn); } if (AnyBaseTypeToTableWithoutColumnCondition( databaseMapping, entityType, fragment.Table, discriminatorColumn)) { discriminatorColumn.Nullable = true; } var existingConfiguration = discriminatorColumn.GetConfiguration() as Properties.Primitive.PrimitivePropertyConfiguration; if (Value != null) { ConfigureColumnType(providerManifest, existingConfiguration, discriminatorColumn); fragment.AddDiscriminatorCondition(discriminatorColumn, Value); } else { if (string.IsNullOrWhiteSpace(discriminatorColumn.TypeName)) { var typeUsage = providerManifest.GetStoreType(DatabaseMappingGenerator.DiscriminatorTypeUsage); discriminatorColumn.PrimitiveType = (PrimitiveType)typeUsage.EdmType; discriminatorColumn.MaxLength = DatabaseMappingGenerator.DiscriminatorMaxLength; discriminatorColumn.Nullable = false; } GetOrCreateConfiguration <Properties.Primitive.PrimitivePropertyConfiguration>().IsNullable = true; fragment.AddNullabilityCondition(discriminatorColumn, true); } if (_configuration == null) { return; } if (existingConfiguration != null) { string errorMessage; if ((existingConfiguration.OverridableConfigurationParts & OverridableConfigurationParts.OverridableInCSpace) != OverridableConfigurationParts.OverridableInCSpace && !existingConfiguration.IsCompatible( _configuration, inCSpace: true, errorMessage: out errorMessage)) { throw Error.ConflictingColumnConfiguration(discriminatorColumn, fragment.Table, errorMessage); } } if (_configuration.IsNullable != null) { discriminatorColumn.Nullable = _configuration.IsNullable.Value; } _configuration.Configure(discriminatorColumn, fragment.Table, providerManifest); }