fix: Harmonize db sequences for tracker [DHIS2-21378] (#24208)

* fix: Harmonize db sequences for tracker [DHIS2-21378]

* Fix relationshipitemid

Author: enricocolasante

dhis-2/dhis-services/dhis-service-core/src/main/resources/org/hisp/dhis/program/hibernate/SingleEvent.hbm.xml

@@ -8,7 +8,7 @@
 
     <id name="id" column="eventid">
       <generator class="sequence">
-        <param name="sequence_name">programstageinstance_sequence</param>
+        <param name="sequence_name">singleevent_sequence</param>
       </generator>
     </id>
 

dhis-2/dhis-services/dhis-service-core/src/main/resources/org/hisp/dhis/relationship/hibernate/Relationship.hbm.xml

@@ -13,7 +13,9 @@
              longer touches relationships via Hibernate. -->
 
         <id name="id" column="relationshipid">
-            <generator class="native"/>
+            <generator class="sequence">
+                <param name="sequence_name">relationship_sequence</param>
+            </generator>
         </id>
 
         &identifiableProperties;

dhis-2/dhis-services/dhis-service-core/src/main/resources/org/hisp/dhis/relationship/hibernate/RelationshipItem.hbm.xml

@@ -12,7 +12,9 @@
              items via Hibernate. -->
 
         <id name="id" column="relationshipitemid">
-            <generator class="native" />
+            <generator class="sequence">
+                <param name="sequence_name">relationshipitem_sequence</param>
+            </generator>
         </id>
 
         <many-to-one name="relationship" class="org.hisp.dhis.tracker.model.Relationship"

dhis-2/dhis-support/dhis-support-db-migration/src/main/resources/org/hisp/dhis/db/migration/2.44/V2_44_12__rename_tracker_sequences_to_match_table_names.sql

@@ -0,0 +1,22 @@
+-- DHIS2-21378: align tracker sequence names with the current table names and give
+-- relationship/relationshipitem their own sequences instead of the shared hibernate_sequence.
+
+-- Tables were renamed long ago (trackedentityinstance -> trackedentity,
+-- programinstance -> enrollment) but the sequences kept the legacy names.
+alter sequence if exists trackedentityinstance_sequence rename to trackedentity_sequence;
+alter sequence if exists programinstance_sequence rename to enrollment_sequence;
+
+-- After the event table split (V2_43_21) the SingleEvent Hibernate mapping kept drawing ids
+-- from the legacy programstageinstance_sequence while the JDBC import path used the canonical
+-- singleevent_sequence, so the two counters diverged. Resync the canonical sequence to the
+-- table's max id and drop the legacy sequence.
+select setval('singleevent_sequence', coalesce(max(eventid), 1)) from singleevent;
+drop sequence if exists programstageinstance_sequence;
+
+-- relationship and relationshipitem drew ids from the shared, global hibernate_sequence
+-- (<generator class="native"/>). Give them dedicated sequences, seeded from the current max ids.
+create sequence if not exists relationship_sequence;
+select setval('relationship_sequence', coalesce(max(relationshipid), 1)) from relationship;
+
+create sequence if not exists relationshipitem_sequence;
+select setval('relationshipitem_sequence', coalesce(max(relationshipitemid), 1)) from relationshipitem;

dhis-2/dhis-tracker/src/main/java/org/hisp/dhis/tracker/export/relationship/HibernateRelationshipStore.java

@@ -45,7 +45,6 @@
 import java.util.stream.Stream;
 import javax.annotation.Nonnull;
 import org.apache.commons.collections4.CollectionUtils;
-import org.hibernate.annotations.QueryHints;
 import org.hisp.dhis.common.IdentifiableObject;
 import org.hisp.dhis.common.SoftDeletableEntity;
 import org.hisp.dhis.common.SortDirection;
@@ -85,7 +84,12 @@ public HibernateRelationshipStore(
       JdbcTemplate jdbcTemplate,
       ApplicationEventPublisher publisher,
       AclService aclService) {
-    super(entityManager, jdbcTemplate, publisher, Relationship.class, aclService, true);
+    // cacheable=false: every query space this store reads (relationship, relationshipitem,
+    // trackedentity, enrollment, trackerevent, singleevent) is written via raw JDBC in the
+    // importer, which bypasses Hibernate's query-cache invalidation -- cached results would go
+    // stale across imports (e.g. an empty duplicate-check result would silently disable
+    // duplicate detection).
+    super(entityManager, jdbcTemplate, publisher, Relationship.class, aclService, false);
   }
 
   public Optional<TrackedEntity> findTrackedEntity(UID trackedEntity, boolean includeDeleted) {
@@ -176,14 +180,7 @@ public List<Relationship> getRelationshipsByRelationshipKeys(
         or (r.invertedKey in (:keys) and r.relationshipType.bidirectional = true))""";
     List<String> relationshipKeysAsString =
         relationshipKeys.stream().map(RelationshipKey::asString).toList();
-    // Query cache must be off here: the tracker importer writes relationships through JDBC, which
-    // bypasses Hibernate's query-cache invalidation. Leaving the cache on would let an earlier
-    // empty result for a key linger across imports and silently disable duplicate detection.
-    return getQuery(hql, Relationship.class)
-        .setParameter("keys", relationshipKeysAsString)
-        .setCacheable(false)
-        .setHint(QueryHints.CACHEABLE, false)
-        .list();
+    return getQuery(hql, Relationship.class).setParameter("keys", relationshipKeysAsString).list();
   }
 
   public List<RelationshipItem> getRelationshipItemsByTrackedEntity(

dhis-2/dhis-tracker/src/main/java/org/hisp/dhis/tracker/imports/bundle/persister/EnrollmentPersister.java

@@ -72,7 +72,7 @@ public EnrollmentPersister(
 
   @Override
   protected String sequenceName() {
-    return "programinstance_sequence";
+    return "enrollment_sequence";
   }
 
   @Override

dhis-2/dhis-tracker/src/main/java/org/hisp/dhis/tracker/imports/bundle/persister/EntityWriteBatch.java

@@ -71,13 +71,12 @@
  * <ul>
  *   <li>TrackedEntity inserts are flushed via a multi-row JDBC INSERT against {@code trackedentity}
  *       -- ids are pre-allocated by {@link AbstractTrackerPersister} from {@code
- *       trackedentityinstance_sequence} in one round-trip.
+ *       trackedentity_sequence} in one round-trip.
  *   <li>TrackedEntity updates are flushed via a single JDBC unnest UPDATE against {@code
  *       trackedentity}, writing only the columns mutated by {@code TrackerObjectsMapper.map} on the
  *       update branch.
  *   <li>Enrollment inserts are flushed via a multi-row JDBC INSERT against {@code enrollment} --
- *       ids are pre-allocated by {@link AbstractTrackerPersister} from {@code
- *       programinstance_sequence}.
+ *       ids are pre-allocated by {@link AbstractTrackerPersister} from {@code enrollment_sequence}.
  *   <li>Enrollment updates are flushed via a single JDBC unnest UPDATE against {@code enrollment},
  *       writing the columns mutated by {@code TrackerObjectsMapper.map} on the update branch.
  *   <li>TrackerEvent inserts are flushed via a multi-row JDBC INSERT against {@code trackerevent}
@@ -97,9 +96,9 @@
  *       {@code relationship} with {@code from/to_relationshipitemid} left NULL, a multi-row INSERT
  *       into {@code relationshipitem} for the (from + to) items, and an unnest UPDATE on {@code
  *       relationship} to set the from/to FKs. The three-step shape breaks the circular FK between
- *       the two tables, which is not deferrable in the live schema. Both tables use the shared
- *       {@code hibernate_sequence}. Relationship is INSERT-only -- the persister rejects UPDATE
- *       strategy upstream.
+ *       the two tables, which is not deferrable in the live schema. Ids come from {@code
+ *       relationship_sequence} and {@code relationshipitem_sequence}. Relationship is INSERT-only
+ *       -- the persister rejects UPDATE strategy upstream.
  *   <li>TrackedEntityAttributeValues are flushed via JDBC against {@code
  *       trackedentityattributevalue} -- a multi-row INSERT, a single unnest UPDATE keyed on the
  *       composite ({@code trackedentityid}, {@code trackedentityattributeid}) PK, and a single
@@ -384,9 +383,8 @@ class EntityWriteBatch {
   private static final String SINGLE_EVENT_NOTES_INSERT_ROW = "(?, ?, ?)";
 
   // Relationship is INSERT-only in tracker imports (RelationshipPersister.convert returns null on
-  // UPDATE strategy). Both relationship and relationshipitem use `hibernate_sequence` (no
-  // dedicated sequence was provisioned in any Flyway migration -- the hbm.xml `<generator
-  // class="native"/>` resolves to the shared global counter).
+  // UPDATE strategy). Relationship ids come from `relationship_sequence`, item ids from
+  // `relationshipitem_sequence`.
   //
   // The two tables form a circular FK (relationship.from/to_relationshipitemid <->
   // relationshipitem.relationshipid) with non-deferrable constraints. We break the cycle by
@@ -1409,15 +1407,15 @@ private int bindRelationshipRow(PreparedStatement ps, int p, Relationship r) thr
 
   /**
    * Inserts the {@code relationshipitem} rows. Each Relationship has exactly two items (from + to);
-   * we allocate {@code 2 * relationships.size()} ids from {@code hibernate_sequence} in one
+   * we allocate {@code 2 * relationships.size()} ids from {@code relationshipitem_sequence} in one
    * round-trip, assign them to the in-memory items (so the subsequent unnest UPDATE can read them
    * back), then flatten the from/to items into a single multi-row INSERT.
    */
   private void insertRelationshipItems(Connection conn) throws SQLException {
     if (relationshipInserts.isEmpty()) {
       return;
     }
-    long[] itemIds = allocateIds(conn, "hibernate_sequence", 2 * relationshipInserts.size());
+    long[] itemIds = allocateIds(conn, "relationshipitem_sequence", 2 * relationshipInserts.size());
     int cursor = 0;
     for (Relationship r : relationshipInserts) {
       r.getFrom().setId((int) itemIds[cursor++]);

dhis-2/dhis-tracker/src/main/java/org/hisp/dhis/tracker/imports/bundle/persister/RelationshipPersister.java

@@ -63,12 +63,9 @@ public RelationshipPersister(
 
   @Override
   protected String sequenceName() {
-    // Shared with every other entity that uses Hibernate's `<generator class="native"/>`. No
-    // dedicated relationship_sequence was provisioned in any Flyway migration. The 2
-    // RelationshipItem
-    // ids per Relationship are allocated separately inside
-    // EntityWriteBatch.insertRelationshipItems.
-    return "hibernate_sequence";
+    // The 2 RelationshipItem ids per Relationship are allocated separately from
+    // relationshipitem_sequence inside EntityWriteBatch.insertRelationshipItems.
+    return "relationship_sequence";
   }
 
   @Override

dhis-2/dhis-tracker/src/main/java/org/hisp/dhis/tracker/imports/bundle/persister/TrackedEntityPersister.java

@@ -64,7 +64,7 @@ public TrackedEntityPersister(
 
   @Override
   protected String sequenceName() {
-    return "trackedentityinstance_sequence";
+    return "trackedentity_sequence";
   }
 
   @Override

dhis-2/dhis-tracker/src/main/java/org/hisp/dhis/tracker/model/Enrollment.java

@@ -92,10 +92,10 @@ public class Enrollment extends BaseTrackerObject
 
   @Id
   @Column(name = "enrollmentid")
-  @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "programinstance_sequence")
+  @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "enrollment_sequence")
   @SequenceGenerator(
-      name = "programinstance_sequence",
-      sequenceName = "programinstance_sequence",
+      name = "enrollment_sequence",
+      sequenceName = "enrollment_sequence",
       allocationSize = 1)
   private long id;