/// <summary> /// <para> /// Creates a human-readable representation of the given metadata. /// </para> /// <para> /// Warning: Do not rely on the format of the returned string. /// It is designed for debugging only and may change arbitrarily between releases. /// </para> /// </summary> /// <param name="columnMapping"> The metadata item. </param> /// <param name="options"> Options for generating the string. </param> /// <param name="indent"> The number of indent spaces to use before each new line. </param> /// <returns> A human-readable representation. </returns> public static string ToDebugString( [NotNull] this IFunctionColumnMapping columnMapping, MetadataDebugStringOptions options, int indent = 0) { var builder = new StringBuilder(); var indentString = new string(' ', indent); builder.Append(indentString); var singleLine = (options & MetadataDebugStringOptions.SingleLine) != 0; if (singleLine) { builder.Append($"FunctionColumnMapping: "); } builder.Append(columnMapping.Property.Name).Append(" - "); builder.Append(columnMapping.Column.Name); if (!singleLine && (options & MetadataDebugStringOptions.IncludeAnnotations) != 0) { builder.Append(columnMapping.AnnotationsToDebugString(indent + 2)); } return(builder.ToString()); }
/// <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 string ToDebugString( [NotNull] this IDbFunctionParameter parameter, MetadataDebugStringOptions options, [NotNull] string indent = "") { var builder = new StringBuilder(); builder .Append(indent) .Append("DbFunctionParameter: "); builder.Append(parameter.Name) .Append(" ") .Append(parameter.StoreType); if ((options & MetadataDebugStringOptions.SingleLine) == 0) { if ((options & MetadataDebugStringOptions.IncludeAnnotations) != 0) { builder.Append(parameter.AnnotationsToDebugString(indent: indent + " ")); } } return(builder.ToString()); }
public static string ToDebugString( [NotNull] this IReadOnlySequence sequence, MetadataDebugStringOptions options, int indent = 0) { var builder = new StringBuilder(); var indentString = new string(' ', indent); builder .Append(indentString) .Append("Sequence: "); if (sequence.Schema != null) { builder .Append(sequence.Schema) .Append("."); } builder.Append(sequence.Name); if (!sequence.IsCyclic) { builder.Append(" Cyclic"); } if (sequence.StartValue != 1) { builder.Append(" Start: ") .Append(sequence.StartValue); } if (sequence.IncrementBy != 1) { builder.Append(" IncrementBy: ") .Append(sequence.IncrementBy); } if (sequence.MinValue != null) { builder.Append(" Min: ") .Append(sequence.MinValue); } if (sequence.MaxValue != null) { builder.Append(" Max: ") .Append(sequence.MaxValue); } if ((options & MetadataDebugStringOptions.SingleLine) == 0) { if ((options & MetadataDebugStringOptions.IncludeAnnotations) != 0) { builder.Append(sequence.AnnotationsToDebugString(indent: indent + 2)); } } return(builder.ToString()); }
public static string ToDebugString( [NotNull] this IUniqueConstraint uniqueConstraint, MetadataDebugStringOptions options, int indent = 0) { var builder = new StringBuilder(); var indentString = new string(' ', indent); builder.Append(indentString); var singleLine = (options & MetadataDebugStringOptions.SingleLine) != 0; if (singleLine) { builder.Append("Key: "); } builder .Append(uniqueConstraint.Name) .Append(" ") .Append(ColumnBase.Format(uniqueConstraint.Columns)); if (uniqueConstraint.GetIsPrimaryKey()) { builder.Append(" PrimaryKey"); } if (!singleLine && (options & MetadataDebugStringOptions.IncludeAnnotations) != 0) { builder.Append(uniqueConstraint.AnnotationsToDebugString(indent + 2)); } return(builder.ToString()); }
/// <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 string ToDebugString( [NotNull] this IModel model, MetadataDebugStringOptions options, [NotNull] string indent = "") { var builder = new StringBuilder(); builder.Append(indent).Append("Model: "); if (model.GetPropertyAccessMode() != PropertyAccessMode.PreferField) { builder.Append(" PropertyAccessMode.").Append(model.GetPropertyAccessMode()); } if (model.GetChangeTrackingStrategy() != ChangeTrackingStrategy.Snapshot) { builder.Append(" ChangeTrackingStrategy.").Append(model.GetChangeTrackingStrategy()); } foreach (var entityType in model.GetEntityTypes()) { builder.AppendLine().Append(entityType.ToDebugString(options, indent + " ")); } if ((options & MetadataDebugStringOptions.IncludeAnnotations) != 0) { builder.Append(model.AnnotationsToDebugString(indent)); } return(builder.ToString()); }
/// <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 string ToDebugString( [NotNull] this IColumnMapping columnMapping, MetadataDebugStringOptions options, [NotNull] string indent = "") { var builder = new StringBuilder(); builder.Append(indent); var singleLine = (options & MetadataDebugStringOptions.SingleLine) != 0; if (singleLine) { builder.Append($"ColumnMapping: "); } builder .Append(columnMapping.Property.DeclaringEntityType.DisplayName()) .Append(".") .Append(columnMapping.Property.Name) .Append(" - "); builder .Append(columnMapping.Column.Table.Name) .Append(".") .Append(columnMapping.Column.Name); if (!singleLine && (options & MetadataDebugStringOptions.IncludeAnnotations) != 0) { builder.Append(columnMapping.AnnotationsToDebugString(indent + " ")); } return(builder.ToString()); }
/// <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 string ToDebugString( [NotNull] this IViewMapping viewMapping, MetadataDebugStringOptions options, [NotNull] string indent = "") { var builder = new StringBuilder(); builder.Append(indent); var singleLine = (options & MetadataDebugStringOptions.SingleLine) != 0; if (singleLine) { builder.Append($"ViewMapping: "); } builder.Append(viewMapping.EntityType.Name).Append(" - "); builder.Append(viewMapping.Table.Name); if (viewMapping.IncludesDerivedTypes) { builder.Append($" IncludesDerivedTypes"); } if (!singleLine && (options & MetadataDebugStringOptions.IncludeAnnotations) != 0) { builder.Append(viewMapping.AnnotationsToDebugString(indent + " ")); } return(builder.ToString()); }
/// <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 string ToDebugString( [NotNull] this IRelationalModel model, MetadataDebugStringOptions options, [NotNull] string indent = "") { var builder = new StringBuilder(); builder.Append(indent).Append("DatabaseModel: "); foreach (var table in model.Tables) { builder.AppendLine().Append(table.ToDebugString(options, indent + " ")); } foreach (var view in model.Views) { builder.AppendLine().Append(view.ToDebugString(options, indent + " ")); } if ((options & MetadataDebugStringOptions.IncludeAnnotations) != 0) { builder.Append(model.AnnotationsToDebugString(indent)); } return(builder.ToString()); }
public static string ToDebugString( [NotNull] this ITableMapping tableMapping, MetadataDebugStringOptions options, int indent = 0) { var builder = new StringBuilder(); var indentString = new string(' ', indent); builder.Append(indentString); var singleLine = (options & MetadataDebugStringOptions.SingleLine) != 0; if (singleLine) { builder.Append("TableMapping: "); } builder.Append(tableMapping.EntityType.Name).Append(" - "); builder.Append(tableMapping.Table.Name); if (tableMapping.IncludesDerivedTypes) { builder.Append(" IncludesDerivedTypes"); } if (!singleLine && (options & MetadataDebugStringOptions.IncludeAnnotations) != 0) { builder.Append(tableMapping.AnnotationsToDebugString(indent + 2)); } return(builder.ToString()); }
/// <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 string ToDebugString( [NotNull] this ICheckConstraint constraint, MetadataDebugStringOptions options, [NotNull] string indent = "") { var builder = new StringBuilder(); builder .Append(indent) .Append("Check: "); builder.Append(constraint.Name) .Append(" \"") .Append(constraint.Sql) .Append("\""); if ((options & MetadataDebugStringOptions.SingleLine) == 0) { if ((options & MetadataDebugStringOptions.IncludeAnnotations) != 0) { builder.Append(constraint.AnnotationsToDebugString(indent: indent + " ")); } } return(builder.ToString()); }
public static string ToDebugString( [NotNull] this IStoreFunctionParameter parameter, MetadataDebugStringOptions options, int indent = 0) { var builder = new StringBuilder(); var indentString = new string(' ', indent); builder .Append(indentString) .Append("StoreFunctionParameter: "); builder.Append(parameter.Name) .Append(" ") .Append(parameter.Type); if ((options & MetadataDebugStringOptions.SingleLine) == 0) { if ((options & MetadataDebugStringOptions.IncludeAnnotations) != 0) { builder.Append(parameter.AnnotationsToDebugString(indent + 2)); } } return(builder.ToString()); }
public static string ToDebugString( [NotNull] this IReadOnlyForeignKey foreignKey, MetadataDebugStringOptions options, int indent = 0) { var builder = new StringBuilder(); var indentString = new string(' ', indent); builder.Append(indentString); var singleLine = (options & MetadataDebugStringOptions.SingleLine) != 0; if (singleLine) { builder.Append("ForeignKey: "); } builder .Append(foreignKey.DeclaringEntityType.DisplayName()) .Append(" ") .Append(foreignKey.Properties.Format()) .Append(" -> ") .Append(foreignKey.PrincipalEntityType.DisplayName()) .Append(" ") .Append(foreignKey.PrincipalKey.Properties.Format()); if (foreignKey.IsUnique) { builder.Append(" Unique"); } if (foreignKey.IsOwnership) { builder.Append(" Ownership"); } if (foreignKey.PrincipalToDependent != null) { builder.Append(" ToDependent: ").Append(foreignKey.PrincipalToDependent.Name); } if (foreignKey.DependentToPrincipal != null) { builder.Append(" ToPrincipal: ").Append(foreignKey.DependentToPrincipal.Name); } if (foreignKey.DeleteBehavior != DeleteBehavior.NoAction) { builder .Append(" ") .Append(foreignKey.DeleteBehavior); } if (!singleLine && (options & MetadataDebugStringOptions.IncludeAnnotations) != 0) { builder.Append(foreignKey.AnnotationsToDebugString(indent + 2)); } return(builder.ToString()); }
/// <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 string ToDebugString( [NotNull] this IKey key, MetadataDebugStringOptions options, [NotNull] string indent = "") { var builder = new StringBuilder(); builder.Append(indent); var singleLine = (options & MetadataDebugStringOptions.SingleLine) != 0; if (singleLine) { builder.Append("Key: "); } builder.AppendJoin( ", ", key.Properties.Select( p => singleLine ? p.DeclaringEntityType.DisplayName() + "." + p.Name : p.Name)); if (key.IsPrimaryKey()) { builder.Append(" PK"); } if (!singleLine && (options & MetadataDebugStringOptions.IncludeAnnotations) != 0) { builder.Append(key.AnnotationsToDebugString(indent + " ")); } return(builder.ToString()); }
public static string ToDebugString( [NotNull] this ISqlQuery sqlQuery, MetadataDebugStringOptions options, int indent = 0) { var builder = new StringBuilder(); var indentString = new string(' ', indent); builder .Append(indentString) .Append("SqlQuery: "); if (sqlQuery.Schema != null) { builder .Append(sqlQuery.Schema) .Append("."); } builder.Append(sqlQuery.Name); if ((options & MetadataDebugStringOptions.SingleLine) == 0) { if (sqlQuery.Sql != null) { builder.AppendLine().Append(indentString).Append(" Sql: "); builder.AppendLine().Append(indentString).Append(new string(' ', 4)).Append(sqlQuery.Sql); } var mappings = sqlQuery.EntityTypeMappings.ToList(); if (mappings.Count != 0) { builder.AppendLine().Append(indentString).Append(" EntityTypeMappings: "); foreach (var mapping in mappings) { builder.AppendLine().Append(mapping.ToDebugString(options, indent + 4)); } } var columns = sqlQuery.Columns.ToList(); if (columns.Count != 0) { builder.AppendLine().Append(indentString).Append(" Columns: "); foreach (var column in columns) { builder.AppendLine().Append(column.ToDebugString(options, indent + 4)); } } if ((options & MetadataDebugStringOptions.IncludeAnnotations) != 0) { builder.Append(sqlQuery.AnnotationsToDebugString(indent + 2)); } } return(builder.ToString()); }
/// <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 string ToDebugString( [NotNull] this ITable table, MetadataDebugStringOptions options, [NotNull] string indent = "") { var builder = new StringBuilder(); builder .Append(indent) .Append("Table: "); if (table.Schema != null) { builder .Append(table.Schema) .Append("."); } builder.Append(table.Name); if (!table.IsMigratable) { builder.Append(" NonMigratable"); } if ((options & MetadataDebugStringOptions.SingleLine) == 0) { var mappings = table.EntityTypeMappings.ToList(); if (mappings.Count != 0) { builder.AppendLine().Append(indent).Append(" EntityTypeMappings: "); foreach (var mapping in mappings) { builder.AppendLine().Append(mapping.ToDebugString(options, indent + " ")); } } var columns = table.Columns.ToList(); if (columns.Count != 0) { builder.AppendLine().Append(indent).Append(" Properties: "); foreach (var column in columns) { builder.AppendLine().Append(column.ToDebugString(options, indent + " ")); } } if ((options & MetadataDebugStringOptions.IncludeAnnotations) != 0) { builder.Append(table.AnnotationsToDebugString(indent: indent + " ")); } } return(builder.ToString()); }
/// <summary> /// <para> /// Creates a human-readable representation of the given metadata. /// </para> /// <para> /// Warning: Do not rely on the format of the returned string. /// It is designed for debugging only and may change arbitrarily between releases. /// </para> /// </summary> /// <param name="function"> The metadata item. </param> /// <param name="options"> Options for generating the string. </param> /// <param name="indent"> The number of indent spaces to use before each new line. </param> /// <returns> A human-readable representation. </returns> public static string ToDebugString( [NotNull] this IStoreFunction function, MetadataDebugStringOptions options, int indent = 0) { var builder = new StringBuilder(); var indentString = new string(' ', indent); builder .Append(indentString) .Append("StoreFunction: "); if (function.ReturnType != null) { builder.Append(function.ReturnType); } else { builder.Append(function.EntityTypeMappings.FirstOrDefault()?.EntityType.DisplayName() ?? ""); } builder.Append(" "); if (function.Schema != null) { builder .Append(function.Schema) .Append("."); } builder.Append(function.Name); if ((options & MetadataDebugStringOptions.SingleLine) == 0) { var parameters = function.Parameters.ToList(); if (parameters.Count != 0) { builder.AppendLine().Append(indentString).Append(" Parameters: "); foreach (var parameter in parameters) { builder.AppendLine().Append(parameter.ToDebugString(options, indent + 4)); } } if ((options & MetadataDebugStringOptions.IncludeAnnotations) != 0) { builder.Append(function.AnnotationsToDebugString(indent: indent + 2)); } } return(builder.ToString()); }
/// <summary> /// <para> /// Creates a human-readable representation of the given metadata. /// </para> /// <para> /// Warning: Do not rely on the format of the returned string. /// It is designed for debugging only and may change arbitrarily between releases. /// </para> /// </summary> /// <param name="view"> The metadata item. </param> /// <param name="options"> Options for generating the string. </param> /// <param name="indent"> The number of indent spaces to use before each new line. </param> /// <returns> A human-readable representation. </returns> public static string ToDebugString( [NotNull] this IView view, MetadataDebugStringOptions options, int indent = 0) { var builder = new StringBuilder(); var indentString = new string(' ', indent); builder .Append(indentString) .Append("View: "); if (view.Schema != null) { builder .Append(view.Schema) .Append("."); } builder.Append(view.Name); if ((options & MetadataDebugStringOptions.SingleLine) == 0) { var mappings = view.EntityTypeMappings.ToList(); if (mappings.Count != 0) { builder.AppendLine().Append(indentString).Append(" EntityTypeMappings: "); foreach (var mapping in mappings) { builder.AppendLine().Append(mapping.ToDebugString(options, indent + 4)); } } var columns = view.Columns.ToList(); if (columns.Count != 0) { builder.AppendLine().Append(indentString).Append(" Properties: "); foreach (var column in columns) { builder.AppendLine().Append(column.ToDebugString(options, indent + 4)); } } if ((options & MetadataDebugStringOptions.IncludeAnnotations) != 0) { builder.Append(view.AnnotationsToDebugString(indent + 2)); } } return(builder.ToString()); }
public static string ToDebugString( [NotNull] this IRelationalModel model, MetadataDebugStringOptions options, int indent = 0) { var builder = new StringBuilder(); var indentString = new string(' ', indent); builder.Append(indentString).Append("RelationalModel: "); if (model.Collation != null) { builder.AppendLine().Append(indentString).Append("Collation: " + model.Collation); } foreach (var table in model.Tables) { builder.AppendLine().Append(table.ToDebugString(options, indent + 2)); } foreach (var view in model.Views) { builder.AppendLine().Append(view.ToDebugString(options, indent + 2)); } foreach (var function in model.Functions) { builder.AppendLine().Append(function.ToDebugString(options, indent + 2)); } foreach (var query in model.Queries) { builder.AppendLine().Append(query.ToDebugString(options, indent + 2)); } foreach (var sequence in model.Sequences) { builder.AppendLine().Append(sequence.ToDebugString(options, indent + 2)); } if ((options & MetadataDebugStringOptions.IncludeAnnotations) != 0) { builder.Append(model.AnnotationsToDebugString(indent)); } return(builder.ToString()); }
/// <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 string ToDebugString( [NotNull] this IDbFunction function, MetadataDebugStringOptions options, [NotNull] string indent = "") { var builder = new StringBuilder(); builder .Append(indent) .Append("DbFunction: "); builder.Append(function.ReturnType.ShortDisplayName()) .Append(" "); if (function.Schema != null) { builder .Append(function.Schema) .Append("."); } builder.Append(function.Name); if ((options & MetadataDebugStringOptions.SingleLine) == 0) { var parameters = function.Parameters.ToList(); if (parameters.Count != 0) { builder.AppendLine().Append(indent).Append(" Parameters: "); foreach (var parameter in parameters) { builder.AppendLine().Append(parameter.ToDebugString(options, indent + " ")); } } if ((options & MetadataDebugStringOptions.IncludeAnnotations) != 0) { builder.Append(function.AnnotationsToDebugString(indent: indent + " ")); } } return(builder.ToString()); }
/// <summary> /// <para> /// Creates a human-readable representation of the given metadata. /// </para> /// <para> /// Warning: Do not rely on the format of the returned string. /// It is designed for debugging only and may change arbitrarily between releases. /// </para> /// </summary> /// <param name="foreignKey"> The metadata item. </param> /// <param name="options"> Options for generating the string. </param> /// <param name="indent"> The number of indent spaces to use before each new line. </param> /// <returns> A human-readable representation. </returns> public static string ToDebugString( [NotNull] this IForeignKeyConstraint foreignKey, MetadataDebugStringOptions options, int indent = 0) { var builder = new StringBuilder(); var indentString = new string(' ', indent); builder.Append(indentString); var singleLine = (options & MetadataDebugStringOptions.SingleLine) != 0; if (singleLine) { builder.Append("ForeignKey: "); } builder .Append(foreignKey.Name) .Append(" ") .Append(foreignKey.Table.Name) .Append(" ") .Append(Column.Format(foreignKey.Columns)) .Append(" -> ") .Append(foreignKey.PrincipalTable.Name) .Append(" ") .Append(Column.Format(foreignKey.PrincipalColumns)); if (foreignKey.OnDeleteAction != ReferentialAction.NoAction) { builder .Append(" ") .Append(foreignKey.OnDeleteAction); } if (!singleLine && (options & MetadataDebugStringOptions.IncludeAnnotations) != 0) { builder.Append(foreignKey.AnnotationsToDebugString(indent + 2)); } return(builder.ToString()); }
/// <summary> /// <para> /// Creates a human-readable representation of the given metadata. /// </para> /// <para> /// Warning: Do not rely on the format of the returned string. /// It is designed for debugging only and may change arbitrarily between releases. /// </para> /// </summary> /// <param name="index"> The metadata item. </param> /// <param name="options"> Options for generating the string. </param> /// <param name="indent"> The number of indent spaces to use before each new line. </param> /// <returns> A human-readable representation. </returns> public static string ToDebugString( [NotNull] this IIndex index, MetadataDebugStringOptions options, int indent = 0) { var builder = new StringBuilder(); var indentString = new string(' ', indent); builder.Append(indentString); var singleLine = (options & MetadataDebugStringOptions.SingleLine) != 0; if (singleLine) { builder.Append("Index: "); } builder .AppendJoin( ", ", index.Properties.Select( p => singleLine ? p.DeclaringEntityType.DisplayName() + "." + p.Name : p.Name)); builder.Append(" " + index.Name ?? "<unnamed>"); if (index.IsUnique) { builder.Append(" Unique"); } if (!singleLine && (options & MetadataDebugStringOptions.IncludeAnnotations) != 0) { builder.Append(index.AnnotationsToDebugString(indent + 2)); } return(builder.ToString()); }
/// <summary> /// <para> /// Creates a human-readable representation of the given metadata. /// </para> /// <para> /// Warning: Do not rely on the format of the returned string. /// It is designed for debugging only and may change arbitrarily between releases. /// </para> /// </summary> /// <param name="index"> The metadata item. </param> /// <param name="options"> Options for generating the string. </param> /// <param name="indent"> The number of indent spaces to use before each new line. </param> /// <returns> A human-readable representation. </returns> public static string ToDebugString( [NotNull] this ITableIndex index, MetadataDebugStringOptions options, int indent = 0) { var builder = new StringBuilder(); var indentString = new string(' ', indent); builder.Append(indentString); var singleLine = (options & MetadataDebugStringOptions.SingleLine) != 0; if (singleLine) { builder.Append("Index: "); } builder .Append(index.Name) .Append(" ") .Append(ColumnBase.Format(index.Columns)); if (index.IsUnique) { builder .Append(" Unique"); } if (!string.IsNullOrWhiteSpace(index.Filter)) { builder .Append(" Filtered"); } if (!singleLine && (options & MetadataDebugStringOptions.IncludeAnnotations) != 0) { builder.Append(index.AnnotationsToDebugString(indent + 2)); } return(builder.ToString()); }
/// <summary> /// <para> /// Creates a human-readable representation of the given metadata. /// </para> /// <para> /// Warning: Do not rely on the format of the returned string. /// It is designed for debugging only and may change arbitrarily between releases. /// </para> /// </summary> /// <param name="column"> The metadata item. </param> /// <param name="options"> Options for generating the string. </param> /// <param name="indent"> The number of indent spaces to use before each new line. </param> /// <returns> A human-readable representation. </returns> public static string ToDebugString( [NotNull] this ISqlQueryColumn column, MetadataDebugStringOptions options, int indent = 0) { var builder = new StringBuilder(); var indentString = new string(' ', indent); builder.Append(indentString); var singleLine = (options & MetadataDebugStringOptions.SingleLine) != 0; if (singleLine) { builder.Append($"SqlQueryColumn: {column.Table.Name}."); } builder.Append(column.Name).Append(" ("); builder.Append(column.StoreType).Append(")"); if (column.IsNullable) { builder.Append(" Nullable"); } else { builder.Append(" NonNullable"); } builder.Append(")"); if (!singleLine && (options & MetadataDebugStringOptions.IncludeAnnotations) != 0) { builder.Append(column.AnnotationsToDebugString(indent + 2)); } return(builder.ToString()); }
/// <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 string ToDebugString( [NotNull] this IColumn column, MetadataDebugStringOptions options, [NotNull] string indent = "") { var builder = new StringBuilder(); builder.Append(indent); var singleLine = (options & MetadataDebugStringOptions.SingleLine) != 0; if (singleLine) { builder.Append($"Column: {column.Table.Name}."); } builder.Append(column.Name).Append(" ("); builder.Append(column.Type).Append(")"); if (column.IsNullable) { builder.Append(" Nullable"); } else { builder.Append(" NonNullable"); } builder.Append(")"); if (!singleLine && (options & MetadataDebugStringOptions.IncludeAnnotations) != 0) { builder.Append(column.AnnotationsToDebugString(indent + " ")); } return builder.ToString(); }
/// <summary> /// <para> /// Creates a human-readable representation of the given metadata. /// </para> /// <para> /// Warning: Do not rely on the format of the returned string. /// It is designed for debugging only and may change arbitrarily between releases. /// </para> /// </summary> /// <param name="serviceProperty"> The metadata item. </param> /// <param name="options"> Options for generating the string. </param> /// <param name="indent"> The number of indent spaces to use before each new line. </param> /// <returns> A human-readable representation. </returns> public static string ToDebugString( [NotNull] this IServiceProperty serviceProperty, MetadataDebugStringOptions options, int indent = 0) { var builder = new StringBuilder(); var indentString = new string(' ', indent); builder.Append(indentString); var singleLine = (options & MetadataDebugStringOptions.SingleLine) != 0; if (singleLine) { builder.Append("Service property: ").Append(serviceProperty.DeclaringType.DisplayName()).Append("."); } builder.Append(serviceProperty.Name); if (serviceProperty.GetFieldName() == null) { builder.Append(" (no field, "); } else { builder.Append(" (").Append(serviceProperty.GetFieldName()).Append(", "); } builder.Append(serviceProperty.ClrType?.ShortDisplayName()).Append(")"); if (!singleLine && (options & MetadataDebugStringOptions.IncludeAnnotations) != 0) { builder.Append(serviceProperty.AnnotationsToDebugString(indent + 2)); } return(builder.ToString()); }
/// <summary> /// <para> /// Creates a human-readable representation of the given metadata. /// </para> /// <para> /// Warning: Do not rely on the format of the returned string. /// It is designed for debugging only and may change arbitrarily between releases. /// </para> /// </summary> /// <param name="table"> The metadata item. </param> /// <param name="options"> Options for generating the string. </param> /// <param name="indent"> The number of indent spaces to use before each new line. </param> /// <returns> A human-readable representation. </returns> public static string ToDebugString( [NotNull] this ITable table, MetadataDebugStringOptions options, int indent = 0) { var builder = new StringBuilder(); var indentString = new string(' ', indent); builder .Append(indentString) .Append("Table: "); if (table.Schema != null) { builder .Append(table.Schema) .Append("."); } builder.Append(table.Name); if (table.IsExcludedFromMigrations) { builder.Append(" ExcludedFromMigrations"); } if ((options & MetadataDebugStringOptions.SingleLine) == 0) { var mappings = table.EntityTypeMappings.ToList(); if (mappings.Count != 0) { builder.AppendLine().Append(indentString).Append(" EntityTypeMappings: "); foreach (var mapping in mappings) { builder.AppendLine().Append(mapping.ToDebugString(options, indent + 4)); } } var columns = table.Columns.ToList(); if (columns.Count != 0) { builder.AppendLine().Append(indentString).Append(" Columns: "); foreach (var column in columns) { builder.AppendLine().Append(column.ToDebugString(options, indent + 4)); } } var checkConstraints = table.CheckConstraints.ToList(); if (checkConstraints.Count != 0) { builder.AppendLine().Append(indentString).Append(" Check constraints: "); foreach (var checkConstraint in checkConstraints) { builder.AppendLine().Append(checkConstraint.ToDebugString(options, indent + 4)); } } if ((options & MetadataDebugStringOptions.IncludeAnnotations) != 0) { builder.Append(table.AnnotationsToDebugString(indent + 2)); } } return(builder.ToString()); }
/// <summary> /// <para> /// Creates a human-readable representation of the given metadata. /// </para> /// <para> /// Warning: Do not rely on the format of the returned string. /// It is designed for debugging only and may change arbitrarily between releases. /// </para> /// </summary> /// <param name="entityType"> The entity type. </param> /// <param name="options"> Options for generating the string. </param> /// <param name="indent"> The number of indent spaces to use before each new line. </param> /// <returns> A human-readable representation. </returns> public static string ToDebugString( [NotNull] this IEntityType entityType, MetadataDebugStringOptions options, int indent = 0) { var builder = new StringBuilder(); var indentString = new string(' ', indent); builder .Append(indentString) .Append("EntityType: ") .Append(entityType.DisplayName()); if (entityType.BaseType != null) { builder.Append(" Base: ").Append(entityType.BaseType.DisplayName()); } if (entityType.HasSharedClrType) { builder.Append(" CLR Type: ").Append(entityType.ClrType.ShortDisplayName()); } if (entityType.IsAbstract()) { builder.Append(" Abstract"); } if (entityType.FindPrimaryKey() == null) { builder.Append(" Keyless"); } if (entityType.GetChangeTrackingStrategy() != ChangeTrackingStrategy.Snapshot) { builder.Append(" ChangeTrackingStrategy.").Append(entityType.GetChangeTrackingStrategy()); } if ((options & MetadataDebugStringOptions.SingleLine) == 0) { var properties = entityType.GetDeclaredProperties().ToList(); if (properties.Count != 0) { builder.AppendLine().Append(indentString).Append(" Properties: "); foreach (var property in properties) { builder.AppendLine().Append(property.ToDebugString(options, indent + 4)); } } var navigations = entityType.GetDeclaredNavigations().ToList(); if (navigations.Count != 0) { builder.AppendLine().Append(indentString).Append(" Navigations: "); foreach (var navigation in navigations) { builder.AppendLine().Append(navigation.ToDebugString(options, indent + 4)); } } var skipNavigations = entityType.GetDeclaredSkipNavigations().ToList(); if (skipNavigations.Count != 0) { builder.AppendLine().Append(indentString).Append(" Skip navigations: "); foreach (var skipNavigation in skipNavigations) { builder.AppendLine().Append(skipNavigation.ToDebugString(options, indent + 4)); } } var serviceProperties = entityType.GetDeclaredServiceProperties().ToList(); if (serviceProperties.Count != 0) { builder.AppendLine().Append(indentString).Append(" Service properties: "); foreach (var serviceProperty in serviceProperties) { builder.AppendLine().Append(serviceProperty.ToDebugString(options, indent + 4)); } } var keys = entityType.GetDeclaredKeys().ToList(); if (keys.Count != 0) { builder.AppendLine().Append(indentString).Append(" Keys: "); foreach (var key in keys) { builder.AppendLine().Append(key.ToDebugString(options, indent + 4)); } } var fks = entityType.GetDeclaredForeignKeys().ToList(); if (fks.Count != 0) { builder.AppendLine().Append(indentString).Append(" Foreign keys: "); foreach (var fk in fks) { builder.AppendLine().Append(fk.ToDebugString(options, indent + 4)); } } var indexes = entityType.GetDeclaredIndexes().ToList(); if (indexes.Count != 0) { builder.AppendLine().Append(indentString).Append(" Indexes: "); foreach (var index in indexes) { builder.AppendLine().Append(index.ToDebugString(options, indent + 4)); } } if ((options & MetadataDebugStringOptions.IncludeAnnotations) != 0) { builder.Append(entityType.AnnotationsToDebugString(indent: indent + 2)); } } return(builder.ToString()); }
/// <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 string ToDebugString( [NotNull] this INavigation navigation, MetadataDebugStringOptions options, [NotNull] string indent = "") { var builder = new StringBuilder(); builder.Append(indent); var singleLine = (options & MetadataDebugStringOptions.SingleLine) != 0; if (singleLine) { builder.Append($"Navigation: {navigation.DeclaringEntityType.DisplayName()}."); } builder.Append(navigation.Name); var field = navigation.GetFieldName(); if (field == null) { builder.Append(" (no field, "); } else if (!field.EndsWith(">k__BackingField", StringComparison.Ordinal)) { builder.Append($" ({field}, "); } else { builder.Append(" ("); } builder.Append(navigation.ClrType?.ShortDisplayName()).Append(")"); if (navigation.IsCollection) { builder.Append(" Collection"); } builder.Append(navigation.IsOnDependent ? " ToPrincipal " : " ToDependent "); builder.Append(navigation.TargetEntityType.DisplayName()); if (navigation.Inverse != null) { builder.Append(" Inverse: ").Append(navigation.Inverse.Name); } if (navigation.GetPropertyAccessMode() != PropertyAccessMode.PreferField) { builder.Append(" PropertyAccessMode.").Append(navigation.GetPropertyAccessMode()); } if ((options & MetadataDebugStringOptions.IncludePropertyIndexes) != 0) { var indexes = navigation.GetPropertyIndexes(); builder.Append(" ").Append(indexes.Index); builder.Append(" ").Append(indexes.OriginalValueIndex); builder.Append(" ").Append(indexes.RelationshipIndex); builder.Append(" ").Append(indexes.ShadowIndex); builder.Append(" ").Append(indexes.StoreGenerationIndex); } if (!singleLine && (options & MetadataDebugStringOptions.IncludeAnnotations) != 0) { builder.Append(navigation.AnnotationsToDebugString(indent + " ")); } return(builder.ToString()); }
public static string ToDebugString( [NotNull] this ITable table, MetadataDebugStringOptions options, int indent = 0) { var builder = new StringBuilder(); var indentString = new string(' ', indent); builder .Append(indentString) .Append("Table: "); if (table.Schema != null) { builder .Append(table.Schema) .Append("."); } builder.Append(table.Name); if (table.IsExcludedFromMigrations) { builder.Append(" ExcludedFromMigrations"); } if (table.PrimaryKey == null) { builder.Append(" Keyless"); } else { if ((options & MetadataDebugStringOptions.SingleLine) == 0) { builder.AppendLine(); } builder.Append(table.PrimaryKey.ToDebugString(options, indent + 2)); } if ((options & MetadataDebugStringOptions.SingleLine) == 0 && table.Comment != null) { builder .AppendLine() .Append(indentString) .AppendLine(" Comment:") .Append(indentString) .Append(table.Comment); } if ((options & MetadataDebugStringOptions.SingleLine) == 0) { var mappings = table.EntityTypeMappings.ToList(); if (mappings.Count != 0) { builder.AppendLine().Append(indentString).Append(" EntityTypeMappings: "); foreach (var mapping in mappings) { builder.AppendLine().Append(mapping.ToDebugString(options, indent + 4)); } } var columns = table.Columns.ToList(); if (columns.Count != 0) { builder.AppendLine().Append(indentString).Append(" Columns: "); foreach (var column in columns) { builder.AppendLine().Append(column.ToDebugString(options, indent + 4)); } } var foreignKeyConstraints = table.ForeignKeyConstraints.ToList(); if (foreignKeyConstraints.Count != 0) { builder.AppendLine().Append(indentString).Append(" ForeignKeyConstraints: "); foreach (var foreignKeyConstraint in foreignKeyConstraints) { builder.AppendLine().Append(foreignKeyConstraint.ToDebugString(options, indent + 4)); } } var indexes = table.Indexes.ToList(); if (indexes.Count != 0) { builder.AppendLine().Append(indentString).Append(" Indexes: "); foreach (var index in indexes) { builder.AppendLine().Append(index.ToDebugString(options, indent + 4)); } } var uniqueConstraints = table.UniqueConstraints.Where(uc => !uc.GetIsPrimaryKey()).ToList(); if (uniqueConstraints.Count != 0) { builder.AppendLine().Append(indentString).Append(" UniqueConstraints: "); foreach (var uniqueConstraint in uniqueConstraints) { builder.AppendLine().Append(uniqueConstraint.ToDebugString(options, indent + 4)); } } var checkConstraints = table.CheckConstraints.ToList(); if (checkConstraints.Count != 0) { builder.AppendLine().Append(indentString).Append(" Check constraints: "); foreach (var checkConstraint in checkConstraints) { builder.AppendLine().Append(checkConstraint.ToDebugString(options, indent + 4)); } } if ((options & MetadataDebugStringOptions.IncludeAnnotations) != 0) { builder.Append(table.AnnotationsToDebugString(indent + 2)); } } return(builder.ToString()); }
public static string ToDebugString( [NotNull] this IReadOnlyProperty property, MetadataDebugStringOptions options, int indent = 0) { var builder = new StringBuilder(); var indentString = new string(' ', indent); builder.Append(indentString); var singleLine = (options & MetadataDebugStringOptions.SingleLine) != 0; if (singleLine) { builder.Append($"Property: {property.DeclaringEntityType.DisplayName()}."); } builder.Append(property.Name).Append(" ("); var field = property.GetFieldName(); if (field == null) { builder.Append("no field, "); } else if (!field.EndsWith(">k__BackingField", StringComparison.Ordinal)) { builder.Append(field).Append(", "); } builder.Append(property.ClrType.ShortDisplayName()).Append(")"); if (property.IsShadowProperty()) { builder.Append(" Shadow"); } if (property.IsIndexerProperty()) { builder.Append(" Indexer"); } if (!property.IsNullable) { builder.Append(" Required"); } if (property.IsPrimaryKey()) { builder.Append(" PK"); } if (property.IsForeignKey()) { builder.Append(" FK"); } if (property.IsKey() && !property.IsPrimaryKey()) { builder.Append(" AlternateKey"); } if (property.IsIndex()) { builder.Append(" Index"); } if (property.IsConcurrencyToken) { builder.Append(" Concurrency"); } if (property.GetBeforeSaveBehavior() != PropertySaveBehavior.Save) { builder.Append(" BeforeSave:").Append(property.GetBeforeSaveBehavior()); } if (property.GetAfterSaveBehavior() != PropertySaveBehavior.Save) { builder.Append(" AfterSave:").Append(property.GetAfterSaveBehavior()); } if (property.ValueGenerated != ValueGenerated.Never) { builder.Append(" ValueGenerated.").Append(property.ValueGenerated); } if (property.GetMaxLength() != null) { builder.Append(" MaxLength(").Append(property.GetMaxLength()).Append(")"); } if (property.IsUnicode() == false) { builder.Append(" Ansi"); } if (property.GetPropertyAccessMode() != PropertyAccessMode.PreferField) { builder.Append(" PropertyAccessMode.").Append(property.GetPropertyAccessMode()); } if ((options & MetadataDebugStringOptions.IncludePropertyIndexes) != 0 && ((Annotatable)property).IsReadOnly) { var indexes = ((IProperty)property).GetPropertyIndexes(); builder.Append(" ").Append(indexes.Index); builder.Append(" ").Append(indexes.OriginalValueIndex); builder.Append(" ").Append(indexes.RelationshipIndex); builder.Append(" ").Append(indexes.ShadowIndex); builder.Append(" ").Append(indexes.StoreGenerationIndex); } if (!singleLine && (options & MetadataDebugStringOptions.IncludeAnnotations) != 0) { builder.Append(property.AnnotationsToDebugString(indent + 2)); } return(builder.ToString()); }