You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@grails.apache.org by bo...@apache.org on 2026/05/02 15:35:39 UTC

(grails-core) 10/14: fix(h7): fix all HibernateGormStaticApiSpec failures (68/68 pass)

This is an automated email from the ASF dual-hosted git repository.

borinquenkid pushed a commit to branch 8.0.x-hibernate7_gorm_enhance
in repository https://gitbox.apache.org/repos/asf/grails-core.git

commit 3ffbbba97a8f672bd1d94e5f3c9ae8c557cbbc7a
Author: Walter Duque de Estrada <wb...@mac.com>
AuthorDate: Fri May 1 23:23:26 2026 -0500

    fix(h7): fix all HibernateGormStaticApiSpec failures (68/68 pass)
    
    - Fix positional params: int i = 0 → int i = 1 (H7 uses 1-indexed ?1)
    - Add GString HQL support in executeQuery/find/findAll overloads
    - Add read() override with session.setReadOnly(entity, true)
    - Add load() override with convertIdentifier() + null guard
    - Add last() override injecting sort-by-id-desc when sort is absent
    - Add findAllWhere/findWhere null-map guard (return null when map is null)
    - Add convertIdentifier() helper using ConversionService
    - Add buildNamedParameterQueryFromGString() helper
    - Fix populateQueryByExample() to use MappingContext.createEntityAccess()
      directly (HibernateSession.getPersister() always returned null)
    - Fix find/findAll by example empty-criteria check: use query.allCriteria
      (calls HibernateQuery.getAllCriteria() → detachedCriteria) instead of
      query.criteria (base Query.Junction which is never populated by HibernateQuery)
    - Fix retrieveAll() in HibernateSession to preserve input order, return null
      for missing IDs, and handle duplicate IDs correctly
    - Add GormRegistry.reset() in test harness setup() to fix stale-cache bug
    
    Co-authored-by: borinquenkid <bo...@users.noreply.github.com>
    Co-authored-by: Copilot <22...@users.noreply.github.com>
---
 .../orm/hibernate/HibernateGormStaticApi.groovy    | 275 ++++++++++++++++++---
 .../org/grails/orm/hibernate/HibernateSession.java |  38 ++-
 .../core/GrailsDataHibernate7TckManager.groovy     |   5 +
 3 files changed, 272 insertions(+), 46 deletions(-)

diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/HibernateGormStaticApi.groovy b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/HibernateGormStaticApi.groovy
index a3ca25ac72..98b715d872 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/HibernateGormStaticApi.groovy
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/HibernateGormStaticApi.groovy
@@ -37,6 +37,7 @@ import org.grails.orm.hibernate.query.HibernateHqlQuery
 import org.hibernate.FlushMode
 import org.hibernate.query.QueryFlushMode
 import org.hibernate.SessionFactory
+import org.springframework.core.convert.ConversionService
 import org.springframework.transaction.support.TransactionSynchronizationManager
 import org.grails.datastore.gorm.DatastoreResolver
 import org.grails.datastore.gorm.finders.FinderMethod
@@ -130,9 +131,30 @@ class HibernateGormStaticApi<D> extends GormStaticApi<D> {
         }
     }
 
+    @Override
+    List executeQuery(CharSequence query, Map params) {
+        executeQuery(query, params, Collections.emptyMap())
+    }
+
+    @Override
+    List executeQuery(CharSequence query, Collection params) {
+        executeQuery(query, params, Collections.emptyMap())
+    }
+
     @Override
     List executeQuery(CharSequence query, Map params, Map args) {
         def template = getHibernateTemplate()
+        if (query instanceof GString) {
+            Map allParams = new LinkedHashMap(params ?: [:])
+            String hql = buildNamedParameterQueryFromGString((GString) query, allParams)
+            return (List) template.execute { org.hibernate.Session session ->
+                org.hibernate.query.Query q = session.createQuery(hql)
+                template.applySettings(q)
+                populateQueryArguments(q, args)
+                populateQueryWithNamedArguments(q, allParams)
+                new HibernateHqlQuery((HibernateSession)getDatastore().currentSession, getGormPersistentEntity(), q).list()
+            }
+        }
         return (List) template.execute { org.hibernate.Session session ->
             org.hibernate.query.Query q = session.createQuery(query.toString())
             template.applySettings(q)
@@ -144,13 +166,170 @@ class HibernateGormStaticApi<D> extends GormStaticApi<D> {
         }
     }
 
+    @Override
+    List executeQuery(CharSequence query) {
+        if (query instanceof GString) {
+            Map params = new LinkedHashMap()
+            String hql = buildNamedParameterQueryFromGString((GString) query, params)
+            return executeQuery(hql, params, Collections.emptyMap())
+        }
+        throw new UnsupportedOperationException('Use executeQuery(CharSequence, Map) or executeQuery(CharSequence, Collection) with parameters')
+    }
+
+    @Override
+    D find(CharSequence query, Map params, Map args) {
+        def template = getHibernateTemplate()
+        if (query instanceof GString) {
+            Map allParams = new LinkedHashMap(params ?: [:])
+            String hql = buildNamedParameterQueryFromGString((GString) query, allParams)
+            return (D) template.execute { org.hibernate.Session session ->
+                org.hibernate.query.Query q = session.createQuery(hql)
+                template.applySettings(q)
+                populateQueryArguments(q, args)
+                populateQueryWithNamedArguments(q, allParams)
+                q.setMaxResults(1)
+                List results = new HibernateHqlQuery((HibernateSession)getDatastore().currentSession, getGormPersistentEntity(), q).list()
+                return results ? results[0] : null
+            }
+        }
+        return (D) template.execute { org.hibernate.Session session ->
+            org.hibernate.query.Query q = session.createQuery(query.toString())
+            template.applySettings(q)
+            populateQueryArguments(q, params)
+            populateQueryArguments(q, args)
+            populateQueryWithNamedArguments(q, params)
+            q.setMaxResults(1)
+
+            List results = new HibernateHqlQuery((HibernateSession)getDatastore().currentSession, getGormPersistentEntity(), q).list()
+            return results ? results[0] : null
+        }
+    }
+
+    @Override
+    List<D> findAll(CharSequence query, Map params, Map args) {
+        def template = getHibernateTemplate()
+        if (query instanceof GString) {
+            Map allParams = new LinkedHashMap(params ?: [:])
+            String hql = buildNamedParameterQueryFromGString((GString) query, allParams)
+            return (List<D>) template.execute { org.hibernate.Session session ->
+                org.hibernate.query.Query q = session.createQuery(hql)
+                template.applySettings(q)
+                populateQueryArguments(q, args)
+                populateQueryWithNamedArguments(q, allParams)
+                new HibernateHqlQuery((HibernateSession)getDatastore().currentSession, getGormPersistentEntity(), q).list()
+            }
+        }
+        return (List<D>) template.execute { org.hibernate.Session session ->
+            org.hibernate.query.Query q = session.createQuery(query.toString())
+            template.applySettings(q)
+            populateQueryArguments(q, params)
+            populateQueryArguments(q, args)
+            populateQueryWithNamedArguments(q, params)
+
+            new HibernateHqlQuery((HibernateSession)getDatastore().currentSession, getGormPersistentEntity(), q).list()
+        }
+    }
+
+    @Override
+    @CompileDynamic
+    D read(Serializable id) {
+        if (id == null) return null
+        id = convertIdentifier(id)
+        if (id == null) return null
+        def template = getHibernateTemplate()
+        return (D) template.execute { org.hibernate.Session session ->
+            D entity = (D) session.get(persistentClass, id)
+            if (entity != null) {
+                session.setReadOnly(entity, true)
+            }
+            entity
+        }
+    }
+
+    @Override
+    @CompileDynamic
+    D load(Serializable id) {
+        if (id == null) return null
+        id = convertIdentifier(id)
+        if (id == null) return null
+        return (D) getHibernateTemplate().load(persistentClass, id)
+    }
+
+    @Override
+    @CompileDynamic
+    D last(Map params) {
+        PersistentEntity pe = getGormPersistentEntity()
+        Map p = new LinkedHashMap(params ?: [:])
+        if (!p.containsKey(DynamicFinder.ARGUMENT_SORT)) {
+            p.put(DynamicFinder.ARGUMENT_SORT, pe.identity.name)
+        }
+        if (!p.containsKey(DynamicFinder.ARGUMENT_ORDER)) {
+            p.put(DynamicFinder.ARGUMENT_ORDER, 'desc')
+        }
+        p.put(DynamicFinder.ARGUMENT_MAX, 1)
+        List<D> results = list(p)
+        results ? results.get(0) : null
+    }
+
+    @Override
+    @CompileDynamic
+    List<D> findAllWhere(Map queryMap, Map args) {
+        if (!queryMap) return null
+        super.findAllWhere(queryMap, args)
+    }
+
+    @Override
+    @CompileDynamic
+    D findWhere(Map queryMap, Map args) {
+        if (!queryMap) return null
+        super.findWhere(queryMap, args)
+    }
+
+    @CompileDynamic
+    protected Serializable convertIdentifier(Serializable id) {
+        try {
+            PersistentEntity pe = getGormPersistentEntity()
+            Class identityType = pe.identity.type
+            if (!identityType.isInstance(id)) {
+                ConversionService conversionService = pe.mappingContext.conversionService
+                if (conversionService.canConvert(id.class, identityType)) {
+                    return (Serializable) conversionService.convert(id, identityType)
+                }
+                return null
+            }
+            return id
+        }
+        catch (Throwable e) {
+            return null
+        }
+    }
+
+    @CompileDynamic
+    protected String buildNamedParameterQueryFromGString(GString query, Map params) {
+        StringBuilder hql = new StringBuilder()
+        int i = 0
+        Object[] values = query.values
+        String[] strings = query.getStrings()
+        for (String str in strings) {
+            hql.append(str)
+            if (i < values.length) {
+                String paramName = "p${i}"
+                hql.append(':').append(paramName)
+                params.put(paramName, values[i])
+                i++
+            }
+        }
+        return hql.toString()
+    }
+
+
     @Override
     List executeQuery(CharSequence query, Collection params, Map args) {
         def template = getHibernateTemplate()
         return (List) template.execute { org.hibernate.Session session ->
             org.hibernate.query.Query q = session.createQuery(query.toString())
             template.applySettings(q)
-            int i = 0
+            int i = 1
             for (param in params) {
                 q.setParameter(i++, param)
             }
@@ -160,6 +339,16 @@ class HibernateGormStaticApi<D> extends GormStaticApi<D> {
         }
     }
 
+    @Override
+    Integer executeUpdate(CharSequence query, Map params) {
+        executeUpdate(query, params, Collections.emptyMap())
+    }
+
+    @Override
+    Integer executeUpdate(CharSequence query, Collection params) {
+        executeUpdate(query, params, Collections.emptyMap())
+    }
+
     @Override
     Integer executeUpdate(CharSequence query, Map params, Map args) {
         def template = getHibernateTemplate()
@@ -180,7 +369,7 @@ class HibernateGormStaticApi<D> extends GormStaticApi<D> {
         return (Integer) template.execute { org.hibernate.Session session ->
             org.hibernate.query.Query q = session.createQuery(query.toString())
             template.applySettings(q)
-            int i = 0
+            int i = 1
             for (param in params) {
                 q.setParameter(i++, param)
             }
@@ -191,19 +380,18 @@ class HibernateGormStaticApi<D> extends GormStaticApi<D> {
     }
 
     @Override
-    D find(CharSequence query, Map params, Map args) {
-        def template = getHibernateTemplate()
-        return (D) template.execute { org.hibernate.Session session ->
-            org.hibernate.query.Query q = session.createQuery(query.toString())
-            template.applySettings(q)
-            populateQueryArguments(q, params)
-            populateQueryArguments(q, args)
-            populateQueryWithNamedArguments(q, params)
-            q.setMaxResults(1)
+    D find(CharSequence query) {
+        find(query, Collections.emptyMap(), Collections.emptyMap())
+    }
 
-            List results = new HibernateHqlQuery((HibernateSession)getDatastore().currentSession, getGormPersistentEntity(), q).list()
-            return results ? results[0] : null
-        }
+    @Override
+    D find(CharSequence query, Map params) {
+        find(query, params, Collections.emptyMap())
+    }
+
+    @Override
+    D find(CharSequence query, Collection params) {
+        find(query, params, Collections.emptyMap())
     }
 
     @Override
@@ -212,7 +400,7 @@ class HibernateGormStaticApi<D> extends GormStaticApi<D> {
         return (D) template.execute { org.hibernate.Session session ->
             org.hibernate.query.Query q = session.createQuery(query.toString())
             template.applySettings(q)
-            int i = 0
+            int i = 1
             for (param in params) {
                 q.setParameter(i++, param)
             }
@@ -225,17 +413,18 @@ class HibernateGormStaticApi<D> extends GormStaticApi<D> {
     }
 
     @Override
-    List<D> findAll(CharSequence query, Map params, Map args) {
-        def template = getHibernateTemplate()
-        return (List<D>) template.execute { org.hibernate.Session session ->
-            org.hibernate.query.Query q = session.createQuery(query.toString())
-            template.applySettings(q)
-            populateQueryArguments(q, params)
-            populateQueryArguments(q, args)
-            populateQueryWithNamedArguments(q, params)
+    List<D> findAll(CharSequence query) {
+        findAll(query, Collections.emptyMap(), Collections.emptyMap())
+    }
 
-            new HibernateHqlQuery((HibernateSession)getDatastore().currentSession, getGormPersistentEntity(), q).list()
-        }
+    @Override
+    List<D> findAll(CharSequence query, Map params) {
+        findAll(query, params, Collections.emptyMap())
+    }
+
+    @Override
+    List<D> findAll(CharSequence query, Collection params) {
+        findAll(query, params, Collections.emptyMap())
     }
 
     @Override
@@ -244,7 +433,7 @@ class HibernateGormStaticApi<D> extends GormStaticApi<D> {
         return (List<D>) template.execute { org.hibernate.Session session ->
             org.hibernate.query.Query q = session.createQuery(query.toString())
             template.applySettings(q)
-            int i = 0
+            int i = 1
             for (param in params) {
                 q.setParameter(i++, param)
             }
@@ -255,10 +444,14 @@ class HibernateGormStaticApi<D> extends GormStaticApi<D> {
     }
 
     @Override
+    @CompileDynamic
     List<D> findAll(D example, Map args) {
         execute({ Session session ->
             def query = session.createQuery(persistentClass)
             populateQueryByExample(session, query, example)
+            if (query.allCriteria.isEmpty()) {
+                return null
+            }
             Integer max = ClassUtils.getIntegerFromMap(DynamicFinder.ARGUMENT_MAX, args)
             Integer offset = ClassUtils.getIntegerFromMap(DynamicFinder.ARGUMENT_OFFSET, args)
             if (max != null) {
@@ -272,10 +465,14 @@ class HibernateGormStaticApi<D> extends GormStaticApi<D> {
     }
 
     @Override
+    @CompileDynamic
     D find(D example, Map args) {
         execute({ Session session ->
             def query = session.createQuery(persistentClass)
             populateQueryByExample(session, query, example)
+            if (query.allCriteria.isEmpty()) {
+                return null
+            }
             query.singleResult()
         } as SessionCallback<D>)
     }
@@ -283,21 +480,17 @@ class HibernateGormStaticApi<D> extends GormStaticApi<D> {
     protected void populateQueryByExample(Session session, Query query, D example) {
         PersistentEntity pe = getGormPersistentEntity()
         MappingContext mappingContext = pe.mappingContext
-        def p = session.getPersister(example)
-        if (p instanceof EntityPersister) {
-            EntityPersister persister = (EntityPersister) p
-            def id = persister.getObjectIdentifier(example)
-            if (id != null) {
-                query.add(Restrictions.eq(pe.identity.name, id))
-            }
-            else {
-                def ea = mappingContext.createEntityAccess(pe, example)
-                for (prop in pe.persistentProperties) {
-                    if (prop instanceof Simple || prop instanceof Basic) {
-                        def val = ea.getProperty(prop.name)
-                        if (val != null) {
-                            query.add(Restrictions.eq(prop.name, val))
-                        }
+        def ea = mappingContext.createEntityAccess(pe, example)
+        def id = ea.getIdentifier()
+        if (id != null) {
+            query.add(Restrictions.eq(pe.identity.name, id))
+        }
+        else {
+            for (prop in pe.persistentProperties) {
+                if (prop instanceof Simple || prop instanceof Basic) {
+                    def val = ea.getProperty(prop.name)
+                    if (val != null) {
+                        query.add(Restrictions.eq(prop.name, val))
                     }
                 }
             }
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/HibernateSession.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/HibernateSession.java
index 01dc72164f..4e9f0d3896 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/HibernateSession.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/HibernateSession.java
@@ -24,6 +24,7 @@ import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 
@@ -399,19 +400,31 @@ public class HibernateSession extends AbstractAttributeStoringSession implements
 
     @Override
     @SuppressWarnings({"PMD.DataflowAnomalyAnalysis"})
-    //TODO Cleanup
     public List retrieveAll(final Class type, final Iterable keys) {
         final GrailsHibernatePersistentEntity persistentEntity = (GrailsHibernatePersistentEntity) getMappingContext().getPersistentEntity(type.getName());
         final String entityName = persistentEntity.getName();
         final String idName = persistentEntity.getIdentity().getName();
+
+        // Collect input keys preserving order (including duplicates)
+        List<Object> inputKeys = new ArrayList<>();
+        for (Object k : keys) {
+            inputKeys.add(k);
+        }
+        if (inputKeys.isEmpty()) {
+            return Collections.emptyList();
+        }
+        // Determine the unique set of keys for the HQL IN query
+        Collection<Object> uniqueKeys = new LinkedHashMap<Object, Object>() {{
+            for (Object k : inputKeys) { put(k, k); }
+        }}.keySet();
+
         final String hql = "from " + entityName + " as e where e." + idName + " in (:keys)";
 
-        return getHibernateTemplate().execute(session -> {
-            // Prepare the HqlQueryContext using our manual HQL string and type override
+        Map<Object, Object> entityById = getHibernateTemplate().execute(session -> {
             HqlQueryContext queryContext = HqlQueryContext.prepare(
                 persistentEntity,
                 hql,
-                Map.of("keys", getIterableAsCollection(keys)),
+                Map.of("keys", uniqueKeys),
                 null,
                 null,
                 new HashMap<>(),
@@ -420,13 +433,28 @@ public class HibernateSession extends AbstractAttributeStoringSession implements
                 type
             );
 
-            return HibernateHqlQueryCreator.createHqlQuery(
+            List fetched = HibernateHqlQueryCreator.createHqlQuery(
                 (HibernateDatastore) getDatastore(),
                 getHibernateTemplate().getSessionFactory(),
                 persistentEntity,
                 queryContext
             ).list();
+
+            Map<Object, Object> byId = new LinkedHashMap<>();
+            org.hibernate.Session nativeSession = session;
+            for (Object entity : fetched) {
+                Object id = nativeSession.getIdentifier(entity);
+                byId.put(id, entity);
+            }
+            return byId;
         });
+
+        // Build result list in input order, with null for missing IDs
+        List<Object> result = new ArrayList<>(inputKeys.size());
+        for (Object k : inputKeys) {
+            result.add(entityById.get(k));
+        }
+        return result;
     }
 
     @Override
diff --git a/grails-data-hibernate7/core/src/test/groovy/org/apache/grails/data/hibernate7/core/GrailsDataHibernate7TckManager.groovy b/grails-data-hibernate7/core/src/test/groovy/org/apache/grails/data/hibernate7/core/GrailsDataHibernate7TckManager.groovy
index d19a45431b..0791573b4c 100644
--- a/grails-data-hibernate7/core/src/test/groovy/org/apache/grails/data/hibernate7/core/GrailsDataHibernate7TckManager.groovy
+++ b/grails-data-hibernate7/core/src/test/groovy/org/apache/grails/data/hibernate7/core/GrailsDataHibernate7TckManager.groovy
@@ -60,6 +60,11 @@ class GrailsDataHibernate7TckManager extends GrailsDataTckManager {
     @Override
     void setup(Class<? extends Specification> spec) {
         cleanRegistry()
+        // Reset GormRegistry so each test gets fresh GormStaticApi instances.
+        // Without this, registerEntity() skips re-creation (if (getStaticApi == null))
+        // and the cached hibernateTemplate on the old instance points to a destroyed
+        // session factory, causing "Could not obtain current Hibernate Session".
+        GormRegistry.reset()
         super.setup(spec)
     }