public void UpdateColumnInfo(ColumnInfo columnInfo, PropertyInfo propertyInfo, IShamanLogger logger)
{
if (propertyInfo.GetCustomAttribute <TimestampAttribute>() == null)
{
return;
}
columnInfo.IsTimestamp = true;
logger.Log(typeof(TimestampAttributeUpdater), nameof(UpdateColumnInfo),
$"{columnInfo.ColumnName}.IsTimestamp=true");
columnInfo.IsDatabaseGenerated = true;
logger.Log(typeof(TimestampAttributeUpdater), nameof(UpdateColumnInfo),
$"{columnInfo.ColumnName}.IsDatabaseGenerated=true");
}
public static bool GetDefaultIsUnicodeText(Type dbContextType, IShamanLogger logger)
{
var fromAttribute = dbContextType.GetTypeInfo().GetCustomAttribute <UnicodeTextAttribute>()?.IsUnicode;
if (fromAttribute != null)
{
logger.Log(typeof(DefaultSchemaUpdater), nameof(GetDefaultIsUnicodeText),
"Default UnicodeText from " + nameof(UnicodeTextAttribute) + ": " + fromAttribute);
return(fromAttribute.Value);
}
logger.Log(typeof(DefaultSchemaUpdater), nameof(GetDefaultIsUnicodeText),
"Default UnicodeText = true");
return(true);
}
public void UpdateColumnInfoInModelInfo(ColumnInfo columnInfo,
IDbSetInfo dbSetInfo, IShamanLogger logger)
{
if (columnInfo.ClrProperty?.GetCustomAttribute <TimestampAttribute>() == null)
{
return;
}
var logPrefix = $"Set {dbSetInfo.TableName}.{columnInfo.ColumnName}";
const string logSource =
nameof(TimestampAttributeUpdater) + "." + nameof(UpdateColumnInfoOnModelCreating);
columnInfo.IsTimestamp = true;
logger.Log(logSource, $"{logPrefix}.IsTimestamp=true");
columnInfo.IsDatabaseGenerated = true;
logger.Log(logSource, $"{logPrefix}.IsDatabaseGenerated=true");
}
public void UpdateColumnInfoInModelInfo(ColumnInfo columnInfo,
IDbSetInfo dbSetInfo, IShamanLogger logger)
{
var attribute = columnInfo.ClrProperty?.GetCustomAttribute <NavigationPropertyAttribute>();
if (attribute == null)
{
return;
}
Action <string> log =
txt => logger.Log(typeof(NavigationPropertyAttributeUpdater), nameof(UpdateColumnInfoOnModelCreating),
txt);
var targetType = attribute.ForceNavigation ? "navigation" : "non-navigation";
if (columnInfo.IsNavigationProperty == attribute.ForceNavigation)
{
log(
$"column {columnInfo.ColumnName} has been already set as {targetType} property. NavigationPropertyAttribute is not necessary.");
}
else
{
columnInfo.IsNavigationProperty = attribute.ForceNavigation;
log($"column {columnInfo.ColumnName} is {targetType} property because of NavigationPropertyAttribute");
}
}
public void UpdateColumnInfoOnModelCreating(IDbSetInfo dbSetInfo,
ColumnInfo columnInfo,
EntityTypeBuilder entityBuilder,
IShamanLogger logger)
{
const string source = nameof(SqlServerReflectionService) + "." + nameof(UpdateColumnInfoOnModelCreating);
if (!UseDataType)
{
return;
}
if (columnInfo.ClrProperty?.PropertyType != typeof(string))
{
return;
}
var modelInfo = dbSetInfo.Model;
var collation = GetCollation(columnInfo, dbSetInfo, modelInfo);
if (string.IsNullOrEmpty(collation))
{
logger.Log(source, $"Column {dbSetInfo.GetSqlTableName()}.{columnInfo.PropertyName} has no SQL collation info");
return;
}
var isUnicode = columnInfo.IsUnicode ?? modelInfo.DefaultIsUnicodeText;
var sqlDataType = SqlServerFixerService.MkStringType(isUnicode, columnInfo.MaxLength, collation);
var action = $"{columnInfo.PropertyName}.HasColumnType(\"{sqlDataType}\")";
logger.LogCalling(source, dbSetInfo.EntityType, action);
entityBuilder.Property(columnInfo.PropertyName).HasColumnType(sqlDataType);
}
public static void SetRawModel(Type type, IMutableModel model, IShamanLogger logger)
{
void Log(string message)
{
logger.Log(typeof(ModelsCachedContainer), nameof(SetRawModel), message);
}
string MutableEntityTypeToString(IMutableEntityType mutableEntityType)
{
try
{
var r = mutableEntityType.Relational();
return($"{r.Schema}.{r.TableName}");
}
catch (Exception e)
{
logger.LogException(Guid.Parse("{22CC8890-B871-45BF-890E-9341B41183F6}"), e);
return("??");
}
}
var value = EfModelWrapper.FromModel(model);
var result = Cache.TryAdd(type, value);
Log(result ? "Success" : "Skipped");
}
public static void Log(this IShamanLogger src, string source, string message)
{
if (!src.IsNullOrEmpty())
{
src.Log(new ShamanLogMessage(source, message));
}
}
public void UpdateDbSetInfo(DbSetInfo dbSetInfo, Type entityType, Type contextType, IShamanLogger logger)
{
var tableAttribute = entityType.GetTypeInfo().GetCustomAttribute <TableAttribute>();
if (tableAttribute == null || _ignoreTableAttribute)
{
dbSetInfo.TableName = _prefix + dbSetInfo.TableName;
logger.Log(typeof(PrefixedTableNameService), nameof(UpdateDbSetInfo),
$"Set TableName='{dbSetInfo.TableName}', prefix='{_prefix}')");
}
}
private static void UpdateAnnotation(IShamanAnnotatable annotatable, string collation, IShamanLogger logger,
string target)
{
if (string.IsNullOrEmpty(collation))
{
return;
}
logger.Log(nameof(SqlServerReflectionService),
$"Set annotation['{Ck}']='{collation}' for {target}");
annotatable.Annotations[Ck] = collation;
}
public void UpdateColumnInfo(ColumnInfo columnInfo, PropertyInfo propertyInfo, IShamanLogger logger)
{
var indexAttribute = propertyInfo.GetCustomAttribute <UnicodeTextAttribute>();
if (indexAttribute == null)
{
return;
}
logger.Log(typeof(UnicodeTextAttribute), nameof(UpdateColumnInfo),
$"Set IsUnicode={indexAttribute.IsUnicode}");
columnInfo.IsUnicode = indexAttribute.IsUnicode;
}
public void UpdateColumnInfo(ColumnInfo columnInfo, PropertyInfo propertyInfo, IShamanLogger logger)
{
var attribute = propertyInfo.GetCustomAttribute <ColumnAttribute>();
if (attribute == null)
{
return;
}
if (!string.IsNullOrEmpty(attribute.Name))
{
columnInfo.ColumnName = attribute.Name;
logger.Log(typeof(ColumnAttributeUpdater), "UpdateColumnInfo",
$"Set ColumnName='{columnInfo.ColumnName}'");
}
if (attribute.Order >= 0)
{
columnInfo.ForceFieldOrder = attribute.Order;
logger.Log(typeof(ColumnAttributeUpdater), "UpdateColumnInfo",
$"Set ForceFieldOrder={columnInfo.ForceFieldOrder}");
}
}
public void UpdateColumnInfo(ColumnInfo columnInfo, PropertyInfo propertyInfo, IShamanLogger logger)
{
var attribute = propertyInfo.GetCustomAttribute <RequiredAttribute>();
if (attribute == null)
{
return;
}
columnInfo.NotNull = true;
logger.Log(typeof(RequiredAttributeUpdater), nameof(UpdateColumnInfo),
$"Set NotNull=true for column '{columnInfo.ColumnName}'");
}
public void UpdateColumnInfoInModelInfo(ColumnInfo columnInfo,
IDbSetInfo dbSetInfo, IShamanLogger logger)
{
var indexAttribute = columnInfo.ClrProperty?.GetCustomAttribute <UnicodeTextAttribute>();
if (indexAttribute == null)
{
return;
}
logger.Log(typeof(UnicodeTextAttribute), nameof(UpdateColumnInfoOnModelCreating),
$"Set IsUnicode={indexAttribute.IsUnicode}");
columnInfo.IsUnicode = indexAttribute.IsUnicode;
}
public static string GetDefaultSchema(Type type, EfModelWrapper model, IShamanLogger logger)
{
var schema = type.GetTypeInfo().GetCustomAttribute <DefaultSchemaAttribute>()?.Schema?.Trim();
if (!string.IsNullOrEmpty(schema))
{
logger.Log(typeof(DefaultSchemaUpdater), nameof(GetDefaultSchema),
"Default schema from " + nameof(DefaultSchemaAttribute) + ": " + schema);
return(schema);
}
schema = model.DefaultSchema;
return(schema);
}
public void UpdateColumnInfo(ColumnInfo columnInfo, PropertyInfo propertyInfo, IShamanLogger logger)
{
var indexAttribute = propertyInfo.GetCustomAttribute <DecimalTypeAttribute>();
if (indexAttribute == null)
{
return;
}
logger.Log(typeof(DecimalTypeAttributeUpdater), nameof(UpdateColumnInfo),
$"Set MaxLength={indexAttribute.Length}, DecimalPlaces={indexAttribute.DecimalPlaces} for column '{columnInfo.ColumnName}'");
columnInfo.MaxLength = indexAttribute.Length;
columnInfo.DecimalPlaces = indexAttribute.DecimalPlaces;
}
public void UpdateColumnInfo(ColumnInfo columnInfo, PropertyInfo propertyInfo, IShamanLogger logger)
{
var attribute = propertyInfo.GetCustomAttribute <SqlServerCollationAttribute>();
var collation = attribute?.Collation?.Trim();
if (string.IsNullOrEmpty(collation))
{
return;
}
logger.Log(typeof(SqlServerReflectionService), nameof(UpdateColumnInfo),
$"Set annotation['{Ck}']='{collation}' for column '{columnInfo.ColumnName}'");
columnInfo.Annotations[Ck] = collation;
}
public void UpdateColumnInfoInModelInfo(ColumnInfo columnInfo,
IDbSetInfo dbSetInfo, IShamanLogger logger)
{
var attribute = columnInfo.ClrProperty?.GetCustomAttribute <ColumnAttribute>();
if (attribute == null)
{
return;
}
const string logSource = nameof(ColumnInfoColumnAttributeUpdater) + "." + nameof(UpdateColumnInfoInModelInfo);
if (!string.IsNullOrEmpty(attribute.Name))
{
columnInfo.ColumnName = attribute.Name;
logger.Log(logSource, $"Set {dbSetInfo.TableName}.{columnInfo.ColumnName}.ColumnName='{columnInfo.ColumnName}'");
}
if (attribute.Order >= 0)
{
columnInfo.ForceFieldOrder = attribute.Order;
logger.Log(logSource, $"Set {dbSetInfo.TableName}.{columnInfo.ColumnName}.ForceFieldOrder={columnInfo.ForceFieldOrder}");
}
}
public static void Log(this IShamanLogger src, Type t, string method, string message)
{
if (src.IsNullOrEmpty())
{
return;
}
var info = new ShamanLogMessage
{
Source = $"{t.Name}.{method}",
Message = message
};
src.Log(info);
}
public void UpdateColumnInfo(ColumnInfo columnInfo, PropertyInfo propertyInfo, IShamanLogger logger)
{
var at = propertyInfo.GetCustomAttribute <DatabaseGeneratedAttribute>();
if (at == null)
{
return;
}
logger.Log(
typeof(DatabaseGeneratedAttributeUpdater),
nameof(UpdateColumnInfo),
$"Set IsDatabaseGenerated=true and DatabaseGeneratedOption.Identity for column {columnInfo.ColumnName}");
columnInfo.IsDatabaseGenerated = true;
columnInfo.IsIdentity = at.DatabaseGeneratedOption == DatabaseGeneratedOption.Identity;
}
public void UpdateDbSetInfo(DbSetInfo dbSetInfo, Type entityType, Type contextType, IShamanLogger logger)
{
var ta = entityType.GetTypeInfo().GetCustomAttribute <TableAttribute>();
if (ta == null)
{
return;
}
dbSetInfo.TableName = ta.Name;
if (!string.IsNullOrEmpty(ta.Schema))
{
dbSetInfo.Schema = ta.Schema;
}
logger.Log(typeof(TableAttributeUpdater), nameof(UpdateDbSetInfo),
$"Set Schema='{dbSetInfo.Schema}' for table '{dbSetInfo.TableName}'");
}
public static IShamanLogger Append(this IShamanLogger src, IShamanLogger another)
{
if (src.IsNullOrEmpty())
{
return(another ?? EmptyShamanLogger.Instance);
}
if (another.IsNullOrEmpty())
{
return(src ?? EmptyShamanLogger.Instance);
}
return(new MethodCallLogger(info =>
{
src.Log(info);
another.Log(info);
}));
}
public void UpdateDbSetInfo(DbSetInfo dbSetInfo, Type entityType, Type contextType, IShamanLogger logger)
{
if (string.IsNullOrEmpty(dbSetInfo.Schema))
{
dbSetInfo.Schema = "dbo";
}
var attribute = entityType.GetTypeInfo().GetCustomAttribute <SqlServerCollationAttribute>();
var collation = attribute?.Collation?.Trim();
if (string.IsNullOrEmpty(collation))
{
return;
}
logger.Log(typeof(SqlServerReflectionService), nameof(UpdateDbSetInfo),
$"Set annotation['{Ck}']='{collation}' for table '{dbSetInfo.TableName}'");
dbSetInfo.Annotations[Ck] = collation;
}
private static IReadOnlyDictionary <Type, string> GetTableNamesFromModel(EfModelWrapper model,
IShamanLogger logger)
{
if (model == null)
{
return(null);
}
var result = new Dictionary <Type, string>();
foreach (var entityType in model.EntityTypes)
{
result[entityType.ClrType] = entityType.TableName;
logger.Log(typeof(ModelInfo), nameof(GetTableNamesFromModel),
$"Table name for {entityType.ClrType.Name}: {entityType.TableName}");
}
return(result);
}
public void UpdateColumnInfoInModelInfo(ColumnInfo columnInfo,
IDbSetInfo dbSetInfo, IShamanLogger logger)
{
var attribute = columnInfo.ClrProperty?.GetCustomAttribute <RequiredAttribute>();
if (attribute == null)
{
return;
}
var logPrefix = $"Set {dbSetInfo.TableName}.{columnInfo.ColumnName}";
const string logSource =
nameof(RequiredAttributeUpdater) + "." + nameof(UpdateColumnInfoInModelInfo);
columnInfo.NotNull = true;
logger.Log(logSource, $"{logPrefix}.NotNull=true");
}
public void UpdateColumnInfo(ColumnInfo columnInfo, PropertyInfo propertyInfo, IShamanLogger logger)
{
var indexAttributes = propertyInfo.GetCustomAttributes <AbstractIndexAttribute>()?.ToArray();
if (indexAttributes == null || !indexAttributes.Any())
{
return;
}
foreach (var indexAttribute in indexAttributes)
{
var indexInfo = GetOrCreateColumnIndexInfo(columnInfo, indexAttribute)
.WithInfoFromAbstractIndexAttribute(indexAttribute)
.WithInfoFromUniqueIndexAttribute(indexAttribute as UniqueIndexAttribute)
.WithInfoFromFullTextIndexAttribute(indexAttribute as FullTextIndexAttribute);
logger.Log(typeof(IndexAttributeUpdater), nameof(UpdateColumnInfo),
$"Set indexInfo: Order={indexInfo.Order}, IsDescending={indexInfo.IsDescending}, IndexType={indexInfo.IndexType}");
}
}
public void UpdateDbSetInfo(DbSetInfo dbSetInfo, Type entityType, Type contextType, IShamanLogger logger)
{
var target = $"table {dbSetInfo.GetSqlTableName()}";
if (string.IsNullOrEmpty(dbSetInfo.Schema))
{
dbSetInfo.Schema = UseDefaultTableSchema;
logger.Log(nameof(SqlServerReflectionService),
$"Set table schema '{dbSetInfo.Schema}' for {target}, entity={entityType}");
}
var collation = GetCollation(entityType.GetTypeInfo());
if (string.IsNullOrEmpty(collation))
{
return;
}
UpdateAnnotation(dbSetInfo, collation, logger, target);
}
public void UpdateColumnInfoInModelInfo(ColumnInfo columnInfo,
IDbSetInfo dbSetInfo, IShamanLogger logger)
{
var indexAttributes = columnInfo.ClrProperty?.GetCustomAttributes <AbstractIndexAttribute>()?.ToArray();
if (indexAttributes == null || !indexAttributes.Any())
{
return;
}
foreach (var indexAttribute in indexAttributes)
{
var indexInfo = GetOrCreateColumnIndexInfo(columnInfo, indexAttribute)
.WithInfoFromAbstractIndexAttribute(indexAttribute)
.WithInfoFromUniqueIndexAttribute(indexAttribute as UniqueIndexAttribute)
.WithInfoFromFullTextIndexAttribute(indexAttribute as FullTextIndexAttribute);
var target = $"column {dbSetInfo.Schema}.{dbSetInfo.TableName}.{columnInfo.ColumnName}";
logger.Log(typeof(IndexAttributeUpdater), nameof(UpdateColumnInfoOnModelCreating),
$"Set indexInfo: Order={indexInfo.Order}, IsDescending={indexInfo.IsDescending}, IndexType={indexInfo.IndexType} for {target}");
}
}
private static EfModelWrapper GetModel(Type dbContextType, bool raw, IShamanLogger logger)
{
Action <string> log = message => logger.Log(typeof(ModelsCachedContainer), nameof(GetModelInternal),
message);
try
{
var instance = new ModelsCachedContainer
{
DbContextType = dbContextType,
Raw = raw,
Logger = logger
};
return(instance.GetModelInternal());
}
catch (Exception e)
{
log("Exception " + e.Message);
throw;
}
}
private static EfModelWrapper GetModel(Type dbContextType, bool raw, IShamanLogger logger)
{
Action <string> log = message => logger.Log(typeof(ModelsCachedContainer), nameof(GetModelInternal),
message);
try
{
var instance = new ModelsCachedContainer
{
DbContextType = dbContextType,
Raw = raw,
Logger = logger
};
return(instance.GetModelInternal());
}
catch (Exception e)
{
logger.LogException(Guid.Parse("{F0BA1A53-86D9-430D-99A7-4D5792C593EF}"), e);
log("Exception " + e.Message);
throw;
}
}
public static Action <string> CreateMethod(this IShamanLogger logger, Type type, string method)
{
return(txt => logger.Log(type, method, txt));
}
