feat(csharp-migrate): R6 — field.float emits REAL; stringify REAL/DOUBLE on the wire

Add SqlType.Real4 (REAL / float4) distinct from SqlType.Real (DOUBLE PRECISION /
float8). Route field.float → Real4 and field.double → Real in ExpectedSchema.
Split PostgresIntrospect so float4/real → Real4 and float8/double precision → Real.
PostgresEmit renders Real4 as REAL. Normalization.CanonicalFloat stringifies
REAL and DOUBLE values as plain-decimal strings (throws on exponential notation),
matching the normalization.md contract and the TS reference port.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: dmealing

server/csharp/MetaObjects.Codegen.Tests/Migrate/PostgresEmitTests.cs

@@ -125,6 +125,7 @@ public void PgType_renders_each_kind()
         Assert.Contains("VARCHAR(50)", T(new SqlType.Text(50)));
         Assert.Contains("INTEGER;", T(new SqlType.Integer(32)));
         Assert.Contains("DOUBLE PRECISION", T(new SqlType.Real()));
+        Assert.Contains("REAL;", T(new SqlType.Real4()));
         Assert.Contains("NUMERIC(10,2)", T(new SqlType.Numeric(10, 2)));
         Assert.Contains("NUMERIC(8)", T(new SqlType.Numeric(8)));
         Assert.Contains("NUMERIC;", T(new SqlType.Numeric()));

server/csharp/MetaObjects.Codegen.Tests/Migrate/PostgresIntrospectTests.cs

@@ -65,9 +65,15 @@ public void PgTypeToSqlType_integers(string dataType, int bits)
     [Theory]
     [InlineData("real")]
     [InlineData("float4")]
+    public void PgTypeToSqlType_float4_maps_to_real4(string dataType)
+    {
+        Assert.Equal(new SqlType.Real4(), PostgresIntrospect.PgTypeToSqlType(dataType));
+    }
+
+    [Theory]
     [InlineData("double precision")]
     [InlineData("float8")]
-    public void PgTypeToSqlType_real(string dataType)
+    public void PgTypeToSqlType_float8_maps_to_real(string dataType)
     {
         Assert.Equal(new SqlType.Real(), PostgresIntrospect.PgTypeToSqlType(dataType));
     }

server/csharp/MetaObjects.Codegen.Tests/Migrate/SqlTypeTests.cs

@@ -14,6 +14,8 @@ public void Record_equality_is_structural()
         Assert.Equal(new SqlType.Integer(64), new SqlType.Integer(64));
         Assert.NotEqual<SqlType>(new SqlType.Integer(32), new SqlType.Integer(64));
         Assert.Equal<SqlType>(new SqlType.Real(), new SqlType.Real());
+        Assert.Equal<SqlType>(new SqlType.Real4(), new SqlType.Real4());
+        Assert.NotEqual<SqlType>(new SqlType.Real(), new SqlType.Real4());  // float8 ≠ float4
         Assert.NotEqual<SqlType>(new SqlType.Timestamp(true), new SqlType.Timestamp(false));
         Assert.NotEqual<SqlType>(new SqlType.Integer(32), new SqlType.Real());
     }

server/csharp/MetaObjects.Codegen/Migrate/ExpectedSchema.cs

@@ -140,7 +140,8 @@ private static ColumnDescriptor BuildColumn(
         FIELD_SUBTYPE_STRING or FIELD_SUBTYPE_CLASS => new SqlType.Text(f.MaxLength),
         FIELD_SUBTYPE_INT or FIELD_SUBTYPE_SHORT or FIELD_SUBTYPE_BYTE => new SqlType.Integer(32),
         FIELD_SUBTYPE_LONG or FIELD_SUBTYPE_CURRENCY => new SqlType.Integer(64),
-        FIELD_SUBTYPE_DOUBLE or FIELD_SUBTYPE_FLOAT => new SqlType.Real(),
+        FIELD_SUBTYPE_DOUBLE => new SqlType.Real(),
+        FIELD_SUBTYPE_FLOAT => new SqlType.Real4(),
         FIELD_SUBTYPE_DECIMAL => new SqlType.Numeric(f.Precision, f.Scale),
         // enum is string-backed → SqlType.Text (PostgresEmit renders as TEXT).
         // The DB-side CHECK constraint enforcing membership is tail-appended by

server/csharp/MetaObjects.Codegen/Migrate/PostgresEmit.cs

@@ -115,6 +115,7 @@ private static string RenderColumn(ColumnDescriptor c)
         SqlType.Text x => x.MaxLength is { } n ? $"VARCHAR({n})" : "TEXT",
         SqlType.Integer x => x.Bits == 64 ? "BIGINT" : "INTEGER",
         SqlType.Real => "DOUBLE PRECISION",
+        SqlType.Real4 => "REAL",
         SqlType.Numeric x => x switch
         {
             { Precision: { } p, Scale: { } s } => $"NUMERIC({p},{s})",

server/csharp/MetaObjects.Codegen/Migrate/PostgresIntrospect.cs

@@ -90,7 +90,8 @@ public static SqlType PgTypeToSqlType(string dataType, long? maxLength = null)
               or "int2" or "smallint" or "smallserial")
             return new SqlType.Integer(32);
 
-        if (dt is "float4" or "real" or "float8" or "double precision") return new SqlType.Real();
+        if (dt is "float4" or "real") return new SqlType.Real4();
+        if (dt is "float8" or "double precision") return new SqlType.Real();
 
         var num = NumericInline.Match(dt);
         if (num.Success)

server/csharp/MetaObjects.Codegen/Migrate/SqlType.cs

@@ -19,7 +19,8 @@ public abstract record SqlType
 {
     public sealed record Text(long? MaxLength = null) : SqlType;
     public sealed record Integer(int Bits) : SqlType;          // 32 | 64
-    public sealed record Real : SqlType;
+    public sealed record Real : SqlType;     // DOUBLE PRECISION (float8) — field.double
+    public sealed record Real4 : SqlType;    // REAL (float4) — field.float
     public sealed record Numeric(long? Precision = null, long? Scale = null) : SqlType;
     public sealed record Boolean : SqlType;
     public sealed record Timestamp(bool WithTimezone) : SqlType;

server/csharp/MetaObjects.IntegrationTests/Runner/Normalization.cs

@@ -36,9 +36,9 @@ public static class Normalization
         long l => l.ToString(CultureInfo.InvariantCulture),
         int i => i,
         short s => (int)s,
-        // Floating
-        float f => (double)f,
-        double d => d,
+        // REAL/DOUBLE → canonical plain-decimal string (format from the native type).
+        float f => CanonicalFloat((double)f),
+        double d => CanonicalFloat(d),
         // NUMERIC / DECIMAL — canonical decimal string, no trailing zeros.
         decimal dec => CanonicalDecimal(dec),
         // Strings already canonical.
@@ -71,6 +71,20 @@ private static string CanonicalDecimal(decimal d)
         return s;
     }
 
+    private static string CanonicalFloat(double d)
+    {
+        var s = d.ToString(CultureInfo.InvariantCulture);
+        if (s.Contains('E') || s.Contains('e'))
+            throw new FormatException(
+                $"CanonicalFloat: {d} is outside the plain-decimal band (exponential notation); " +
+                "REAL/DOUBLE fixture values must be in-band dyadic rationals — " +
+                "see fixtures/persistence-conformance/normalization.md");
+        if (!s.Contains('.')) return s;
+        s = s.TrimEnd('0');
+        if (s.EndsWith('.')) s = s[..^1];
+        return s;
+    }
+
     // TIMESTAMP (no TZ) → "YYYY-MM-DDTHH:MM:SS[.fff]" with no trailing zeros and no Z.
     // TIMESTAMPTZ comes via DateTimeOffset above and gets a Z; the bare DateTime
     // branch never appends one.