Make ColumnType return the mapped store type even when not set explicitly

src/EFCore.Relational/Metadata/Conventions/Internal/RelationalConventionSetBuilder.cs

@@ -5,7 +5,6 @@
 using System.Collections.Generic;
 using System.Linq;
 using JetBrains.Annotations;
-using Microsoft.EntityFrameworkCore.Storage;
 using Microsoft.EntityFrameworkCore.Utilities;
 
 namespace Microsoft.EntityFrameworkCore.Metadata.Conventions.Internal
@@ -62,6 +61,8 @@ public virtual ConventionSet AddConventions(ConventionSet conventionSet)
             conventionSet.ForeignKeyUniquenessConventions.Add(sharedTableConvention);
             conventionSet.ForeignKeyOwnershipConventions.Add(sharedTableConvention);
 
+            conventionSet.ModelBuiltConventions.Add(new RelationalTypeMappingConvention(Dependencies.TypeMapper));
+
             return conventionSet;
         }
 

src/EFCore.Relational/Metadata/Conventions/Internal/RelationalTypeMappingConvention.cs

@@ -0,0 +1,43 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System.Linq;
+using JetBrains.Annotations;
+using Microsoft.EntityFrameworkCore.Metadata.Internal;
+using Microsoft.EntityFrameworkCore.Storage;
+
+namespace Microsoft.EntityFrameworkCore.Metadata.Conventions.Internal
+{
+    /// <summary>
+    ///     This API supports the Entity Framework Core infrastructure and is not intended to be used
+    ///     directly from your code. This API may change or be removed in future releases.
+    /// </summary>
+    public class RelationalTypeMappingConvention : IModelConvention
+    {
+        private readonly IRelationalTypeMapper _typeMapper;
+
+        /// <summary>
+        ///     This API supports the Entity Framework Core infrastructure and is not intended to be used
+        ///     directly from your code. This API may change or be removed in future releases.
+        /// </summary>
+        public RelationalTypeMappingConvention([NotNull] IRelationalTypeMapper typeMapper)
+            => _typeMapper = typeMapper;
+
+        /// <summary>
+        ///     This API supports the Entity Framework Core infrastructure and is not intended to be used
+        ///     directly from your code. This API may change or be removed in future releases.
+        /// </summary>
+        public virtual InternalModelBuilder Apply(InternalModelBuilder modelBuilder)
+        {
+            foreach (var property in modelBuilder.Metadata.GetEntityTypes().SelectMany(e => e.GetDeclaredProperties()))
+            {
+                property.Builder.HasAnnotation(
+                    RelationalAnnotationNames.TypeMapping,
+                    _typeMapper.FindMapping(property),
+                    ConfigurationSource.Convention);
+            }
+
+            return modelBuilder;
+        }
+    }
+}

src/EFCore.Relational/Metadata/RelationalAnnotationNames.cs

@@ -79,5 +79,10 @@ public static class RelationalAnnotationNames
         ///     The name for filter annotations.
         /// </summary>
         public const string Filter = Prefix + "Filter";
+
+        /// <summary>
+        ///     The name for filter annotations.
+        /// </summary>
+        public const string TypeMapping = Prefix + "TypeMapping";
     }
 }

src/EFCore.Relational/Metadata/RelationalPropertyAnnotations.cs

@@ -9,6 +9,7 @@
 using JetBrains.Annotations;
 using Microsoft.EntityFrameworkCore.Internal;
 using Microsoft.EntityFrameworkCore.Metadata.Internal;
+using Microsoft.EntityFrameworkCore.Storage;
 using Microsoft.EntityFrameworkCore.Utilities;
 
 namespace Microsoft.EntityFrameworkCore.Metadata
@@ -126,7 +127,8 @@ protected virtual bool SetColumnName([CanBeNull] string value)
 
         public virtual string ColumnType
         {
-            get => (string)Annotations.GetAnnotation(RelationalAnnotationNames.ColumnType);
+            get => (string)Annotations.GetAnnotation(RelationalAnnotationNames.ColumnType)
+                ?? ((RelationalTypeMapping)Annotations.GetAnnotation(RelationalAnnotationNames.TypeMapping))?.StoreType;
             [param: CanBeNull] set => SetColumnType(value);
         }
 

src/EFCore.Relational/Storage/RelationalTypeMapperExtensions.cs

@@ -43,7 +43,9 @@ public static RelationalTypeMapping GetMapping(
             Check.NotNull(typeMapper, nameof(typeMapper));
             Check.NotNull(property, nameof(property));
 
-            var mapping = typeMapper.FindMapping(property);
+            var mapping = (RelationalTypeMapping)property[RelationalAnnotationNames.TypeMapping]
+                ?? typeMapper.FindMapping(property);
+
             if (mapping != null)
             {
                 return mapping;

test/EFCore.SqlServer.FunctionalTests/BuiltInDataTypesSqlServerTest.cs

@@ -5,6 +5,10 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Metadata.Internal;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Storage;
 using Microsoft.EntityFrameworkCore.TestUtilities.Xunit;
 using Microsoft.EntityFrameworkCore.Utilities;
 using Xunit;
@@ -2011,6 +2015,28 @@ const string query
         private const string FileLineEnding = @"
 ";
 
+        [Fact]
+        public void Can_get_column_types_from_built_model()
+        {
+            using (var context = CreateContext())
+            {
+                var typeMapper = context.GetService<IRelationalTypeMapper>();
+
+                foreach (var property in context.Model.GetEntityTypes().SelectMany(e => e.GetDeclaredProperties()))
+                {
+                    var columnType = property.Relational().ColumnType;
+                    Assert.NotNull(columnType);
+
+                    if (property[RelationalAnnotationNames.ColumnType] == null)
+                    {
+                        Assert.Equal(
+                            columnType.ToLowerInvariant(),
+                            typeMapper.FindMapping(property).StoreType.ToLowerInvariant());
+                    }
+                }
+            }
+        }
+
         private string Sql => Fixture.TestSqlLoggerFactory.Sql.Replace(Environment.NewLine, FileLineEnding);
 
         private class ColumnInfo

test/EFCore.Sqlite.FunctionalTests/BuiltInDataTypesSqliteTest.cs

@@ -3,6 +3,10 @@
 
 using System;
 using System.Linq;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Metadata.Internal;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Storage;
 using Xunit;
 
 namespace Microsoft.EntityFrameworkCore
@@ -796,5 +800,27 @@ public virtual void Can_insert_and_read_back_all_mapped_data_types_with_precisio
                 Assert.Equal(101.1m, entity.Decimal);
             }
         }
+
+        [Fact]
+        public void Can_get_column_types_from_built_model()
+        {
+            using (var context = CreateContext())
+            {
+                var typeMapper = context.GetService<IRelationalTypeMapper>();
+
+                foreach (var property in context.Model.GetEntityTypes().SelectMany(e => e.GetDeclaredProperties()))
+                {
+                    var columnType = property.Relational().ColumnType;
+                    Assert.NotNull(columnType);
+
+                    if (property[RelationalAnnotationNames.ColumnType] == null)
+                    {
+                        Assert.Equal(
+                            columnType.ToLowerInvariant(),
+                            typeMapper.FindMapping(property).StoreType.ToLowerInvariant());
+                    }
+                }
+            }
+        }
     }
 }