Skip ALTER COLUMN for computed columns when only CLR type changes

The migration model differ produced an AlterColumnOperation when the CLR
type of a property mapped to a computed column changed (e.g. int → long
for a column with .HasComputedColumnSql("DATALENGTH(...)")). The
generated ALTER TABLE ... ALTER COLUMN then failed at runtime with
"Cannot alter column ... because it is 'COMPUTED'".

A computed column's store type and collation are derived from the
expression; they aren't user-configurable. CLR-type-only changes are
metadata on the EF side and require no database-side change.

Suppress columnTypeChanged and collationChanged when both source and
target are computed with the same ComputedColumnSql and IsStored.
Real changes — nullability, comment, order, annotations, and notably
expression changes — still flow through the existing path; the SQL
generator's drop+add path handles legitimate computed-column
modifications unchanged.

Fixes #33425

Author: m-x-shokhzod

src/EFCore.Relational/Migrations/Internal/MigrationsModelDiffer.cs

@@ -1065,7 +1065,20 @@ protected virtual IEnumerable<MigrationOperation> Diff(
         var targetMigrationsAnnotations = target.GetAnnotations();
 
         var isNullableChanged = source.IsNullable != target.IsNullable;
-        var columnTypeChanged = source.StoreType != target.StoreType;
+
+        // For computed columns whose expression and persistence are unchanged, the database column's
+        // type and collation are derived from the expression — they aren't user-configurable. CLR-type
+        // changes that recompute StoreType/Collation cannot (and need not) be applied via ALTER COLUMN;
+        // SQL Server rejects with "Cannot alter column ... because it is COMPUTED". When the expression
+        // itself changes, the SQL generator's existing drop+add path handles it. See #33425.
+        var isComputedWithUnchangedExpression =
+            source.ComputedColumnSql != null
+            && target.ComputedColumnSql != null
+            && MultilineEquals(source.ComputedColumnSql, target.ComputedColumnSql)
+            && source.IsStored == target.IsStored;
+
+        var columnTypeChanged = !isComputedWithUnchangedExpression && source.StoreType != target.StoreType;
+        var collationChanged = !isComputedWithUnchangedExpression && source.Collation != target.Collation;
 
         if (!source.TryGetDefaultValue(out var sourceDefault))
         {
@@ -1085,7 +1098,7 @@ protected virtual IEnumerable<MigrationOperation> Diff(
             || sourceDefault?.GetType() != targetDefault?.GetType()
             || (sourceDefault != DBNull.Value && !target.ProviderValueComparer.Equals(sourceDefault, targetDefault))
             || !MultilineEquals(source.Comment, target.Comment)
-            || source.Collation != target.Collation
+            || collationChanged
             || source.Order != target.Order
             || HasDifferences(sourceMigrationsAnnotations, targetMigrationsAnnotations))
         {

test/EFCore.Relational.Tests/Migrations/Internal/MigrationsModelDifferTest.cs

@@ -3025,6 +3025,66 @@ public void Alter_column_computed_expression()
                 Assert.Equal("CreateCatamountName()", operation.ComputedColumnSql);
             });
 
+    [ConditionalFact]
+    public void Computed_column_clr_type_change_alone_is_no_op()
+        => Execute(
+            source => source.Entity(
+                "FileData",
+                x =>
+                {
+                    x.ToTable("Files", "dbo");
+                    x.Property<int>("Id");
+                    x.Property<byte[]>("FileContents").IsRequired();
+                    // Initial: int CLR type → store type "int"
+                    x.Property<int>("FileSize").HasComputedColumnSql("DATALENGTH([FileContents])");
+                }),
+            target => target.Entity(
+                "FileData",
+                x =>
+                {
+                    x.ToTable("Files", "dbo");
+                    x.Property<int>("Id");
+                    x.Property<byte[]>("FileContents").IsRequired();
+                    // Changed: long CLR type → store type "bigint" (DATALENGTH actually returns bigint).
+                    // Computed column's store type is derived from the expression, not configurable;
+                    // the CLR-type-only change must NOT produce an AlterColumnOperation since
+                    // SQL Server rejects ALTER COLUMN on a computed column. See #33425.
+                    x.Property<long>("FileSize").HasComputedColumnSql("DATALENGTH([FileContents])");
+                }),
+            operations => Assert.Empty(operations));
+
+    [ConditionalFact]
+    public void Computed_column_expression_change_with_clr_type_change_still_alters()
+        => Execute(
+            source => source.Entity(
+                "FileData",
+                x =>
+                {
+                    x.ToTable("Files", "dbo");
+                    x.Property<int>("Id");
+                    x.Property<byte[]>("FileContents").IsRequired();
+                    x.Property<int>("FileSize").HasComputedColumnSql("DATALENGTH([FileContents])");
+                }),
+            target => target.Entity(
+                "FileData",
+                x =>
+                {
+                    x.ToTable("Files", "dbo");
+                    x.Property<int>("Id");
+                    x.Property<byte[]>("FileContents").IsRequired();
+                    // Both expression and CLR type changed — diff must still emit AlterColumnOperation
+                    // (provider's SQL generator turns it into drop+add for computed columns).
+                    x.Property<long>("FileSize").HasComputedColumnSql("LEN([FileContents])");
+                }),
+            operations =>
+            {
+                Assert.Equal(1, operations.Count);
+                var operation = Assert.IsType<AlterColumnOperation>(operations[0]);
+                Assert.Equal("FileSize", operation.Name);
+                Assert.Equal("LEN([FileContents])", operation.ComputedColumnSql);
+                Assert.Equal("DATALENGTH([FileContents])", operation.OldColumn.ComputedColumnSql);
+            });
+
     [ConditionalFact]
     public void Alter_column_comment()
         => Execute(