Resiliency to columns with missing types in SQL Server scaffolding

src/EFCore.SqlServer/Diagnostics/Internal/SqlServerLoggingDefinitions.cs

@@ -37,6 +37,14 @@ public class SqlServerLoggingDefinitions : RelationalLoggingDefinitions
         /// </summary>
         public EventDefinitionBase? LogByteIdentityColumn;
 
+        /// <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 EventDefinitionBase? LogColumnWithoutType;
+
         /// <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

src/EFCore.SqlServer/Diagnostics/SqlServerEventId.cs

@@ -64,6 +64,7 @@ private enum Id
             ForeignKeyPrincipalColumnMissingWarning,
             ReflexiveConstraintIgnored,
             DuplicateForeignKeyConstraintIgnored,
+            ColumnWithoutTypeWarning
         }
 
         private static readonly string _validationPrefix = DbLoggerCategory.Model.Validation.Name + ".";
@@ -237,5 +238,11 @@ private static EventId MakeScaffoldingId(Id id)
         ///     This event is in the <see cref="DbLoggerCategory.Scaffolding" /> category.
         /// </summary>
         public static readonly EventId DuplicateForeignKeyConstraintIgnored = MakeScaffoldingId(Id.DuplicateForeignKeyConstraintIgnored);
+
+        /// <summary>
+        ///     A column was skipped because its database type could not be found.
+        ///     This event is in the <see cref="DbLoggerCategory.Scaffolding" /> category.
+        /// </summary>
+        public static readonly EventId ColumnWithoutTypeWarning = MakeScaffoldingId(Id.ColumnWithoutTypeWarning);
     }
 }

src/EFCore.SqlServer/Extensions/Internal/SqlServerLoggerExtensions.cs

@@ -433,6 +433,27 @@ public static void MissingTableWarning(
             // No DiagnosticsSource events because these are purely design-time messages
         }
 
+        /// <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 void ColumnWithoutTypeWarning(
+            this IDiagnosticsLogger<DbLoggerCategory.Scaffolding> diagnostics,
+            string tableName,
+            string columnName)
+        {
+            var definition = SqlServerResources.LogColumnWithoutType(diagnostics);
+
+            if (diagnostics.ShouldLog(definition))
+            {
+                definition.Log(diagnostics, tableName, columnName);
+            }
+
+            // No DiagnosticsSource events because these are purely design-time messages
+        }
+
         /// <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

src/EFCore.SqlServer/Properties/SqlServerStrings.resx

@@ -184,6 +184,10 @@
     <value>The property '{property}' on entity type '{entityType}' is of type 'byte', but is set up to use a SQL Server identity column; this requires that values starting at 255 and counting down will be used for temporary key values. A temporary key value is needed for every entity inserted in a single call to 'SaveChanges'. Care must be taken that these values do not collide with real key values.</value>
     <comment>Warning SqlServerEventId.ByteIdentityColumnWarning string string</comment>
   </data>
+  <data name="LogColumnWithoutType" xml:space="preserve">
+    <value>A database type for column '{columnName}' on table '{tableName}' could not be found, the column will be skipped.</value>
+    <comment>Warning SqlServerEventId.ColumnWithoutTypeWarning string string</comment>
+  </data>
   <data name="LogConflictingValueGenerationStrategies" xml:space="preserve">
     <value>Both the SqlServerValueGenerationStrategy '{generationStrategy}' and '{otherGenerationStrategy}' have been set on property '{propertyName}' on entity type '{entityName}'. Configuring two strategies is usually unintentional and will likely result in a database error.</value>
     <comment>Warning SqlServerEventId.ConflictingValueGenerationStrategiesWarning string string string string</comment>

src/EFCore.SqlServer/Scaffolding/Internal/SqlServerDatabaseModelFactory.cs

@@ -5,6 +5,7 @@
 using System.Collections.Generic;
 using System.Data;
 using System.Data.Common;
+using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
 using System.Linq;
 using System.Text;
@@ -19,6 +20,7 @@
 using Microsoft.EntityFrameworkCore.SqlServer.Internal;
 using Microsoft.EntityFrameworkCore.SqlServer.Metadata.Internal;
 using Microsoft.EntityFrameworkCore.Utilities;
+using Microsoft.Extensions.Logging;
 
 namespace Microsoft.EntityFrameworkCore.SqlServer.Scaffolding.Internal
 {
@@ -711,7 +713,7 @@ UNION ALL
             commandText += @"
 ) o
 JOIN [sys].[columns] AS [c] ON [o].[object_id] = [c].[object_id]
-JOIN [sys].[types] AS [tp] ON [c].[user_type_id] = [tp].[user_type_id]
+LEFT JOIN [sys].[types] AS [tp] ON [c].[user_type_id] = [tp].[user_type_id]
 LEFT JOIN [sys].[extended_properties] AS [e] ON [e].[major_id] = [o].[object_id] AND [e].[minor_id] = [c].[column_id] AND [e].[class] = 1 AND [e].[name] = 'MS_Description'
 LEFT JOIN [sys].[computed_columns] AS [cc] ON [c].[object_id] = [cc].[object_id] AND [c].[column_id] = [cc].[column_id]
 LEFT JOIN [sys].[default_constraints] AS [dc] ON [c].[object_id] = [dc].[parent_object_id] AND [c].[column_id] = [dc].[parent_column_id]";
@@ -744,7 +746,7 @@ UNION ALL
                     var columnName = dataRecord.GetFieldValue<string>("column_name");
                     var ordinal = dataRecord.GetFieldValue<int>("ordinal");
                     var dataTypeSchemaName = dataRecord.GetValueOrDefault<string>("type_schema");
-                    var dataTypeName = dataRecord.GetFieldValue<string>("type_name");
+                    var dataTypeName = dataRecord.GetValueOrDefault<string>("type_name");
                     var maxLength = dataRecord.GetValueOrDefault<int>("max_length");
                     var precision = dataRecord.GetValueOrDefault<int>("precision");
                     var scale = dataRecord.GetValueOrDefault<int>("scale");
@@ -758,6 +760,12 @@ UNION ALL
                     var isSparse = dataRecord.GetValueOrDefault<bool>("is_sparse");
                     var generatedAlwaysType = SupportsTemporalTable() ? dataRecord.GetValueOrDefault<byte>("generated_always_type") : 0;
 
+                    if (dataTypeName is null)
+                    {
+                        _logger.ColumnWithoutTypeWarning(DisplayName(tableSchema, tableName), columnName);
+                        continue;
+                    }
+
                     _logger.ColumnFound(
                         DisplayName(tableSchema, tableName),
                         columnName,
@@ -991,13 +999,62 @@ FROM [sys].[indexes] i
                                 TypeDesc: ddr.GetValueOrDefault<string>("type_desc")))
                     .ToArray();
 
+                Check.DebugAssert(primaryKeyGroups.Length == 0 || primaryKeyGroups.Length == 1, "Multiple primary keys found");
+
                 if (primaryKeyGroups.Length == 1)
                 {
-                    var primaryKeyGroup = primaryKeyGroups[0];
+                    if (TryGetPrimaryKey(primaryKeyGroups[0], out var primaryKey))
+                    {
+                        _logger.PrimaryKeyFound(primaryKey.Name!, DisplayName(tableSchema, tableName));
+                        table.PrimaryKey = primaryKey;
+                    }
+                }
 
-                    _logger.PrimaryKeyFound(primaryKeyGroup.Key.Name, DisplayName(tableSchema, tableName));
+                var uniqueConstraintGroups = tableIndexGroup
+                    .Where(ddr => ddr.GetValueOrDefault<bool>("is_unique_constraint"))
+                    .GroupBy(
+                        ddr =>
+                            (Name: ddr.GetValueOrDefault<string>("index_name"),
+                                TypeDesc: ddr.GetValueOrDefault<string>("type_desc")))
+                    .ToArray();
 
-                    var primaryKey = new DatabasePrimaryKey { Table = table, Name = primaryKeyGroup.Key.Name };
+                foreach (var uniqueConstraintGroup in uniqueConstraintGroups)
+                {
+                    if (TryGetUniqueConstraint(uniqueConstraintGroup, out var uniqueConstraint))
+                    {
+                        _logger.UniqueConstraintFound(uniqueConstraintGroup.Key.Name!, DisplayName(tableSchema, tableName));
+                        table.UniqueConstraints.Add(uniqueConstraint);
+                    }
+                }
+
+                var indexGroups = tableIndexGroup
+                    .Where(
+                        ddr => !ddr.GetValueOrDefault<bool>("is_primary_key")
+                            && !ddr.GetValueOrDefault<bool>("is_unique_constraint"))
+                    .GroupBy(
+                        ddr =>
+                            (Name: ddr.GetValueOrDefault<string>("index_name"),
+                                TypeDesc: ddr.GetValueOrDefault<string>("type_desc"),
+                                IsUnique: ddr.GetValueOrDefault<bool>("is_unique"),
+                                HasFilter: ddr.GetValueOrDefault<bool>("has_filter"),
+                                FilterDefinition: ddr.GetValueOrDefault<string>("filter_definition"),
+                                FillFactor: ddr.GetValueOrDefault<byte>("fill_factor")))
+                    .ToArray();
+
+                foreach (var indexGroup in indexGroups)
+                {
+                    if (TryGetIndex(indexGroup, out var index))
+                    {
+                        _logger.IndexFound(indexGroup.Key.Name!, DisplayName(tableSchema, tableName), indexGroup.Key.IsUnique);
+                        table.Indexes.Add(index);
+                    }
+                }
+
+                bool TryGetPrimaryKey(
+                    IGrouping<(string Name, string? TypeDesc), DbDataRecord> primaryKeyGroup,
+                    [NotNullWhen(true)] out DatabasePrimaryKey? primaryKey)
+                {
+                    primaryKey = new DatabasePrimaryKey { Table = table, Name = primaryKeyGroup.Key.Name };
 
                     if (primaryKeyGroup.Key.TypeDesc == "NONCLUSTERED")
                     {
@@ -1008,29 +1065,25 @@ FROM [sys].[indexes] i
                     {
                         var columnName = dataRecord.GetValueOrDefault<string>("column_name");
                         var column = table.Columns.FirstOrDefault(c => c.Name == columnName)
-                            ?? table.Columns.FirstOrDefault(
-                                c => c.Name!.Equals(columnName, StringComparison.OrdinalIgnoreCase));
-                        Check.DebugAssert(column != null, "column is null.");
+                                     ?? table.Columns.FirstOrDefault(
+                                         c => c.Name!.Equals(columnName, StringComparison.OrdinalIgnoreCase));
+
+                        if (column is null)
+                        {
+                            return false;
+                        }
 
                         primaryKey.Columns.Add(column);
                     }
 
-                    table.PrimaryKey = primaryKey;
+                    return true;
                 }
 
-                var uniqueConstraintGroups = tableIndexGroup
-                    .Where(ddr => ddr.GetValueOrDefault<bool>("is_unique_constraint"))
-                    .GroupBy(
-                        ddr =>
-                            (Name: ddr.GetValueOrDefault<string>("index_name"),
-                                TypeDesc: ddr.GetValueOrDefault<string>("type_desc")))
-                    .ToArray();
-
-                foreach (var uniqueConstraintGroup in uniqueConstraintGroups)
+                bool TryGetUniqueConstraint(
+                    IGrouping<(string? Name, string? TypeDesc), DbDataRecord> uniqueConstraintGroup,
+                    [NotNullWhen(true)] out DatabaseUniqueConstraint? uniqueConstraint)
                 {
-                    _logger.UniqueConstraintFound(uniqueConstraintGroup.Key.Name!, DisplayName(tableSchema, tableName));
-
-                    var uniqueConstraint = new DatabaseUniqueConstraint { Table = table, Name = uniqueConstraintGroup.Key.Name };
+                    uniqueConstraint = new DatabaseUniqueConstraint { Table = table, Name = uniqueConstraintGroup.Key.Name };
 
                     if (uniqueConstraintGroup.Key.TypeDesc == "CLUSTERED")
                     {
@@ -1041,35 +1094,26 @@ FROM [sys].[indexes] i
                     {
                         var columnName = dataRecord.GetValueOrDefault<string>("column_name");
                         var column = table.Columns.FirstOrDefault(c => c.Name == columnName)
-                            ?? table.Columns.FirstOrDefault(
-                                c => c.Name!.Equals(columnName, StringComparison.OrdinalIgnoreCase));
-                        Check.DebugAssert(column != null, "column is null.");
+                                     ?? table.Columns.FirstOrDefault(
+                                         c => c.Name!.Equals(columnName, StringComparison.OrdinalIgnoreCase));
+
+                        if (column is null)
+                        {
+                            return false;
+                        }
 
                         uniqueConstraint.Columns.Add(column);
                     }
 
-                    table.UniqueConstraints.Add(uniqueConstraint);
+                    return true;
                 }
 
-                var indexGroups = tableIndexGroup
-                    .Where(
-                        ddr => !ddr.GetValueOrDefault<bool>("is_primary_key")
-                            && !ddr.GetValueOrDefault<bool>("is_unique_constraint"))
-                    .GroupBy(
-                        ddr =>
-                            (Name: ddr.GetValueOrDefault<string>("index_name"),
-                                TypeDesc: ddr.GetValueOrDefault<string>("type_desc"),
-                                IsUnique: ddr.GetValueOrDefault<bool>("is_unique"),
-                                HasFilter: ddr.GetValueOrDefault<bool>("has_filter"),
-                                FilterDefinition: ddr.GetValueOrDefault<string>("filter_definition"),
-                                FillFactor: ddr.GetValueOrDefault<byte>("fill_factor")))
-                    .ToArray();
-
-                foreach (var indexGroup in indexGroups)
+                bool TryGetIndex(
+                    IGrouping<(string? Name, string? TypeDesc, bool IsUnique, bool HasFilter, string? FilterDefinition, byte FillFactor),
+                        DbDataRecord> indexGroup,
+                    [NotNullWhen(true)] out DatabaseIndex? index)
                 {
-                    _logger.IndexFound(indexGroup.Key.Name!, DisplayName(tableSchema, tableName), indexGroup.Key.IsUnique);
-
-                    var index = new DatabaseIndex
+                    index = new DatabaseIndex
                     {
                         Table = table,
                         Name = indexGroup.Key.Name,
@@ -1098,17 +1142,18 @@ FROM [sys].[indexes] i
                         }
 
                         var column = table.Columns.FirstOrDefault(c => c.Name == columnName)
-                            ?? table.Columns.FirstOrDefault(
-                                c => c.Name!.Equals(columnName, StringComparison.OrdinalIgnoreCase));
-                        Check.DebugAssert(column != null, "column is null.");
+                                     ?? table.Columns.FirstOrDefault(
+                                         c => c.Name!.Equals(columnName, StringComparison.OrdinalIgnoreCase));
+
+                        if (column is null)
+                        {
+                            return false;
+                        }
 
                         index.Columns.Add(column);
                     }
 
-                    if (index.Columns.Count > 0)
-                    {
-                        table.Indexes.Add(index);
-                    }
+                    return index.Columns.Count > 0;
                 }
             }
         }