feat(omdb): R6 — field.float emits REAL (Real4); field.double stays DOUBLE

Adds a distinct SqlType.Real4 record (float4, single precision) to the sealed
SqlType interface so field.float maps to SQL REAL, separate from field.double
(float8) -> DOUBLE/DOUBLE PRECISION. Mirrors the committed TS/C#/Python R6 ports.

- SqlType: new Real4 record in the permits clause (exhaustive-switch enforced).
- JdbcSqlTypes.fromJdbc: Types.FLOAT/REAL -> Real4, Types.DOUBLE -> Real. This is
  the single shared mapping point, so the expected-schema and DB-introspection
  paths agree (no phantom ALTER COLUMN round-trip).
- Postgres pgType / Derby derbyType: new Real4 -> "REAL" arms.
- codegen-spring SpringTypeMapper: FloatField -> Float, DecimalField -> BigDecimal
  DTO arms (previously fell through to the unmapped-type throw).
- integration-tests Normalization: canonicalFloat stringifies REAL/DOUBLE on the
  wire and fails loudly on out-of-band (exponential) values; mirrors normalization.ts.
- Tests: SqlType Real4 equality/widening, fromJdbc split, per-dialect REAL vs
  DOUBLE rendering, and the canonicalFloat in-band/strip/throw cases.

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

Author: dmealing

server/java/codegen-spring/src/main/java/com/metaobjects/generator/spring/SpringTypeMapper.java

@@ -3,8 +3,10 @@
 import com.metaobjects.field.BooleanField;
 import com.metaobjects.field.CurrencyField;
 import com.metaobjects.field.DateField;
+import com.metaobjects.field.DecimalField;
 import com.metaobjects.field.DoubleField;
 import com.metaobjects.field.EnumField;
+import com.metaobjects.field.FloatField;
 import com.metaobjects.field.IntegerField;
 import com.metaobjects.field.LongField;
 import com.metaobjects.field.MetaField;
@@ -65,6 +67,8 @@ public static String javaTypeName(MetaField<?> field) {
         if (field instanceof IntegerField) return "Integer";
         if (field instanceof LongField) return "Long";
         if (field instanceof DoubleField) return "Double";
+        if (field instanceof FloatField) return "Float";
+        if (field instanceof DecimalField) return "java.math.BigDecimal";
         if (field instanceof BooleanField) return "Boolean";
         if (field instanceof DateField) return "java.time.LocalDate";
         if (field instanceof TimestampField) return "java.time.Instant";

server/java/integration-tests/src/test/java/com/metaobjects/integration/Normalization.java

@@ -48,8 +48,8 @@ public static Object normalizeValue(Object v) {
         if (v instanceof Integer i)return i;
         if (v instanceof Short s)  return (int) s;
         if (v instanceof Byte b)   return (int) b;
-        if (v instanceof Float f)  return (double) f;
-        if (v instanceof Double d) return d;
+        if (v instanceof Float f)  return canonicalFloat(f);
+        if (v instanceof Double d) return canonicalFloat(d);
         if (v instanceof BigDecimal bd) return canonicalDecimal(bd);
         if (v instanceof UUID u)   return u.toString().toLowerCase(java.util.Locale.ROOT);
         if (v instanceof byte[] bytes) return Base64.getEncoder().encodeToString(bytes);
@@ -74,6 +74,23 @@ public static Object normalizeValue(Object v) {
         return v.toString();
     }
 
+    /** REAL → canonical plain-decimal string, formatted from the single (no widening tail). */
+    private static String canonicalFloat(float f)  { return canonicalFloatStr(Float.toString(f), f); }
+    /** DOUBLE → canonical plain-decimal string. */
+    private static String canonicalFloat(double d) { return canonicalFloatStr(Double.toString(d), d); }
+    private static String canonicalFloatStr(String s, Object v) {
+        if (s.indexOf('E') >= 0 || s.indexOf('e') >= 0) {
+            throw new IllegalArgumentException(
+                "canonicalFloat: " + v + " 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.replaceAll("0+$", "");
+        if (s.endsWith(".")) s = s.substring(0, s.length() - 1);
+        return s;
+    }
+
     /** NUMERIC/DECIMAL → canonical string: strip trailing zeros + the decimal point if integral. */
     private static String canonicalDecimal(BigDecimal d) {
         String s = d.stripTrailingZeros().toPlainString();

server/java/integration-tests/src/test/java/com/metaobjects/integration/NormalizationFloatTest.java

@@ -0,0 +1,31 @@
+package com.metaobjects.integration;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+/**
+ * R6: REAL/DOUBLE wire normalization (mirror of the TS {@code normalization.test.ts} cases).
+ * {@link Normalization#normalizeValue} routes Float/Double through the canonical-float
+ * stringifier: in-band values become plain-decimal strings (trailing zeros + bare decimal
+ * point stripped); out-of-band (exponential) values fail loudly so a bad fixture surfaces
+ * immediately instead of silently corrupting the cross-port byte-equality compare.
+ */
+class NormalizationFloatTest {
+    @Test void inBandFloat_isPlainDecimalString() {
+        assertEquals("1.5", Normalization.normalizeValue(1.5f));   // REAL (float4)
+        assertEquals("0.25", Normalization.normalizeValue(0.25d)); // DOUBLE (float8)
+    }
+    @Test void integerValuedDouble_stripsTrailingZeroAndPoint() {
+        assertEquals("2", Normalization.normalizeValue(2.0d)); // "2.0" -> "2." -> "2"
+    }
+    @Test void outOfBandDouble_throws() {
+        assertThrows(IllegalArgumentException.class,
+            () -> Normalization.normalizeValue(1.0e-10d)); // Double.toString -> "1.0E-10"
+    }
+    @Test void outOfBandFloat_throws() {
+        assertThrows(IllegalArgumentException.class,
+            () -> Normalization.normalizeValue(1.0e-10f)); // Float.toString -> "1.0E-10"
+    }
+}

server/java/omdb/src/main/java/com/metaobjects/manager/db/driver/DerbyDriver.java

@@ -357,6 +357,7 @@ String derbyType(SqlType t) {
             case SqlType.Bool b      -> "BOOLEAN";
             case SqlType.Timestamp ts -> "TIMESTAMP";
             case SqlType.Real r      -> "DOUBLE";
+            case SqlType.Real4 r     -> "REAL";
             case SqlType.Numeric n   -> "NUMERIC";
             case SqlType.Json j      -> "VARCHAR(32700)";
             case SqlType.Date d      -> "DATE";

server/java/omdb/src/main/java/com/metaobjects/manager/db/driver/PostgresDriver.java

@@ -370,6 +370,7 @@ String pgType(SqlType t) {
             // gratuitously promoted to TIMESTAMPTZ (matches TS/C# behavior).
             case SqlType.Timestamp ts -> ts.withTimezone() ? "TIMESTAMP WITH TIME ZONE" : "TIMESTAMP";
             case SqlType.Real r      -> "DOUBLE PRECISION";
+            case SqlType.Real4 r     -> "REAL";
             case SqlType.Numeric n   -> "NUMERIC";
             case SqlType.Json j      -> "JSONB";
             case SqlType.Date d      -> "DATE";

server/java/omdb/src/main/java/com/metaobjects/manager/db/migrate/JdbcSqlTypes.java

@@ -23,7 +23,12 @@ public static SqlType fromJdbc(int jdbcType, int length) {
                 return new SqlType.Int(64);
             case Types.FLOAT:
             case Types.REAL:
+                // float4 / single precision — field.float. Postgres reports a REAL column as
+                // Types.REAL and SimpleMappingHandlerDB maps FloatField -> Types.FLOAT, so both
+                // the expected-snapshot and introspection paths land on Real4 (stable round-trip).
+                return new SqlType.Real4();
             case Types.DOUBLE:
+                // float8 / double precision — field.double.
                 return new SqlType.Real();
             case Types.NUMERIC:
             case Types.DECIMAL:

server/java/omdb/src/main/java/com/metaobjects/manager/db/migrate/SqlType.java

@@ -9,7 +9,7 @@
  * Per spec §5.2.
  */
 public sealed interface SqlType
-        permits SqlType.Text, SqlType.Int, SqlType.Real, SqlType.Numeric, SqlType.Bool,
+        permits SqlType.Text, SqlType.Int, SqlType.Real, SqlType.Real4, SqlType.Numeric, SqlType.Bool,
                 SqlType.Timestamp, SqlType.Date, SqlType.Json, SqlType.Blob, SqlType.Uuid {
 
     /** maxLength == null means unbounded (TEXT). */
@@ -18,8 +18,12 @@ record Text(Integer maxLength) implements SqlType {}
     /** bits: 32 (INTEGER) or 64 (BIGINT). Named Int to avoid shadowing java.lang.Integer. */
     record Int(int bits) implements SqlType {}
 
+    /** DOUBLE PRECISION (float8, double precision) — field.double. */
     record Real() implements SqlType {}
 
+    /** REAL (float4, single precision) — field.float. */
+    record Real4() implements SqlType {}
+
     record Numeric(Integer precision, Integer scale) implements SqlType {}
 
     record Bool() implements SqlType {}
@@ -65,7 +69,7 @@ static boolean isWidening(SqlType from, SqlType to) {
             return tp >= fp && ts == fs && (tp - ts) >= (fp - fs);
         }
 
-        // Real/Bool/Date/Json/Blob/Uuid/Timestamp: any same-kind difference is not widening
+        // Real/Real4/Bool/Date/Json/Blob/Uuid/Timestamp: any same-kind difference is not widening
         return false;
     }
 }

server/java/omdb/src/test/java/com/metaobjects/manager/db/driver/DriverFloatTypeTest.java

@@ -0,0 +1,23 @@
+package com.metaobjects.manager.db.driver;
+
+import com.metaobjects.manager.db.migrate.SqlType;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * R6: REAL (float4, field.float) renders distinctly from DOUBLE (float8, field.double)
+ * per dialect. Guards against the two arms collapsing back to a single floating type.
+ */
+public class DriverFloatTypeTest {
+    @Test public void postgres_real4_is_REAL_and_real_is_DOUBLE_PRECISION() {
+        PostgresDriver pg = new PostgresDriver();
+        assertEquals("REAL", pg.pgType(new SqlType.Real4()));
+        assertEquals("DOUBLE PRECISION", pg.pgType(new SqlType.Real()));
+    }
+    @Test public void derby_real4_is_REAL_and_real_is_DOUBLE() {
+        DerbyDriver derby = new DerbyDriver();
+        assertEquals("REAL", derby.derbyType(new SqlType.Real4()));
+        assertEquals("DOUBLE", derby.derbyType(new SqlType.Real()));
+    }
+}

server/java/omdb/src/test/java/com/metaobjects/manager/db/migrate/JdbcSqlTypesTest.java

@@ -0,0 +1,22 @@
+package com.metaobjects.manager.db.migrate;
+
+import org.junit.Test;
+
+import java.sql.Types;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * R6: java.sql.Types FLOAT/REAL route to {@link SqlType.Real4} (float4, single precision);
+ * DOUBLE routes to {@link SqlType.Real} (float8). This single mapping point is shared by both
+ * the expected-snapshot builder and the DB introspector, so the split round-trips cleanly.
+ */
+public class JdbcSqlTypesTest {
+    @Test public void floatAndReal_mapToReal4() {
+        assertEquals(new SqlType.Real4(), JdbcSqlTypes.fromJdbc(Types.FLOAT, 0));
+        assertEquals(new SqlType.Real4(), JdbcSqlTypes.fromJdbc(Types.REAL, 0));
+    }
+    @Test public void double_mapsToReal() {
+        assertEquals(new SqlType.Real(), JdbcSqlTypes.fromJdbc(Types.DOUBLE, 0));
+    }
+}

server/java/omdb/src/test/java/com/metaobjects/manager/db/migrate/SqlTypeTest.java

@@ -25,4 +25,14 @@ public class SqlTypeTest {
         assertFalse(SqlType.isWidening(new Int(32), new Text(120))); // cross-kind: lossy
         assertFalse(SqlType.isWidening(new Text(120), new Text(120))); // identical
     }
+    // R6: REAL (float4, single precision) is a distinct kind from DOUBLE (float8).
+    @Test public void real4_equals_real4_and_differs_from_real() {
+        assertEquals(new Real4(), new Real4());
+        assertNotEquals(new Real(), new Real4()); // float4 != float8
+    }
+    @Test public void float_kinds_are_never_widening() {
+        assertFalse(SqlType.isWidening(new Real4(), new Real())); // single -> double: not auto-widened
+        assertFalse(SqlType.isWidening(new Real(), new Real4())); // double -> single: narrowing
+        assertFalse(SqlType.isWidening(new Real4(), new Real4())); // identical
+    }
 }