Backend: close the gaps found porting BuildCloud (#6153)

.github/workflows/parparvm-tests.yml

@@ -47,6 +47,8 @@ on:
       - 'CodenameOne/src/com/codename1/realtime/**'
       - 'CodenameOne/src/com/codename1/qrcode/QrCode.java'
       - 'CodenameOne/src/com/codename1/impl/MdnsEngine.java'
+      - 'CodenameOne/src/com/codename1/util/regex/**'
+      - 'CodenameOne/src/com/codename1/xml/**'
       - 'CodenameOne/src/com/codename1/orm/session/**'
       - 'CodenameOne/src/com/codename1/orm/repository/**'
       - 'CodenameOne/src/com/codename1/annotations/db/**'
@@ -134,6 +136,8 @@ on:
       - 'CodenameOne/src/com/codename1/realtime/**'
       - 'CodenameOne/src/com/codename1/qrcode/QrCode.java'
       - 'CodenameOne/src/com/codename1/impl/MdnsEngine.java'
+      - 'CodenameOne/src/com/codename1/util/regex/**'
+      - 'CodenameOne/src/com/codename1/xml/**'
       - 'CodenameOne/src/com/codename1/orm/session/**'
       - 'CodenameOne/src/com/codename1/orm/repository/**'
       - 'CodenameOne/src/com/codename1/annotations/db/**'

CodenameOne/src/com/codename1/annotations/Column.java

@@ -58,4 +58,28 @@
     /// engine spells differently (`TEXT`/`VARCHAR`, `REAL`/`DOUBLE PRECISION`,
     /// `BLOB`/`BYTEA`).
     String type() default "";
+    /// When false the column is left out of every `INSERT` the ORM writes, so the
+    /// row starts with the column's database default. The field's value at
+    /// insert time is ignored, not written.
+    boolean insertable() default true;
+    /// When false the column is left out of every `UPDATE` the ORM writes for a
+    /// changed entity, so a save never overwrites it. The column can still be
+    /// written by a query of the application's own -- a `@Modifying @Query` that
+    /// claims a row with a compare-and-swap, for example -- which is what makes
+    /// `insertable = false, updatable = false` a column only that statement owns.
+    /// A change made to the field alone is ignored: it neither writes the column
+    /// nor marks the entity dirty.
+    boolean updatable() default true;
+    /// The collation of the column, appended to its DDL as `COLLATE <name>`
+    /// (quoted on PostgreSQL), and the one the schema report then holds an
+    /// existing column to instead of requiring a case-sensitive key collation.
+    /// Letters, digits and underscores only, as `utf8mb4_0900_ai_ci` on MySQL,
+    /// `NOCASE` on SQLite or a collation created on PostgreSQL.
+    ///
+    /// A case-insensitive collation on a key makes the database treat `"A"` and
+    /// `"a"` as one key. The session's identity cache still compares ids with
+    /// `String.equals`, so look an entity up by the spelling it is stored with:
+    /// another one finds the row but loads a second instance of it. Hibernate
+    /// has the same caveat.
+    String collation() default "";
 }

CodenameOne/src/com/codename1/annotations/db/ElementCollection.java

@@ -33,6 +33,16 @@
     /// Names the scalar value column in the collection table.
     /// @return column name; element_value by default
     String column() default "element_value";
+    /// Names the column that holds the owner's id in the collection table.
+    /// Empty keeps `JoinTable.joinColumn` when that is set and `owner_id`
+    /// otherwise; naming the column in both places is a build error.
+    /// @return owner column name; empty for the default
+    String joinColumn() default "";
+    /// The SQL type of the value column, written into `CREATE TABLE` as it
+    /// is, like `Column.type` -- for example `LONGTEXT` -- and validated against
+    /// the existing column the same way.
+    /// @return SQL type; empty for the dialect's type for the element class
+    String type() default "";
     /// Names the column that stores each element's position, which keys the
     /// table together with the owner and keeps a List's order and duplicates.
     ///

CodenameOne/src/com/codename1/annotations/db/Lob.java

@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2026, Codename One and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Codename One designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Codename One through http://www.codenameone.com/ if you
+ * need additional information or have any questions.
+ */
+package com.codename1.annotations.db;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/// Marks a `String`, `char[]` or `byte[]` field as a large object, as JPA's
+/// `@Lob` does.
+///
+/// It changes nothing about the column, because every string and byte column
+/// is already one: MySQL gets `LONGTEXT` and `LONGBLOB`, and SQLite and
+/// PostgreSQL leave `TEXT` and `BLOB`/`BYTEA` unbounded. It exists so an entity
+/// ported from JPA keeps the annotation, and the build rejects it on a field of
+/// any other type, as JPA would.
+@Retention(RetentionPolicy.CLASS)
+@Target(ElementType.FIELD)
+@com.codename1.impl.SharedWithBackend
+public @interface Lob {
+}

CodenameOne/src/com/codename1/annotations/db/Temporal.java

@@ -52,8 +52,12 @@
 ///   not change what is stored. A `TIMESTAMP WITH TIME ZONE` column is read with
 ///   the offset the server sends.
 /// - Precision is the **millisecond**, which is all a Date holds. A column with
-///   finer precision has the extra digits dropped on read; one with coarser
-///   precision rounds or truncates on write, as that engine does.
+///   finer precision has the extra digits dropped on read. A coarser column,
+///   such as a plain MySQL `DATETIME`, is accepted only when the field declares
+///   it, `@Column(type = "DATETIME")`: the declaration is the opt-in to losing
+///   the milliseconds. The engine then rounds or truncates on write, as it does
+///   for Hibernate, so on MySQL a value may read back one second later. MySQL's
+///   `TIMESTAMP` is still refused, since it ends in 2038.
 /// - On SQLite, which has no native date type, the value is text in the form
 ///   `2026-10-16 09:30:00.000`, which sorts in time order. Rows written in a
 ///   different textual form are read when they are ISO 8601, but compare as text

CodenameOne/src/com/codename1/impl/orm/Attribute.java

@@ -51,6 +51,14 @@ public final class Attribute {
     /// itself is TEXT storage through TemporalConverter; this picks the DDL type
     /// and what an existing column may be.
     public final int temporal;
+    /// False for `@Column(insertable = false)`: no INSERT names the column.
+    public final boolean insertable;
+    /// False for `@Column(updatable = false)`: no dirty-checking UPDATE names it.
+    public final boolean updatable;
+    /// Null, or the `@Column(collation)` name: the DDL appends it, and the
+    /// schema report holds the column to it instead of to a case-sensitive key
+    /// collation.
+    public final String collation;
     /// The kind that decides SQL semantics -- collation, LIKE, the text
     /// functions -- as opposed to [#kind], which decides how a value is bound and
     /// read. A `@Temporal` column exchanges text through its converter but is a
@@ -68,6 +76,19 @@ public Attribute(String field, String column, int kind, boolean id, boolean gene
     }
     public Attribute(String field, String column, int kind, boolean id, boolean generated, boolean nullable,
             boolean version, String declaredType, int temporal) {
+        this(field, column, kind, id, generated, nullable, version, declaredType, temporal, true, true);
+    }
+    public Attribute(String field, String column, int kind, boolean id, boolean generated, boolean nullable,
+            boolean version, String declaredType, int temporal, boolean insertable, boolean updatable) {
+        this(field, column, kind, id, generated, nullable, version, declaredType, temporal, insertable, updatable,
+                null);
+    }
+    public Attribute(String field, String column, int kind, boolean id, boolean generated, boolean nullable,
+            boolean version, String declaredType, int temporal, boolean insertable, boolean updatable,
+            String collation) {
+        this.collation = collation == null || collation.length() == 0 ? null : collation;
+        this.insertable = insertable;
+        this.updatable = updatable;
         this.temporal = temporal;
         this.declaredType = declaredType;
         this.field = field;

CodenameOne/src/com/codename1/impl/orm/Relationship.java

@@ -42,6 +42,8 @@ public final class Relationship {
     public final boolean orphanRemoval;
     public final boolean unique;
     public final boolean element;
+    /// The SQL type an element collection declares for its value column, empty for the default.
+    public final String elementType;
     public final int column;
     public final int cascade;
     public static final int PERSIST = 1;
@@ -69,7 +71,14 @@ public Relationship(String field, Class target, boolean many, boolean lazy, int
     public Relationship(String field, Class target, boolean many, boolean lazy, int column, String mappedBy,
             String joinTable, String joinColumn, String inverseJoinColumn, int cascade, boolean orphanRemoval,
             boolean unique, String mapKey, String orderColumn, String orderBy, boolean element) {
+        this(field, target, many, lazy, column, mappedBy, joinTable, joinColumn, inverseJoinColumn, cascade,
+                orphanRemoval, unique, mapKey, orderColumn, orderBy, element, "");
+    }
+    public Relationship(String field, Class target, boolean many, boolean lazy, int column, String mappedBy,
+            String joinTable, String joinColumn, String inverseJoinColumn, int cascade, boolean orphanRemoval,
+            boolean unique, String mapKey, String orderColumn, String orderBy, boolean element, String elementType) {
         this.element = element;
+        this.elementType = elementType == null ? "" : elementType;
         this.mapKey = mapKey;
         this.orderColumn = orderColumn;
         this.orderBy = orderBy;