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/03/23 01:53:05 UTC

(grails-core) branch 8.0.x-hibernate7-dev updated (3d4d4be350 -> 9620b0b501)

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

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


    from 3d4d4be350 hibernate 7:   Key Enhancements & Fixes:
     new 8c0e10dabd hibernate 7: linting
     new a788ce1e98 hibernate 7: linting
     new 45c7764f70 hibernate 7: linting and EventListenerIntegrator tightening
     new 0d2c60704c hibernate 7: Internally DataSource Connection.DEFAULT value was incorrect, still support legacy value hardcoded
     new 31e1f79670 hibernate 7: added more validations for GrailsHibernateUtil
     new d78d73c37b hibernate 7: more linting
     new 95835198eb hibernate 7:   * Query Engine Precision:        * Replaced inefficient IN subqueries with true SQL JOINs for association criteria.        * Enabled full support for user-specified JoinType (INNER, LEFT, etc.) across all criteria APIs.        * Resolved ClassCastException and IllegalArgumentException issues when navigating deeply nested association paths or querying into @Embedded components.        * Fixed correlated subquery support (exists) to correctly handle its ow [...]
     new 9620b0b501 hibernate 7:   * Fix HQL Queries

The 8 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails.  The revisions
listed as "add" were already present in the repository and have only
been added to this reference.


Summary of changes:
 grails-data-hibernate7/core/ISSUES.md              | 103 ++++++++++++
 .../groovy/grails/orm/CriteriaMethodInvoker.java   |  71 ++++++---
 .../main/groovy/grails/orm/CriteriaMethods.java    |   2 +-
 .../grails/orm/HibernateCriteriaBuilder.java       |  25 +--
 .../CloseSuppressingInvocationHandler.java         |   8 +-
 .../orm/hibernate/EventListenerIntegrator.java     |   7 +-
 .../orm/hibernate/GrailsHibernateTemplate.java     |  17 +-
 .../grails/orm/hibernate/GrailsSessionContext.java |   9 +-
 .../grails/orm/hibernate/HibernateDatastore.java   |  51 +++---
 .../access/TraitPropertyAccessStrategy.java        |  33 ++--
 .../orm/hibernate/cfg/GrailsHibernateUtil.java     |  43 ++---
 .../orm/hibernate/cfg/HibernateMappingContext.java |  26 ++-
 .../cfg/HibernateMappingContextConfiguration.java  |  47 +++---
 .../binder/ClassPropertiesBinder.java              |  11 +-
 .../cfg/domainbinding/binder/CollectionBinder.java |   3 +-
 .../binder/CollectionForPropertyConfigBinder.java  |   1 -
 .../cfg/domainbinding/binder/ColumnBinder.java     |  22 ++-
 .../cfg/domainbinding/binder/ComponentBinder.java  |  10 +-
 .../cfg/domainbinding/binder/ComponentUpdater.java |   4 +-
 .../domainbinding/binder/CompositeIdBinder.java    |  13 +-
 .../CompositeIdentifierToManyToOneBinder.java      |   4 +-
 .../cfg/domainbinding/binder/EnumTypeBinder.java   |  14 +-
 .../binder/ForeignKeyOneToOneBinder.java           |   4 +-
 .../domainbinding/binder/GrailsDomainBinder.java   |  13 +-
 .../domainbinding/binder/GrailsPropertyBinder.java |  12 +-
 .../domainbinding/binder/JoinedSubClassBinder.java |   7 +-
 .../binder/NumericColumnConstraintsBinder.java     |  20 ++-
 .../cfg/domainbinding/binder/OneToOneBinder.java   |   4 +-
 .../cfg/domainbinding/binder/PropertyBinder.java   |  18 +--
 .../cfg/domainbinding/binder/RootBinder.java       |   7 +-
 .../RootPersistentClassCommonValuesBinder.java     |  11 +-
 .../domainbinding/binder/SimpleValueBinder.java    |   8 +-
 .../binder/SingleTableSubclassBinder.java          |   4 +-
 .../domainbinding/binder/UnionSubclassBinder.java  |   7 +-
 .../generator/GrailsIncrementGenerator.java        |  76 +++++----
 .../generator/GrailsNativeGenerator.java           |   3 +-
 .../generator/GrailsSequenceGeneratorEnum.groovy   |   2 +-
 .../generator/GrailsTableGenerator.java            |   4 +-
 .../hibernate/GrailsHibernatePersistentEntity.java |  49 +++---
 .../hibernate/HibernateAssociation.java            |  10 +-
 .../hibernate/HibernateOneToOneProperty.java       |  15 +-
 .../hibernate/HibernatePersistentProperty.java     |  17 +-
 .../hibernate/HibernateToManyProperty.java         |  21 +--
 .../secondpass/BasicCollectionElementBinder.java   |   3 +-
 .../secondpass/CollectionKeyBinder.java            |  12 +-
 .../secondpass/CollectionKeyColumnUpdater.java     |   1 -
 .../secondpass/CollectionOrderByBinder.java        |  10 +-
 .../secondpass/CollectionSecondPassBinder.java     |  23 +--
 .../secondpass/DependentKeyValueBinder.java        |   6 +-
 .../domainbinding/secondpass/ListSecondPass.java   |   4 +-
 .../secondpass/ListSecondPassBinder.java           |  19 +--
 .../domainbinding/secondpass/MapSecondPass.java    |   4 +-
 .../secondpass/MapSecondPassBinder.java            |   4 +-
 .../domainbinding/secondpass/SetSecondPass.java    |   4 +-
 .../secondpass/UnidirectionalOneToManyBinder.java  |  19 +--
 ...UnidirectionalOneToManyInverseValuesBinder.java |   3 -
 .../domainbinding/util/BasicValueIdCreator.java    |   5 +-
 .../cfg/domainbinding/util/CascadeBehavior.java    |   4 +-
 .../domainbinding/util/CascadeBehaviorFetcher.java |  28 ++--
 .../util/ColumnNameForPropertyAndPathFetcher.java  |   6 +-
 .../util/DefaultColumnNameFetcher.java             |  16 +-
 .../util/MultiTenantFilterBinder.java              |   3 +-
 .../domainbinding/util/NamingStrategyProvider.java |   6 +-
 .../domainbinding/util/OrderByClauseBuilder.java   |  19 +--
 .../util/SimpleValueColumnFetcher.java             |   6 +-
 .../domainbinding/util/TableForManyCalculator.java |   5 +-
 .../connections/HibernateConnectionSource.java     |   1 -
 .../HibernateConnectionSourceFactory.java          |  15 +-
 .../event/listener/HibernateEventListener.java     |  32 ++--
 .../multitenancy/MultiTenantEventListener.java     |  19 ++-
 .../proxy/ByteBuddyGroovyInterceptor.java          |  23 ++-
 .../proxy/ByteBuddyGroovyProxyFactory.java         |  18 +--
 .../hibernate/proxy/GrailsBytecodeProvider.java    |  13 +-
 .../proxy/GroovyProxyInterceptorLogic.java         |  26 +--
 .../orm/hibernate/proxy/HibernateProxyHandler.java |  11 +-
 .../query/DetachedAssociationFunction.java         |   6 +
 .../grails/orm/hibernate/query/HibernateAlias.java |  18 +--
 .../orm/hibernate/query/HibernateHqlQuery.java     |  52 +++---
 .../grails/orm/hibernate/query/HibernateQuery.java |  13 +-
 .../hibernate/query/HibernateQueryArgument.java    |  20 +++
 .../hibernate/query/HibernateQueryConstants.java   |   1 +
 .../orm/hibernate/query/HqlListQueryBuilder.java   |  26 +--
 .../orm/hibernate/query/HqlQueryContext.java       | 145 ++++++++++-------
 .../hibernate/query/JpaCriteriaQueryCreator.java   |  39 +++--
 .../orm/hibernate/query/JpaFromProvider.java       | 162 +++++++++++++------
 .../orm/hibernate/query/PredicateGenerator.java    | 171 +++++++++++++-------
 .../hibernate/support/ClosureEventListener.java    |  56 ++++---
 .../support/ClosureEventTriggeringInterceptor.java |  31 ++--
 .../grails/orm/CriteriaMethodInvokerSpec.groovy    |  23 ++-
 .../hibernate/EventListenerIntegratorSpec.groovy   |  51 ++++++
 .../HibernateDatastoreIntegrationSpec.groovy       |   3 +-
 .../orm/hibernate/HibernateDatastoreSpec.groovy    |  77 +++++++--
 .../cfg/GrailsHibernatePersistentEntitySpec.groovy |   3 +-
 .../hibernate/cfg/GrailsHibernateUtilSpec.groovy   |  91 +++++++++--
 .../cfg/HibernateMappingContextSpec.groovy         |   5 +-
 .../cfg/domainbinding/EnumTypeBinderSpec.groovy    |  13 +-
 .../cfg/domainbinding/binder/RootBinderSpec.groovy |   7 +-
 .../domainbinding/binder/SubClassBinderSpec.groovy |  10 +-
 .../BasicCollectionElementBinderSpec.groovy        |   4 +-
 .../hibernate/query/HqlListQueryBuilderSpec.groovy | 177 +++++++++++++++++++++
 .../orm/hibernate/query/HqlQueryContextSpec.groovy |  20 ++-
 .../mapping/core/connections/ConnectionSource.java |   9 +-
 .../mapping/model/AbstractMappingContext.java      |   8 +-
 .../datastore/mapping/model/MappingContext.java    |   2 +-
 104 files changed, 1569 insertions(+), 878 deletions(-)
 create mode 100644 grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/EventListenerIntegratorSpec.groovy
 create mode 100644 grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/query/HqlListQueryBuilderSpec.groovy


(grails-core) 07/08: hibernate 7: * Query Engine Precision: * Replaced inefficient IN subqueries with true SQL JOINs for association criteria. * Enabled full support for user-specified JoinType (INNER, LEFT, etc.) across all criteria APIs. * Resolved ClassCastException and IllegalArgumentException issues when navigating deeply nested association paths or querying into @Embedded components. * Fixed correlated subquery support (exists) to correctly handle its own independent join pr [...]

Posted by bo...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

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

commit 95835198eb445675fe57a012ef466526f44d3e1f
Author: Walter Duque de Estrada <wb...@mac.com>
AuthorDate: Sun Mar 22 18:44:29 2026 -0500

    hibernate 7:
      * Query Engine Precision:
           * Replaced inefficient IN subqueries with true SQL JOINs for association criteria.
           * Enabled full support for user-specified JoinType (INNER, LEFT, etc.) across all criteria APIs.
           * Resolved ClassCastException and IllegalArgumentException issues when navigating deeply nested association paths or querying into @Embedded components.
           * Fixed correlated subquery support (exists) to correctly handle its own independent join providers.
---
 grails-data-hibernate7/core/ISSUES.md              |   5 +
 .../groovy/grails/orm/CriteriaMethodInvoker.java   |  34 +++++-
 .../grails/orm/HibernateCriteriaBuilder.java       |  17 ++-
 .../grails/orm/hibernate/GrailsSessionContext.java |   9 +-
 .../generator/GrailsIncrementGenerator.java        |  76 +++++++-----
 .../query/DetachedAssociationFunction.java         |   6 +
 .../grails/orm/hibernate/query/HibernateAlias.java |   8 +-
 .../orm/hibernate/query/JpaFromProvider.java       | 135 +++++++++++++++++----
 .../orm/hibernate/query/PredicateGenerator.java    |  53 ++++++--
 .../grails/orm/CriteriaMethodInvokerSpec.groovy    |  23 ++--
 10 files changed, 276 insertions(+), 90 deletions(-)

diff --git a/grails-data-hibernate7/core/ISSUES.md b/grails-data-hibernate7/core/ISSUES.md
index e9194b2bc3..8874cbb009 100644
--- a/grails-data-hibernate7/core/ISSUES.md
+++ b/grails-data-hibernate7/core/ISSUES.md
@@ -15,6 +15,11 @@ In Grails 7:
 - `HibernateDatastore.getDatastoreForConnection` supports `"dataSource"`, `ConnectionSource.DEFAULT` ("default"), and `ConnectionSource.OLD_DEFAULT` ("DEFAULT").
 - Raw `"default"` and `"DEFAULT"` strings in H7 production code and key tests have been replaced with `ConnectionSource.DEFAULT`.
 - `HibernateMappingContextConfiguration` and `HibernateDatastore` correctly use `ConnectionSource.DEFAULT` for the primary datasource name.
+- **Fixed Issues in GORM Querying (Hibernate 7):**
+    - Refactored `JpaFromProvider` to correctly handle root aliases and hierarchical joins for dot-notated projection/criteria paths.
+    - Fixed `ClassCastException` in `PredicateGenerator` by ensuring all association paths are properly pre-joined in the JPA metamodel.
+    - Enhanced `PredicateGenerator.handleExists` to properly support correlated subqueries with their own join providers.
+    - Ensured basic collection joins (e.g., `nicknames`) are automatically handled during query construction.
 
 **Risk & Potential Propagation:**
 - This change might affect other GORM modules (Neo4j, MongoDB, etc.) if they rely on the uppercase `"DEFAULT"` string literal and don't yet support the lowercase `"default"`.
diff --git a/grails-data-hibernate7/core/src/main/groovy/grails/orm/CriteriaMethodInvoker.java b/grails-data-hibernate7/core/src/main/groovy/grails/orm/CriteriaMethodInvoker.java
index 1eb07c07bd..68ba31de38 100644
--- a/grails-data-hibernate7/core/src/main/groovy/grails/orm/CriteriaMethodInvoker.java
+++ b/grails-data-hibernate7/core/src/main/groovy/grails/orm/CriteriaMethodInvoker.java
@@ -34,7 +34,12 @@ import org.springframework.beans.BeanUtils;
 
 import grails.gorm.DetachedCriteria;
 import grails.gorm.PagedResultList;
+import org.grails.datastore.gorm.query.criteria.DetachedAssociationCriteria;
+import org.grails.datastore.mapping.model.PersistentEntity;
+import org.grails.datastore.mapping.model.PersistentProperty;
+import org.grails.datastore.mapping.model.types.Association;
 import org.grails.datastore.mapping.query.Query;
+import org.grails.orm.hibernate.cfg.domainbinding.hibernate.HibernatePersistentEntity;
 import org.grails.orm.hibernate.query.HibernateQuery;
 import org.grails.orm.hibernate.query.HibernateQueryArgument;
 
@@ -188,18 +193,38 @@ public class CriteriaMethodInvoker {
 
             if (attribute.isAssociation()) {
                 Class<?> oldTargetClass = builder.getTargetClass();
-                builder.setTargetClass(builder.getClassForAssociationType(attribute));
+                Class<?> associationClass = builder.getClassForAssociationType(attribute);
+                builder.setTargetClass(associationClass);
                 JoinType joinType;
                 if (hasMoreThanOneArg) {
                     joinType = builder.convertFromInt((Integer) args[0]);
-                } else if (builder.getTargetClass().equals(oldTargetClass)) {
+                } else if (associationClass.equals(oldTargetClass)) {
                     joinType = JoinType.LEFT; // default to left join if joining on the same table
                 } else {
                     joinType = builder.convertFromInt(0);
                 }
 
                 hibernateQuery.join(name, joinType);
-                hibernateQuery.in(name, new DetachedCriteria<>(builder.getTargetClass()).build(callable));
+
+                PersistentEntity parentEntity =
+                        hibernateQuery.getSession().getMappingContext().getPersistentEntity(oldTargetClass.getName());
+                PersistentProperty property = parentEntity.getPropertyByName(name);
+                if (property instanceof Association association) {
+                    DetachedAssociationCriteria associationCriteria =
+                            new DetachedAssociationCriteria(associationClass, association);
+                    DetachedCriteria oldDetachedCriteria = hibernateQuery.getDetachedCriteria();
+                    hibernateQuery.setDetachedCriteria(associationCriteria);
+                    try {
+                        invokeClosureNode(callable);
+                    } finally {
+                        hibernateQuery.setDetachedCriteria(oldDetachedCriteria);
+                    }
+                    hibernateQuery.add((Query.Criterion) associationCriteria);
+                } else {
+                    // Fallback for non-GORM associations if any
+                    hibernateQuery.in(name, new DetachedCriteria<>(associationClass).build(callable));
+                }
+
                 builder.setTargetClass(oldTargetClass);
 
                 return name;
@@ -238,7 +263,8 @@ public class CriteriaMethodInvoker {
                             && args[0] instanceof String s
                             && args[1] instanceof String a
                             && args[2] instanceof Number jt) {
-                        return builder.createAlias(s, a, jt.intValue());
+                        builder.createAlias(s, a, jt.intValue());
+                        return builder;
                     }
                     return name;
                 case IS_NULL, IS_NOT_NULL, IS_EMPTY, IS_NOT_EMPTY:
diff --git a/grails-data-hibernate7/core/src/main/groovy/grails/orm/HibernateCriteriaBuilder.java b/grails-data-hibernate7/core/src/main/groovy/grails/orm/HibernateCriteriaBuilder.java
index ceba4af686..fb8d7eccd4 100644
--- a/grails-data-hibernate7/core/src/main/groovy/grails/orm/HibernateCriteriaBuilder.java
+++ b/grails-data-hibernate7/core/src/main/groovy/grails/orm/HibernateCriteriaBuilder.java
@@ -168,13 +168,26 @@ public class HibernateCriteriaBuilder extends GroovyObjectSupport implements Bui
         }
     }
 
-    public Criteria createAlias(String associationPath, String alias) {
+    public org.grails.datastore.mapping.query.api.Criteria createAlias(String associationPath, String alias) {
         var prop = hibernateQuery.getEntity().getPropertyByName(associationPath);
         if (prop instanceof org.grails.datastore.mapping.model.types.Basic) {
-            hibernateQuery.addAlias(new org.grails.orm.hibernate.query.HibernateAlias(associationPath, alias));
+            hibernateQuery.addAlias(new org.grails.orm.hibernate.query.HibernateAlias(associationPath, alias, JoinType.INNER));
             return this;
         }
         hibernateQuery.getDetachedCriteria().createAlias(associationPath, alias);
+        hibernateQuery.getDetachedCriteria().join(associationPath, JoinType.INNER);
+        return this;
+    }
+
+    public org.grails.datastore.mapping.query.api.Criteria createAlias(String associationPath, String alias, int joinType) {
+        var prop = hibernateQuery.getEntity().getPropertyByName(associationPath);
+        JoinType convertedJoinType = convertFromInt(joinType);
+        if (prop instanceof org.grails.datastore.mapping.model.types.Basic) {
+            hibernateQuery.addAlias(new org.grails.orm.hibernate.query.HibernateAlias(associationPath, alias, convertedJoinType));
+            return this;
+        }
+        hibernateQuery.getDetachedCriteria().createAlias(associationPath, alias);
+        hibernateQuery.getDetachedCriteria().join(associationPath, convertedJoinType);
         return this;
     }
 
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/GrailsSessionContext.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/GrailsSessionContext.java
index 82b18747ff..f292dd0108 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/GrailsSessionContext.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/GrailsSessionContext.java
@@ -79,6 +79,7 @@ public class GrailsSessionContext implements CurrentSessionContext {
     }
 
     /** Retrieve the Spring-managed Session for the current thread, if any. */
+    @Override
     public Session currentSession() throws HibernateException {
         Object value = TransactionSynchronizationManager.getResource(sessionFactory);
         if (value instanceof Session) {
@@ -87,16 +88,16 @@ public class GrailsSessionContext implements CurrentSessionContext {
 
         if (value instanceof SessionHolder sessionHolder) {
             Session session = sessionHolder.getSession();
-            if (TransactionSynchronizationManager.isSynchronizationActive() &&
-                    !sessionHolder.isSynchronizedWithTransaction()) {
+            if (TransactionSynchronizationManager.isSynchronizationActive()
+                    && !sessionHolder.isSynchronizedWithTransaction()) {
                 TransactionSynchronizationManager.registerSynchronization(
                         createSpringSessionSynchronization(sessionHolder));
                 sessionHolder.setSynchronizedWithTransaction(true);
                 // Switch to FlushMode.AUTO, as we have to assume a thread-bound Session
                 // with FlushMode.MANUAL, which needs to allow flushing within the transaction.
                 FlushMode flushMode = session.getHibernateFlushMode();
-                if (flushMode.equals(FlushMode.MANUAL) &&
-                        !TransactionSynchronizationManager.isCurrentTransactionReadOnly()) {
+                if (flushMode.equals(FlushMode.MANUAL)
+                        && !TransactionSynchronizationManager.isCurrentTransactionReadOnly()) {
                     session.setHibernateFlushMode(FlushMode.AUTO);
                     sessionHolder.setPreviousFlushMode(flushMode);
                 }
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/generator/GrailsIncrementGenerator.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/generator/GrailsIncrementGenerator.java
index bc11819d80..172247aa5d 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/generator/GrailsIncrementGenerator.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/generator/GrailsIncrementGenerator.java
@@ -19,8 +19,10 @@
 package org.grails.orm.hibernate.cfg.domainbinding.generator;
 
 import java.io.Serial;
+import java.util.Optional;
 import java.util.Properties;
 
+import org.hibernate.boot.model.naming.Identifier;
 import org.hibernate.boot.model.relational.SqlStringGenerationContext;
 import org.hibernate.boot.model.relational.internal.SqlStringGenerationContextImpl;
 import org.hibernate.engine.jdbc.env.spi.JdbcEnvironment;
@@ -49,44 +51,52 @@ public class GrailsIncrementGenerator extends IncrementGenerator {
             GrailsHibernatePersistentEntity domainClass,
             PersistentEntityNamingStrategy namingStrategy) {
 
+        configure(context, buildParams(context, mappedId, domainClass, namingStrategy));
+        initialize(buildSqlContext(context));
+    }
+
+    private Properties buildParams(
+            GeneratorCreationContext context,
+            Identity mappedId,
+            GrailsHibernatePersistentEntity domainClass,
+            PersistentEntityNamingStrategy namingStrategy) {
+
         Properties params = new Properties();
-        if (mappedId != null && mappedId.getProperties() != null) {
-            params.putAll(mappedId.getProperties());
-        }
+        Optional.ofNullable(mappedId).map(Identity::getProperties).ifPresent(params::putAll);
 
-        // Use the entity's naming-strategy-aware table resolution:
-        // handles explicit mapping, table-per-hierarchy root, and PhysicalNamingStrategy fallback.
         params.put(TABLES, domainClass.getTableName(namingStrategy));
+        params.put(COLUMN, resolveColumnName(context, mappedId));
 
-        org.grails.orm.hibernate.cfg.Mapping mapping = domainClass.getHibernateMappedForm();
-        if (mapping != null && mapping.getTable() != null) {
-            if (mapping.getTable().getCatalog() != null)
-                params.put(CATALOG, mapping.getTable().getCatalog());
-            if (mapping.getTable().getSchema() != null)
-                params.put(SCHEMA, mapping.getTable().getSchema());
-        }
+        Optional.ofNullable(domainClass.getHibernateMappedForm())
+                .map(org.grails.orm.hibernate.cfg.Mapping::getTable)
+                .ifPresent(table -> {
+                    if (table.getCatalog() != null) params.put(CATALOG, table.getCatalog());
+                    if (table.getSchema() != null) params.put(SCHEMA, table.getSchema());
+                });
+
+        return params;
+    }
 
-        // Resolve column name — fall back to "id" if the property path is dotted (composite)
-        String columnName = context.getProperty().getName();
-        if (columnName == null || columnName.contains(".")) {
-            columnName = (mappedId != null &&
-                            mappedId.getName() != null &&
-                            !mappedId.getName().contains(".")) ?
-                    mappedId.getName() :
-                    "id";
+    private String resolveColumnName(GeneratorCreationContext context, Identity mappedId) {
+        String propertyName = context.getProperty().getName();
+        if (propertyName != null && !propertyName.contains(".")) {
+            return propertyName;
         }
-        params.put(COLUMN, columnName);
-
-        // Delegate to the standard configure() — sets returnClass, column, physicalTableNames
-        configure(context, params);
-
-        // Build SqlStringGenerationContext and initialize the SQL query
-        JdbcEnvironment jdbcEnvironment = context.getDatabase().getJdbcEnvironment();
-        var physicalName = context.getDatabase().getDefaultNamespace().getPhysicalName();
-        String catalog = physicalName.catalog() != null ? physicalName.catalog().getCanonicalName() : null;
-        String schema = physicalName.schema() != null ? physicalName.schema().getCanonicalName() : null;
-        SqlStringGenerationContext sqlContext =
-                SqlStringGenerationContextImpl.fromExplicit(jdbcEnvironment, context.getDatabase(), catalog, schema);
-        initialize(sqlContext);
+        return Optional.ofNullable(mappedId)
+                .map(Identity::getName)
+                .filter(name -> !name.contains("."))
+                .orElse("id");
+    }
+
+    private SqlStringGenerationContext buildSqlContext(GeneratorCreationContext context) {
+        var database = context.getDatabase();
+        var physicalName = database.getDefaultNamespace().getPhysicalName();
+
+        return SqlStringGenerationContextImpl.fromExplicit(
+                database.getJdbcEnvironment(),
+                database,
+                Optional.ofNullable(physicalName.catalog()).map(Identifier::getCanonicalName).orElse(null),
+                Optional.ofNullable(physicalName.schema()).map(Identifier::getCanonicalName).orElse(null)
+        );
     }
 }
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/DetachedAssociationFunction.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/DetachedAssociationFunction.java
index fe43d6819f..e8fd19a73a 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/DetachedAssociationFunction.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/DetachedAssociationFunction.java
@@ -30,6 +30,12 @@ public class DetachedAssociationFunction implements Function<Query.Criterion, Li
     public List<DetachedAssociationCriteria<?>> apply(Query.Criterion o) {
         if (o instanceof DetachedAssociationCriteria) {
             return List.of((DetachedAssociationCriteria<?>) o);
+        } else if (o instanceof Query.Junction junction) {
+            java.util.List<DetachedAssociationCriteria<?>> result = new java.util.ArrayList<>();
+            for (Query.Criterion criterion : junction.getCriteria()) {
+                result.addAll(apply(criterion));
+            }
+            return result;
         }
         return List.of();
     }
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/HibernateAlias.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/HibernateAlias.java
index bd3fac0f6d..a1c9c10263 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/HibernateAlias.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/HibernateAlias.java
@@ -18,6 +18,8 @@
  */
 package org.grails.orm.hibernate.query;
 
+import jakarta.persistence.criteria.JoinType;
+
 import org.grails.datastore.mapping.query.Query;
 
 /**
@@ -25,6 +27,10 @@ import org.grails.datastore.mapping.query.Query;
  *
  * @author walterduquedeestrada
  */
-public record HibernateAlias(String path, String alias) implements Query.Criterion, Query.QueryElement {
+public record HibernateAlias(String path, String alias, JoinType joinType) implements Query.Criterion, Query.QueryElement {
+
+    public HibernateAlias(String path, String alias) {
+        this(path, alias, JoinType.INNER);
+    }
 
 }
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/JpaFromProvider.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/JpaFromProvider.java
index 7bc699eae9..2ae820e7f8 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/JpaFromProvider.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/JpaFromProvider.java
@@ -31,6 +31,7 @@ import jakarta.persistence.criteria.Path;
 
 import grails.gorm.DetachedCriteria;
 import org.grails.datastore.gorm.query.criteria.DetachedAssociationCriteria;
+import org.grails.datastore.mapping.model.PersistentEntity;
 import org.grails.datastore.mapping.query.Query;
 
 @SuppressWarnings({
@@ -72,6 +73,19 @@ public class JpaFromProvider implements Cloneable {
         fromMap.putAll(getFromsByName(detachedCriteria, projections, List.of(), root));
     }
 
+    @SuppressWarnings("PMD.ConstructorCallsOverridableMethod")
+    public JpaFromProvider(
+            JpaFromProvider parent,
+            PersistentEntity entity,
+            List<Query.Criterion> criteria,
+            List<Query.Projection> projections,
+            Map<String, jakarta.persistence.FetchType> fetchStrategies,
+            Map<String, jakarta.persistence.criteria.JoinType> joinTypes,
+            From<?, ?> root) {
+        fromMap = new HashMap<>(parent.fromMap);
+        fromMap.putAll(getFromsByName(entity, criteria, projections, List.of(), fetchStrategies, joinTypes, root));
+    }
+
     public Map<String, From<?, ?>> getFromsByName() {
         return fromMap;
     }
@@ -85,7 +99,33 @@ public class JpaFromProvider implements Cloneable {
             List<Query.Projection> projections,
             List<HibernateAlias> aliases,
             From<?, ?> root) {
-        var detachedAssociationCriteriaList = detachedCriteria.getCriteria().stream()
+        Map<String, From<?, ?>> froms = getFromsByName(
+                detachedCriteria.getPersistentEntity(),
+                detachedCriteria.getCriteria(),
+                projections,
+                aliases,
+                detachedCriteria.getFetchStrategies(),
+                detachedCriteria.getJoinTypes(),
+                root);
+        if (detachedCriteria.getAlias() != null) {
+            froms.put(detachedCriteria.getAlias(), root);
+        }
+        return froms;
+    }
+
+    protected Map<String, From<?, ?>> getFromsByName(
+            PersistentEntity entity,
+            List<Query.Criterion> criteria,
+            List<Query.Projection> projections,
+            List<HibernateAlias> aliases,
+            Map<String, FetchType> fetchStrategies,
+            Map<String, JoinType> joinTypes,
+            From<?, ?> root) {
+        var allCriteriaPaths = criteria.stream()
+                .flatMap(c -> findPaths(c).stream())
+                .toList();
+
+        var detachedAssociationCriteriaList = criteria.stream()
                 .map(new DetachedAssociationFunction())
                 .flatMap(List::stream)
                 .toList();
@@ -94,8 +134,10 @@ public class JpaFromProvider implements Cloneable {
 
         // Also scan for HibernateAlias (basic collections)
         Map<String, String> basicAliasMap = new HashMap<>();
+        Map<String, JoinType> basicJoinTypeMap = new HashMap<>();
         for (HibernateAlias ha : aliases) {
             basicAliasMap.put(ha.path(), ha.alias());
+            basicJoinTypeMap.put(ha.path(), ha.joinType());
         }
 
         var definedAliases = detachedAssociationCriteriaList.stream()
@@ -104,32 +146,39 @@ public class JpaFromProvider implements Cloneable {
                 .collect(Collectors.toSet());
         definedAliases.addAll(basicAliasMap.values());
 
-        var directProjectedPaths = projections.stream()
+        var associationProjectedPaths = projections.stream()
                 .filter(Query.PropertyProjection.class::isInstance)
                 .map(p -> ((Query.PropertyProjection) p).getPropertyName())
                 .filter(name -> name.contains("."))
                 .map(name -> name.substring(0, name.lastIndexOf('.')))
                 .collect(Collectors.toSet());
 
-        var eagerPaths = detachedCriteria.getFetchStrategies().entrySet().stream()
+        var criteriaPaths = allCriteriaPaths.stream()
+                .filter(p -> p.contains("."))
+                .map(p -> p.substring(0, p.lastIndexOf('.')))
+                .collect(Collectors.toSet());
+
+        var eagerPaths = fetchStrategies.entrySet().stream()
                 .filter(entry -> entry.getValue().equals(FetchType.EAGER))
                 .map(Map.Entry::getKey)
                 .collect(Collectors.toSet());
 
-        var collectionPaths = detachedCriteria.getPersistentEntity().getPersistentProperties().stream()
+        var collectionPaths = entity != null ? entity.getPersistentProperties().stream()
                 .filter(p -> p instanceof org.grails.datastore.mapping.model.types.Basic)
                 .map(org.grails.datastore.mapping.model.PersistentProperty::getName)
-                .collect(Collectors.toSet());
+                .collect(Collectors.toSet()) : java.util.Collections.<String>emptySet();
 
         java.util.Set<String> allPaths = new java.util.HashSet<>();
         allPaths.addAll(aliasMap.keySet());
         allPaths.addAll(basicAliasMap.keySet());
-        allPaths.addAll(directProjectedPaths.stream()
-                .filter(p -> !definedAliases.contains(p))
-                .toList());
+        allPaths.addAll(associationProjectedPaths);
+        allPaths.addAll(criteriaPaths);
         allPaths.addAll(eagerPaths);
         allPaths.addAll(collectionPaths);
 
+        // Don't try to join segments that are already defined aliases
+        allPaths.removeAll(definedAliases);
+
         // Expand paths to include all parents (e.g., "a.b.c" -> "a", "a.b", "a.b.c")
         java.util.Set<String> expandedPaths = new java.util.HashSet<>();
         for (String path : allPaths) {
@@ -146,7 +195,7 @@ public class JpaFromProvider implements Cloneable {
 
         // Re-calculate projected paths to include expanded segments for LEFT join logic
         var finalProjectedPaths = expandedPaths.stream()
-                .filter(p -> directProjectedPaths.stream().anyMatch(dp -> dp.equals(p) || dp.startsWith(p + ".")))
+                .filter(p -> associationProjectedPaths.stream().anyMatch(dp -> dp.equals(p) || dp.startsWith(p + ".")))
                 .collect(Collectors.toSet());
 
         Map<String, From<?, ?>> fromsByPath = new HashMap<>();
@@ -164,10 +213,15 @@ public class JpaFromProvider implements Cloneable {
             String leaf = path.contains(".") ? path.substring(path.lastIndexOf('.') + 1) : path;
 
             From<?, ?> base = fromsByPath.get(parentPath);
+            if (base == null) {
+                continue;
+            }
 
             JoinType joinType = JoinType.INNER;
-            if (detachedCriteria.getJoinTypes().containsKey(path)) {
-                joinType = detachedCriteria.getJoinTypes().get(path);
+            if (joinTypes.containsKey(path)) {
+                joinType = joinTypes.get(path);
+            } else if (basicJoinTypeMap.containsKey(path)) {
+                joinType = basicJoinTypeMap.get(path);
             } else if (finalProjectedPaths.contains(path)
                     || eagerPaths.contains(path)
                     || collectionPaths.contains(path)) {
@@ -176,28 +230,43 @@ public class JpaFromProvider implements Cloneable {
 
             var table = base.join(leaf, joinType);
 
+            boolean aliasApplied = false;
             // If there's an alias for this path, map it to the alias too
             var dac = aliasMap.get(path);
             if (dac != null && dac.getAlias() != null) {
+                table.alias(dac.getAlias());
                 fromsByPath.put(dac.getAlias(), table);
+                aliasApplied = true;
             }
 
             String basicAlias = basicAliasMap.get(path);
             if (basicAlias != null) {
+                table.alias(basicAlias);
                 fromsByPath.put(basicAlias, table);
+                aliasApplied = true;
             }
 
-            table.alias(path);
+            if (!aliasApplied) {
+                table.alias(path);
+            }
             fromsByPath.put(path, table);
         }
 
-        String rootAlias = detachedCriteria.getAlias();
-        if (rootAlias != null && !rootAlias.isEmpty()) {
-            fromsByPath.put(rootAlias, root);
-        }
         return fromsByPath;
     }
 
+    private java.util.Set<String> findPaths(Query.Criterion criterion) {
+        java.util.Set<String> paths = new java.util.HashSet<>();
+        if (criterion instanceof Query.PropertyNameCriterion pnc) {
+            paths.add(pnc.getProperty());
+        } else if (criterion instanceof Query.Junction junction) {
+            for (Query.Criterion c : junction.getCriteria()) {
+                paths.addAll(findPaths(c));
+            }
+        }
+        return paths;
+    }
+
     private Map<String, DetachedAssociationCriteria<?>> createAliasMap(
             List<DetachedAssociationCriteria<?>> detachedAssociationCriteriaList) {
         // Use a merge function and a stable map type to avoid DuplicateKey exceptions when the same
@@ -224,29 +293,43 @@ public class JpaFromProvider implements Cloneable {
         String[] parsed = propertyName.split("\\.");
         if (parsed.length == SINGLE_PROPERTY) {
             From<?, ?> root = fromMap.get("root");
-            if (propertyName.equals(root.getJavaType().getSimpleName())
-                    || propertyName.equals(root.getJavaType().getName())) {
-                return root;
+            if (root != null) {
+                if (propertyName.equals(root.getJavaType().getSimpleName())
+                        || propertyName.equals(root.getJavaType().getName())) {
+                    return root;
+                }
+                return root.get(propertyName);
             }
-            return root.get(propertyName);
         }
 
         // Try to find the longest matching prefix in fromMap
-        for (int i = parsed.length - 1; i >= 1; i--) {
+        for (int i = parsed.length; i >= 1; i--) {
             String prefix = java.util.Arrays.stream(parsed, 0, i).collect(Collectors.joining("."));
             if (fromMap.containsKey(prefix)) {
                 Path<?> path = fromMap.get(prefix);
-                for (int j = i; j < parsed.length; j++) {
-                    path = path.get(parsed[j]);
+                if (path != null) {
+                    for (int j = i; j < parsed.length; j++) {
+                        path = path.get(parsed[j]);
+                        if (path == null) {
+                            break;
+                        }
+                    }
+                    if (path != null) {
+                        return path;
+                    }
                 }
-                return path;
             }
         }
 
         // Fallback to root
         Path<?> path = fromMap.get("root");
-        for (String segment : parsed) {
-            path = path.get(segment);
+        if (path != null) {
+            for (String segment : parsed) {
+                path = path.get(segment);
+                if (path == null) {
+                    break;
+                }
+            }
         }
         return path;
     }
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/PredicateGenerator.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/PredicateGenerator.java
index e9a20cbd27..07985dee5b 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/PredicateGenerator.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/PredicateGenerator.java
@@ -136,12 +136,18 @@ public class PredicateGenerator {
             JpaFromProvider fromsByProvider,
             DetachedAssociationCriteria<?> c) {
 
-        var child = root.join(c.getAssociationPath(), JoinType.LEFT);
-        JpaFromProvider childTablesByName = (JpaFromProvider) fromsByProvider.clone();
-        childTablesByName.put("root", child);
-
+        From<?, ?> child = (From<?, ?>) fromsByProvider.getFullyQualifiedPath(c.getAssociationPath());
         PersistentEntity associatedEntity = c.getAssociation().getAssociatedEntity();
 
+        JpaFromProvider childTablesByName = new JpaFromProvider(
+                fromsByProvider,
+                associatedEntity,
+                c.getCriteria(),
+                java.util.Collections.<Query.Projection>emptyList(),
+                c.getFetchStrategies(),
+                c.getJoinTypes(),
+                child);
+
         return cb.and(getPredicates(cb, criteriaQuery, child, c.getCriteria(), childTablesByName, associatedEntity));
     }
 
@@ -151,9 +157,15 @@ public class PredicateGenerator {
             From<?, ?> root,
             JpaFromProvider fromsByProvider,
             HibernateAssociationQuery haq) {
-        var child = root.join(haq.associationPath, JoinType.LEFT);
-        JpaFromProvider childFroms = (JpaFromProvider) fromsByProvider.clone();
-        childFroms.put("root", child);
+        From<?, ?> child = (From<?, ?>) fromsByProvider.getFullyQualifiedPath(haq.associationPath);
+        JpaFromProvider childFroms = new JpaFromProvider(
+                fromsByProvider,
+                haq.getEntity(),
+                haq.getAssociationCriteria(),
+                java.util.Collections.<Query.Projection>emptyList(),
+                java.util.Collections.<String, jakarta.persistence.FetchType>emptyMap(),
+                java.util.Collections.<String, jakarta.persistence.criteria.JoinType>emptyMap(),
+                child);
         return cb.and(
                 getPredicates(cb, criteriaQuery, child, haq.getAssociationCriteria(), childFroms, haq.getEntity()));
     }
@@ -389,12 +401,27 @@ public class PredicateGenerator {
             JpaFromProvider fromsByProvider,
             PersistentEntity entity,
             Query.Exists c) {
-        Subquery subquery = criteriaQuery.subquery(Integer.class);
-        Root subRoot = subquery.from(entity.getJavaClass());
-        JpaFromProvider newMap = (JpaFromProvider) fromsByProvider.clone();
-        newMap.put("root", subRoot);
-        var predicates =
-                getPredicates(cb, criteriaQuery, subRoot, c.getSubquery().getCriteria(), newMap, entity);
+        QueryableCriteria<?> subqueryable = c.getSubquery();
+        PersistentEntity subEntity = subqueryable.getPersistentEntity();
+        Subquery<Integer> subquery = criteriaQuery.subquery(Integer.class);
+        Root<?> subRoot = subquery.from(subEntity.getJavaClass());
+
+        JpaFromProvider subFromsProvider = new JpaFromProvider(
+                fromsByProvider,
+                subEntity,
+                subqueryable.getCriteria(),
+                java.util.Collections.<Query.Projection>emptyList(),
+                java.util.Collections.<String, jakarta.persistence.FetchType>emptyMap(),
+                java.util.Collections.<String, jakarta.persistence.criteria.JoinType>emptyMap(),
+                subRoot);
+
+        var predicates = getPredicates(
+                cb,
+                criteriaQuery,
+                subRoot,
+                subqueryable.getCriteria(),
+                subFromsProvider,
+                subEntity);
         var existsPredicate = getExistsPredicate(cb, root_, entity, subRoot);
         Predicate[] allPredicates = existsPredicate != null
                 ? Stream.concat(Arrays.stream(predicates), Stream.of(existsPredicate))
diff --git a/grails-data-hibernate7/core/src/test/groovy/grails/orm/CriteriaMethodInvokerSpec.groovy b/grails-data-hibernate7/core/src/test/groovy/grails/orm/CriteriaMethodInvokerSpec.groovy
index b21b1050e4..d35c864e61 100644
--- a/grails-data-hibernate7/core/src/test/groovy/grails/orm/CriteriaMethodInvokerSpec.groovy
+++ b/grails-data-hibernate7/core/src/test/groovy/grails/orm/CriteriaMethodInvokerSpec.groovy
@@ -19,14 +19,12 @@
 
 package grails.orm
 
-import groovy.lang.Closure
-import groovy.lang.MissingMethodException
+
+import grails.gorm.DetachedCriteria
+import org.grails.datastore.gorm.query.criteria.DetachedAssociationCriteria
 import org.grails.orm.hibernate.query.HibernateQuery
-import org.grails.orm.hibernate.HibernateSession
-import org.hibernate.Session
+
 import org.hibernate.SessionFactory
-import org.springframework.orm.hibernate5.SessionHolder
-import org.springframework.transaction.support.TransactionSynchronizationManager
 import spock.lang.Specification
 
 class CriteriaMethodInvokerSpec extends Specification {
@@ -34,10 +32,14 @@ class CriteriaMethodInvokerSpec extends Specification {
     HibernateCriteriaBuilder builder = Mock(HibernateCriteriaBuilder)
     HibernateQuery query = Mock(HibernateQuery)
     SessionFactory sessionFactory = Mock(SessionFactory)
+    org.grails.orm.hibernate.HibernateSession session = Mock(org.grails.orm.hibernate.HibernateSession)
+    org.grails.datastore.mapping.model.MappingContext mappingContext = Mock(org.grails.datastore.mapping.model.MappingContext)
     CriteriaMethodInvoker invoker = new CriteriaMethodInvoker(builder)
 
     def setup() {
         builder.getHibernateQuery() >> query
+        query.getSession() >> session
+        session.getMappingContext() >> mappingContext
         _ * builder.isPaginationEnabledList() >> false
     }
 
@@ -146,6 +148,8 @@ class CriteriaMethodInvokerSpec extends Specification {
     void "test invokeMethod handles association query"() {
         given:
         def closure = { eq("amount", 10) }
+        def association = Mock(org.grails.datastore.mapping.model.types.Association)
+        def persistentEntity = Mock(org.grails.orm.hibernate.cfg.domainbinding.hibernate.HibernatePersistentEntity)
 
         when:
         invoker.invokeMethod("transactions", [closure] as Object[])
@@ -164,7 +168,12 @@ class CriteriaMethodInvokerSpec extends Specification {
         }
         1 * builder.getClassForAssociationType(_) >> InvokerTransaction
         1 * query.join("transactions", _)
-        1 * query.in("transactions", _)
+        1 * mappingContext.getPersistentEntity(InvokerAccount.name) >> persistentEntity
+        1 * persistentEntity.getPropertyByName("transactions") >> association
+        1 * query.getDetachedCriteria() >> Mock(DetachedCriteria)
+        1 * query.setDetachedCriteria(_ as DetachedAssociationCriteria)
+        1 * query.setDetachedCriteria(_ as DetachedCriteria)
+        1 * query.add(_ as DetachedAssociationCriteria)
     }
 
     void "test invokeMethod handles and/or/not junctions"() {


(grails-core) 01/08: hibernate 7: linting

Posted by bo...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

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

commit 8c0e10dabd219b9cc7afeae658e04ffa1a11a880
Author: Walter Duque de Estrada <wb...@mac.com>
AuthorDate: Sun Mar 22 10:54:28 2026 -0500

    hibernate 7: linting
---
 .../groovy/grails/orm/CriteriaMethodInvoker.java   |  37 +++---
 .../main/groovy/grails/orm/CriteriaMethods.java    |   2 +-
 .../CloseSuppressingInvocationHandler.java         |   8 +-
 .../access/TraitPropertyAccessStrategy.java        |  33 +++---
 .../orm/hibernate/cfg/HibernateMappingContext.java |  26 ++---
 .../cfg/HibernateMappingContextConfiguration.java  |  47 ++++----
 .../binder/ClassPropertiesBinder.java              |  11 +-
 .../cfg/domainbinding/binder/CollectionBinder.java |   3 +-
 .../binder/CollectionForPropertyConfigBinder.java  |   1 -
 .../cfg/domainbinding/binder/ColumnBinder.java     |  22 ++--
 .../cfg/domainbinding/binder/ComponentBinder.java  |  10 +-
 .../cfg/domainbinding/binder/ComponentUpdater.java |   4 +-
 .../domainbinding/binder/CompositeIdBinder.java    |  13 ++-
 .../CompositeIdentifierToManyToOneBinder.java      |   4 +-
 .../cfg/domainbinding/binder/EnumTypeBinder.java   |  14 ++-
 .../binder/ForeignKeyOneToOneBinder.java           |   4 +-
 .../domainbinding/binder/GrailsDomainBinder.java   |  10 +-
 .../domainbinding/binder/GrailsPropertyBinder.java |  12 +-
 .../domainbinding/binder/JoinedSubClassBinder.java |   7 +-
 .../binder/NumericColumnConstraintsBinder.java     |  20 ++--
 .../cfg/domainbinding/binder/OneToOneBinder.java   |   4 +-
 .../cfg/domainbinding/binder/PropertyBinder.java   |  18 +--
 .../cfg/domainbinding/binder/RootBinder.java       |   7 +-
 .../RootPersistentClassCommonValuesBinder.java     |  10 +-
 .../domainbinding/binder/SimpleValueBinder.java    |   8 +-
 .../binder/SingleTableSubclassBinder.java          |   4 +-
 .../domainbinding/binder/UnionSubclassBinder.java  |   7 +-
 .../generator/GrailsNativeGenerator.java           |   3 +-
 .../hibernate/HibernateAssociation.java            |  10 +-
 .../hibernate/HibernateOneToOneProperty.java       |  15 ++-
 .../hibernate/HibernateToManyProperty.java         |  21 ++--
 .../secondpass/BasicCollectionElementBinder.java   |   3 +-
 .../secondpass/CollectionKeyBinder.java            |  12 +-
 .../secondpass/CollectionKeyColumnUpdater.java     |   1 -
 .../secondpass/CollectionOrderByBinder.java        |  10 +-
 .../secondpass/CollectionSecondPassBinder.java     |  23 ++--
 .../secondpass/DependentKeyValueBinder.java        |   6 +-
 .../domainbinding/secondpass/ListSecondPass.java   |   4 +-
 .../secondpass/ListSecondPassBinder.java           |  19 ++--
 .../domainbinding/secondpass/MapSecondPass.java    |   4 +-
 .../secondpass/MapSecondPassBinder.java            |   4 +-
 .../domainbinding/secondpass/SetSecondPass.java    |   4 +-
 ...UnidirectionalOneToManyInverseValuesBinder.java |   3 -
 .../domainbinding/util/BasicValueIdCreator.java    |   5 +-
 .../domainbinding/util/CascadeBehaviorFetcher.java |  28 ++---
 .../util/ColumnNameForPropertyAndPathFetcher.java  |   6 +-
 .../domainbinding/util/NamingStrategyProvider.java |   6 +-
 .../domainbinding/util/OrderByClauseBuilder.java   |  19 ++--
 .../util/SimpleValueColumnFetcher.java             |   6 +-
 .../domainbinding/util/TableForManyCalculator.java |   5 +-
 .../connections/HibernateConnectionSource.java     |   1 -
 .../event/listener/HibernateEventListener.java     |  32 ++----
 .../multitenancy/MultiTenantEventListener.java     |  19 ++--
 .../proxy/ByteBuddyGroovyInterceptor.java          |  23 ++--
 .../proxy/ByteBuddyGroovyProxyFactory.java         |  18 ++-
 .../orm/hibernate/proxy/HibernateProxyHandler.java |  11 +-
 .../grails/orm/hibernate/query/HibernateQuery.java |  13 +--
 .../hibernate/query/HibernateQueryArgument.java    |   1 +
 .../hibernate/query/HibernateQueryConstants.java   |   1 +
 .../hibernate/query/JpaCriteriaQueryCreator.java   |  39 ++++---
 .../orm/hibernate/query/JpaFromProvider.java       |  33 ++----
 .../orm/hibernate/query/PredicateGenerator.java    | 124 ++++++++++++---------
 .../hibernate/support/ClosureEventListener.java    |  56 +++++-----
 .../support/ClosureEventTriggeringInterceptor.java |  31 ++++--
 .../cfg/domainbinding/EnumTypeBinderSpec.groovy    |  13 ++-
 .../BasicCollectionElementBinderSpec.groovy        |   4 +-
 .../mapping/model/AbstractMappingContext.java      |   8 +-
 67 files changed, 496 insertions(+), 494 deletions(-)

diff --git a/grails-data-hibernate7/core/src/main/groovy/grails/orm/CriteriaMethodInvoker.java b/grails-data-hibernate7/core/src/main/groovy/grails/orm/CriteriaMethodInvoker.java
index 07723be11a..1eb07c07bd 100644
--- a/grails-data-hibernate7/core/src/main/groovy/grails/orm/CriteriaMethodInvoker.java
+++ b/grails-data-hibernate7/core/src/main/groovy/grails/orm/CriteriaMethodInvoker.java
@@ -80,7 +80,7 @@ public class CriteriaMethodInvoker {
             case SCROLL_CALL -> builder.setScroll(true);
             case COUNT_CALL -> builder.setCount(true);
             case LIST_DISTINCT_CALL -> builder.setDistinct(true);
-            default -> { }
+            default -> {}
         }
 
         // Check for pagination params
@@ -115,9 +115,9 @@ public class CriteriaMethodInvoker {
                             !(argMap.get(HibernateQueryArgument.IGNORE_CASE.value()) instanceof Boolean b) || b;
                     final String orderParam = (String) argMap.get(HibernateQueryArgument.ORDER.value());
                     final Query.Order.Direction direction =
-                            Query.Order.Direction.DESC.name().equalsIgnoreCase(orderParam) ?
-                                    Query.Order.Direction.DESC :
-                                    Query.Order.Direction.ASC;
+                            Query.Order.Direction.DESC.name().equalsIgnoreCase(orderParam)
+                                    ? Query.Order.Direction.DESC
+                                    : Query.Order.Direction.ASC;
                     Query.Order order;
                     order = new Query.Order(sortField, direction);
                     if (ignoreCase) {
@@ -234,7 +234,10 @@ public class CriteriaMethodInvoker {
                 case CREATE_ALIAS:
                     if (args.length == 2 && args[0] instanceof String s && args[1] instanceof String a) {
                         return builder.createAlias(s, a);
-                    } else if (args.length == 3 && args[0] instanceof String s && args[1] instanceof String a && args[2] instanceof Number jt) {
+                    } else if (args.length == 3
+                            && args[0] instanceof String s
+                            && args[1] instanceof String a
+                            && args[2] instanceof Number jt) {
                         return builder.createAlias(s, a, jt.intValue());
                     }
                     return name;
@@ -245,7 +248,7 @@ public class CriteriaMethodInvoker {
                             case IS_NOT_NULL -> builder.getHibernateQuery().isNotNull(value);
                             case IS_EMPTY -> builder.getHibernateQuery().isEmpty(value);
                             case IS_NOT_EMPTY -> builder.getHibernateQuery().isNotEmpty(value);
-                            default -> { }
+                            default -> {}
                         }
                         return name;
                     } else if (args.length == 1 && args[0] != null) {
@@ -339,17 +342,17 @@ public class CriteriaMethodInvoker {
     }
 
     private boolean isCriteriaConstructionMethod(CriteriaMethods method, Object... args) {
-        return (method == CriteriaMethods.LIST_CALL &&
-                        args.length == 2 &&
-                        args[0] instanceof Map<?, ?> &&
-                        args[1] instanceof Closure) ||
-                (method == CriteriaMethods.ROOT_CALL ||
-                        method == CriteriaMethods.ROOT_DO_CALL ||
-                        method == CriteriaMethods.LIST_CALL ||
-                        method == CriteriaMethods.LIST_DISTINCT_CALL ||
-                        method == CriteriaMethods.GET_CALL ||
-                        method == CriteriaMethods.COUNT_CALL ||
-                        (method == CriteriaMethods.SCROLL_CALL && args.length == 1 && args[0] instanceof Closure));
+        return (method == CriteriaMethods.LIST_CALL
+                        && args.length == 2
+                        && args[0] instanceof Map<?, ?>
+                        && args[1] instanceof Closure)
+                || (method == CriteriaMethods.ROOT_CALL
+                        || method == CriteriaMethods.ROOT_DO_CALL
+                        || method == CriteriaMethods.LIST_CALL
+                        || method == CriteriaMethods.LIST_DISTINCT_CALL
+                        || method == CriteriaMethods.GET_CALL
+                        || method == CriteriaMethods.COUNT_CALL
+                        || (method == CriteriaMethods.SCROLL_CALL && args.length == 1 && args[0] instanceof Closure));
     }
 
     private void invokeClosureNode(Object args) {
diff --git a/grails-data-hibernate7/core/src/main/groovy/grails/orm/CriteriaMethods.java b/grails-data-hibernate7/core/src/main/groovy/grails/orm/CriteriaMethods.java
index 73538fa6f7..1c00070574 100644
--- a/grails-data-hibernate7/core/src/main/groovy/grails/orm/CriteriaMethods.java
+++ b/grails-data-hibernate7/core/src/main/groovy/grails/orm/CriteriaMethods.java
@@ -83,7 +83,7 @@ public enum CriteriaMethods {
      * @return The corresponding CriteriaMethods enum
      * @throws MissingMethodException if the method name is not recognized
      */
-    public static CriteriaMethods fromName(String name, Class<?> targetClass, Object[] args) {
+    public static CriteriaMethods fromName(String name, Class<?> targetClass, Object... args) {
         for (CriteriaMethods m : values()) {
             if (m.name.equals(name)) {
                 return m;
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/CloseSuppressingInvocationHandler.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/CloseSuppressingInvocationHandler.java
index d51dc0bb4f..bc884d7b37 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/CloseSuppressingInvocationHandler.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/CloseSuppressingInvocationHandler.java
@@ -20,6 +20,7 @@ package org.grails.orm.hibernate;
 
 import java.lang.reflect.InvocationHandler;
 import java.lang.reflect.Method;
+import java.util.Objects;
 
 import org.hibernate.Session;
 import org.hibernate.query.Query;
@@ -47,18 +48,19 @@ public class CloseSuppressingInvocationHandler implements InvocationHandler {
         switch (method.getName()) {
             case "equals" -> {
                 // Only consider equal when proxies are identical.
-                return (proxy == args[0]);
-                // Only consider equal when proxies are identical.
+                return Objects.equals(proxy, args[0]);
             }
             case "hashCode" -> {
                 // Use hashCode of Session proxy.
                 return System.identityHashCode(proxy);
-                // Use hashCode of Session proxy.
             }
             case "close" -> {
                 // Handle close method: suppress, not valid.
                 return null;
             }
+            default -> {
+                // do nothing
+            }
         }
 
         Object retVal = method.invoke(target, args);
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/access/TraitPropertyAccessStrategy.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/access/TraitPropertyAccessStrategy.java
index b7b58cc7c2..511e7bc25a 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/access/TraitPropertyAccessStrategy.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/access/TraitPropertyAccessStrategy.java
@@ -68,19 +68,18 @@ public class TraitPropertyAccessStrategy implements PropertyAccessStrategy {
             // See https://issues.apache.org/jira/browse/GROOVY-11512
             Method booleanReadMethod =
                     ReflectionUtils.findMethod(containerJavaType, NameUtils.getGetterName(propertyName, true));
-            if (booleanReadMethod != null &&
-                    (booleanReadMethod.getReturnType() == Boolean.class ||
-                            booleanReadMethod.getReturnType() == boolean.class)) {
+            if (booleanReadMethod != null
+                    && (booleanReadMethod.getReturnType() == Boolean.class
+                            || booleanReadMethod.getReturnType() == boolean.class)) {
                 readMethod = booleanReadMethod;
             }
         }
 
         if (readMethod == null) {
-            throw new IllegalStateException("TraitPropertyAccessStrategy used on property [" +
-                    propertyName +
-                    "] of class [" +
-                    containerJavaType.getName() +
-                    "] that is not provided by a trait!");
+            throw new IllegalStateException("TraitPropertyAccessStrategy used on property [" + propertyName
+                    + "] of class ["
+                    + containerJavaType.getName()
+                    + "] that is not provided by a trait!");
         }
 
         Traits.Implemented traitImplemented = readMethod.getAnnotation(Traits.Implemented.class);
@@ -90,11 +89,10 @@ public class TraitPropertyAccessStrategy implements PropertyAccessStrategy {
             if (traitBridge != null) {
                 traitFieldName = getTraitFieldName(traitBridge.traitClass(), propertyName);
             } else {
-                throw new IllegalStateException("TraitPropertyAccessStrategy used on property [" +
-                        propertyName +
-                        "] of class [" +
-                        containerJavaType.getName() +
-                        "] that is not provided by a trait!");
+                throw new IllegalStateException("TraitPropertyAccessStrategy used on property [" + propertyName
+                        + "] of class ["
+                        + containerJavaType.getName()
+                        + "] that is not provided by a trait!");
             }
         } else {
             traitFieldName = getTraitFieldName(readMethod.getDeclaringClass(), propertyName);
@@ -109,11 +107,10 @@ public class TraitPropertyAccessStrategy implements PropertyAccessStrategy {
                     containerJavaType, NameUtils.getSetterName(propertyName), readMethod.getReturnType());
             if (writeMethod == null) {
                 if (setterRequired) {
-                    throw new MappingException("TraitPropertyAccessStrategy used on property [" +
-                            propertyName +
-                            "] of class [" +
-                            containerJavaType.getName() +
-                            "] that has no setter!");
+                    throw new MappingException("TraitPropertyAccessStrategy used on property [" + propertyName
+                            + "] of class ["
+                            + containerJavaType.getName()
+                            + "] that has no setter!");
                 }
                 setter = null;
             } else {
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/HibernateMappingContext.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/HibernateMappingContext.java
index e2ab028515..11ec0e9676 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/HibernateMappingContext.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/HibernateMappingContext.java
@@ -52,20 +52,18 @@ public class HibernateMappingContext extends AbstractMappingContext {
     }
 
     public HibernateMappingContext(
-            HibernateConnectionSourceSettings settings, Object contextObject, Class... persistentClasses) {
+            HibernateConnectionSourceSettings settings, Object contextObject, Class<?>... persistentClasses) {
         this.mappingFactory = new HibernateMappingFactory();
         initialize(settings);
-        if (settings != null) {
-            this.mappingFactory.setDefaultMapping(settings.getDefault().getMapping());
-            this.mappingFactory.setDefaultConstraints(settings.getDefault().getConstraints());
-        }
+        this.mappingFactory.setDefaultMapping(settings.getDefault().getMapping());
+        this.mappingFactory.setDefaultConstraints(settings.getDefault().getConstraints());
         this.mappingFactory.setContextObject(contextObject);
         this.syntaxStrategy = new GrailsJpaMappingConfigurationStrategy(mappingFactory);
         this.proxyFactory = new HibernateProxyHandler();
         addPersistentEntities(persistentClasses);
     }
 
-    public HibernateMappingContext(HibernateConnectionSourceSettings settings, Class... persistentClasses) {
+    public HibernateMappingContext(HibernateConnectionSourceSettings settings, Class<?>... persistentClasses) {
         this(settings, null, persistentClasses);
     }
 
@@ -73,7 +71,7 @@ public class HibernateMappingContext extends AbstractMappingContext {
         this(new HibernateConnectionSourceSettings());
     }
 
-    public void setDefaultConstraints(Closure defaultConstraints) {
+    public void setDefaultConstraints(Closure<?> defaultConstraints) {
         this.mappingFactory.setDefaultConstraints(defaultConstraints);
     }
 
@@ -83,12 +81,12 @@ public class HibernateMappingContext extends AbstractMappingContext {
     }
 
     @Override
-    public MappingFactory getMappingFactory() {
+    public MappingFactory<?,?> getMappingFactory() {
         return mappingFactory;
     }
 
     @Override
-    protected PersistentEntity createPersistentEntity(Class javaClass) {
+    protected PersistentEntity createPersistentEntity(Class<?> javaClass) {
         if (GormEntity.class.isAssignableFrom(javaClass)) {
             Object mappingStrategy = resolveMappingStrategy(javaClass);
             if (isValidMappingStrategy(javaClass, mappingStrategy)) {
@@ -99,18 +97,18 @@ public class HibernateMappingContext extends AbstractMappingContext {
     }
 
     @Override
-    protected boolean isValidMappingStrategy(Class javaClass, Object mappingStrategy) {
-        return HibernateEntity.class.isAssignableFrom(javaClass) ||
-                super.isValidMappingStrategy(javaClass, mappingStrategy);
+    protected boolean isValidMappingStrategy(Class<?> javaClass, Object mappingStrategy) {
+        return HibernateEntity.class.isAssignableFrom(javaClass)
+                || super.isValidMappingStrategy(javaClass, mappingStrategy);
     }
 
     @Override
-    protected PersistentEntity createPersistentEntity(Class javaClass, boolean external) {
+    protected PersistentEntity createPersistentEntity(Class<?> javaClass, boolean external) {
         return createPersistentEntity(javaClass);
     }
 
     @Override
-    public PersistentEntity createEmbeddedEntity(Class type) {
+    public PersistentEntity createEmbeddedEntity(Class<?> type) {
         HibernateEmbeddedPersistentEntity embedded = new HibernateEmbeddedPersistentEntity(type, this);
         embedded.initialize();
         return embedded;
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/HibernateMappingContextConfiguration.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/HibernateMappingContextConfiguration.java
index c423cbb617..7d7ad0012c 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/HibernateMappingContextConfiguration.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/HibernateMappingContextConfiguration.java
@@ -29,7 +29,6 @@ import java.util.List;
 import java.util.Map;
 import java.util.Properties;
 import java.util.Set;
-
 import javax.sql.DataSource;
 
 import jakarta.annotation.Nullable;
@@ -141,7 +140,9 @@ public class HibernateMappingContextConfiguration extends Configuration
                 properties.put(JdbcSettings.JAKARTA_NON_JTA_DATASOURCE, applicationContext.getBean(dsName));
             }
             properties.put(Environment.CURRENT_SESSION_CONTEXT_CLASS, currentSessionContext.getName());
-            properties.put("hibernate.enhancer.bytecodeprovider.instance", new org.grails.orm.hibernate.proxy.GrailsBytecodeProvider());
+            properties.put(
+                    "hibernate.enhancer.bytecodeprovider.instance",
+                    new org.grails.orm.hibernate.proxy.GrailsBytecodeProvider());
             properties.put("hibernate.bytecode.allow_enhancement_as_proxy", "false");
             properties.put("hibernate.bytecode.enhancement_metadata_cache", "false");
             properties.put("hibernate.enhancer.enableLazyInitialization", "false");
@@ -165,8 +166,8 @@ public class HibernateMappingContextConfiguration extends Configuration
         getProperties().put(JdbcSettings.JAKARTA_NON_JTA_DATASOURCE, source);
         getProperties().put(Environment.CURRENT_SESSION_CONTEXT_CLASS, GrailsSessionContext.class.getName());
         final ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
-        if (contextClassLoader != null &&
-                contextClassLoader.getClass().getSimpleName().equalsIgnoreCase("RestartClassLoader")) {
+        if (contextClassLoader != null
+                && contextClassLoader.getClass().getSimpleName().equalsIgnoreCase("RestartClassLoader")) {
             getProperties().put(AvailableSettings.CLASSLOADERS, contextClassLoader);
         } else {
             getProperties()
@@ -221,9 +222,9 @@ public class HibernateMappingContextConfiguration extends Configuration
         try {
             MetadataReaderFactory readerFactory = new CachingMetadataReaderFactory(resourcePatternResolver);
             for (String pkg : packagesToScan) {
-                String pattern = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
-                        ClassUtils.convertClassNameToResourcePath(pkg) +
-                        RESOURCE_PATTERN;
+                String pattern = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX
+                        + ClassUtils.convertClassNameToResourcePath(pkg)
+                        + RESOURCE_PATTERN;
                 Resource[] resources = resourcePatternResolver.getResources(pattern);
                 for (Resource resource : resources) {
                     if (resource.isReadable()) {
@@ -231,9 +232,9 @@ public class HibernateMappingContextConfiguration extends Configuration
                         String className = reader.getClassMetadata().getClassName();
                         if (matchesFilter(reader, readerFactory)) {
                             ClassLoader classLoader = resourcePatternResolver.getClassLoader();
-                            Class<?> loadedClass = classLoader != null ?
-                                    classLoader.loadClass(className) :
-                                    ClassUtils.forName(className, null);
+                            Class<?> loadedClass = classLoader != null
+                                    ? classLoader.loadClass(className)
+                                    : ClassUtils.forName(className, null);
                             addAnnotatedClasses(loadedClass);
                         }
                     }
@@ -274,10 +275,10 @@ public class HibernateMappingContextConfiguration extends Configuration
     public SessionFactory buildSessionFactory() throws HibernateException {
         // 1. FORCE the custom bytecode provider instance right before bootstrap
         // This bypasses the ServiceLoader and ensures your GrailsBytecodeProvider is used.
-        getProperties().put(
-                BytecodeSettings.BYTECODE_PROVIDER_INSTANCE,
-                new org.grails.orm.hibernate.proxy.GrailsBytecodeProvider()
-        );
+        getProperties()
+                .put(
+                        BytecodeSettings.BYTECODE_PROVIDER_INSTANCE,
+                        new org.grails.orm.hibernate.proxy.GrailsBytecodeProvider());
 
         // set the class loader to load Groovy classes
 
@@ -295,17 +296,16 @@ public class HibernateMappingContextConfiguration extends Configuration
 
         ConfigurationHelper.resolvePlaceHolders(getProperties());
 
-        final GrailsDomainBinder domainBinder =
-                new GrailsDomainBinder(
-                        dataSourceName,
-                        sessionFactoryBeanName,
-                        hibernateMappingContext,
-                        namingStrategyProvider,
-                        hibernateMappingContext.getMappingCacheHolder());
+        final GrailsDomainBinder domainBinder = new GrailsDomainBinder(
+                dataSourceName,
+                sessionFactoryBeanName,
+                hibernateMappingContext,
+                namingStrategyProvider,
+                hibernateMappingContext.getMappingCacheHolder());
 
         List<Class> annotatedClasses = new ArrayList<>();
         for (PersistentEntity persistentEntity : hibernateMappingContext.getPersistentEntities()) {
-            Class javaClass = persistentEntity.getJavaClass();
+            Class<?> javaClass = persistentEntity.getJavaClass();
             if (javaClass.isAnnotationPresent(Entity.class)) {
                 annotatedClasses.add(javaClass);
             }
@@ -356,7 +356,8 @@ public class HibernateMappingContextConfiguration extends Configuration
         StandardServiceRegistryBuilder standardServiceRegistryBuilder =
                 createStandardServiceRegistryBuilder(bootstrapServiceRegistry).applySettings(getProperties());
 
-        org.grails.orm.hibernate.proxy.GrailsBytecodeProvider bytecodeProvider = new org.grails.orm.hibernate.proxy.GrailsBytecodeProvider();
+        org.grails.orm.hibernate.proxy.GrailsBytecodeProvider bytecodeProvider =
+                new org.grails.orm.hibernate.proxy.GrailsBytecodeProvider();
         standardServiceRegistryBuilder.addService(org.hibernate.bytecode.spi.BytecodeProvider.class, bytecodeProvider);
 
         StandardServiceRegistry ssr = standardServiceRegistryBuilder.build();
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/ClassPropertiesBinder.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/ClassPropertiesBinder.java
index 95ad8308bc..8dca67f1de 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/ClassPropertiesBinder.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/ClassPropertiesBinder.java
@@ -61,9 +61,9 @@ public class ClassPropertiesBinder {
     public void bindClassProperties(HibernatePersistentEntity hibernatePersistentEntity) {
         PersistentClass persistentClass = hibernatePersistentEntity.getPersistentClass();
         getTable(persistentClass).setComment(hibernatePersistentEntity.getComment());
-        for (HibernatePersistentProperty currentGrailsProp : hibernatePersistentEntity.getPersistentPropertiesToBind()) {
-            Value value = grailsPropertyBinder.bindProperty(
-                    currentGrailsProp, null, GrailsDomainBinder.EMPTY_PATH);
+        for (HibernatePersistentProperty currentGrailsProp :
+                hibernatePersistentEntity.getPersistentPropertiesToBind()) {
+            Value value = grailsPropertyBinder.bindProperty(currentGrailsProp, null, GrailsDomainBinder.EMPTY_PATH);
             persistentClass.addProperty(propertyFromValueCreator.createProperty(value, currentGrailsProp));
         }
 
@@ -73,9 +73,8 @@ public class ClassPropertiesBinder {
     @Nonnull
     private Table getTable(PersistentClass persistentClass) {
         if (persistentClass.getTable() == null) {
-            throw new MappingException("Persistent class [" +
-                    persistentClass.getEntityName() +
-                    "] does not have a table associated with it");
+            throw new MappingException("Persistent class [" + persistentClass.getEntityName()
+                    + "] does not have a table associated with it");
         }
         return persistentClass.getTable();
     }
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/CollectionBinder.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/CollectionBinder.java
index f7acc414cc..1bdfe301cb 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/CollectionBinder.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/CollectionBinder.java
@@ -145,7 +145,8 @@ public class CollectionBinder {
 
         // set role
         String propertyName = getNameForPropertyAndPath(property, path);
-        collection.setRole(GrailsHibernateUtil.qualify(property.getHibernateOwner().getName(), propertyName));
+        collection.setRole(
+                GrailsHibernateUtil.qualify(property.getHibernateOwner().getName(), propertyName));
 
         PropertyConfig pc = property.getHibernateMappedForm();
         // configure eager fetching
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/CollectionForPropertyConfigBinder.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/CollectionForPropertyConfigBinder.java
index 724bf9f09c..142c56b711 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/CollectionForPropertyConfigBinder.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/CollectionForPropertyConfigBinder.java
@@ -22,7 +22,6 @@ import java.util.Optional;
 
 import jakarta.annotation.Nonnull;
 
-import org.hibernate.FetchMode;
 import org.hibernate.mapping.Collection;
 
 import org.grails.orm.hibernate.cfg.domainbinding.hibernate.HibernateToManyProperty;
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/ColumnBinder.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/ColumnBinder.java
index 87ec82cc66..0bf1cb53b5 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/ColumnBinder.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/ColumnBinder.java
@@ -126,11 +126,10 @@ public class ColumnBinder {
             Mapping mapping = owner.getHibernateMappedForm();
             if (mapping != null && mapping.getTablePerHierarchy()) {
                 if (LOG.isDebugEnabled())
-                    LOG.debug("[GrailsDomainBinder] Sub class property [" +
-                            property.getName() +
-                            "] for column name [" +
-                            column.getName() +
-                            "] set to nullable");
+                    LOG.debug("[GrailsDomainBinder] Sub class property [" + property.getName()
+                            + "] for column name ["
+                            + column.getName()
+                            + "] set to nullable");
                 column.setNullable(true);
             } else {
                 column.setNullable(property.isNullable());
@@ -142,12 +141,11 @@ public class ColumnBinder {
         column.setUnique(mappedFormFinal.isUnique() && !mappedFormFinal.isUniqueWithinGroup());
 
         if (LOG.isDebugEnabled())
-            LOG.debug("[GrailsDomainBinder] bound property [" +
-                    property.getName() +
-                    "] to column name [" +
-                    column.getName() +
-                    "] in table [" +
-                    table.getName() +
-                    "]");
+            LOG.debug("[GrailsDomainBinder] bound property [" + property.getName()
+                    + "] to column name ["
+                    + column.getName()
+                    + "] in table ["
+                    + table.getName()
+                    + "]");
     }
 }
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/ComponentBinder.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/ComponentBinder.java
index 658b57e903..44c69b64dd 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/ComponentBinder.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/ComponentBinder.java
@@ -70,11 +70,13 @@ public class ComponentBinder {
         String currentPath = path.isEmpty() ? embeddedProperty.getName() : path + "." + embeddedProperty.getName();
         Class<?> propertyType = embeddedProperty.getOwner().getJavaClass();
 
-        associatedEntity.getHibernateParentProperty(propertyType).ifPresent(p -> component.setParentProperty(p.getName()));
+        associatedEntity
+                .getHibernateParentProperty(propertyType)
+                .ifPresent(p -> component.setParentProperty(p.getName()));
 
-        for (HibernatePersistentProperty peerProperty : associatedEntity.getHibernatePersistentProperties(propertyType)) {
-            var value = grailsPropertyBinder.bindProperty(
-                    peerProperty, embeddedProperty, currentPath);
+        for (HibernatePersistentProperty peerProperty :
+                associatedEntity.getHibernatePersistentProperties(propertyType)) {
+            var value = grailsPropertyBinder.bindProperty(peerProperty, embeddedProperty, currentPath);
             componentUpdater.updateComponent(component, embeddedProperty, peerProperty, value);
         }
         return component;
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/ComponentUpdater.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/ComponentUpdater.java
index 7089597a58..90e7ae0812 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/ComponentUpdater.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/ComponentUpdater.java
@@ -41,8 +41,8 @@ public class ComponentUpdater {
             Value value) {
         Property persistentProperty = propertyFromValueCreator.createProperty(value, currentGrailsProp);
         component.addProperty(persistentProperty);
-        if (componentProperty != null &&
-                componentProperty.getHibernateOwner().isComponentPropertyNullable(componentProperty)) {
+        if (componentProperty != null
+                && componentProperty.getHibernateOwner().isComponentPropertyNullable(componentProperty)) {
             for (Column c : value.getColumns()) {
                 c.setNullable(true);
             }
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/CompositeIdBinder.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/CompositeIdBinder.java
index f8c49fa5b4..395a43309c 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/CompositeIdBinder.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/CompositeIdBinder.java
@@ -49,7 +49,9 @@ public class CompositeIdBinder {
     }
 
     public void bindCompositeId(
-            @Nonnull HibernatePersistentEntity hibernatePersistentEntity, RootClass root, CompositeIdentity compositeIdentity) {
+            @Nonnull HibernatePersistentEntity hibernatePersistentEntity,
+            RootClass root,
+            CompositeIdentity compositeIdentity) {
         hibernatePersistentEntity.setPersistentClass(root);
         Component id = new Component(metadataBuildingContext, root);
         id.setNullValue("undefined");
@@ -64,12 +66,13 @@ public class CompositeIdBinder {
 
         id.setRoleName(path);
 
-        HibernatePersistentProperty[] composite = compositeIdentity != null ?
-                compositeIdentity.getHibernateProperties(hibernatePersistentEntity) :
-                hibernatePersistentEntity.getCompositeIdentity();
+        HibernatePersistentProperty[] composite = compositeIdentity != null
+                ? compositeIdentity.getHibernateProperties(hibernatePersistentEntity)
+                : hibernatePersistentEntity.getCompositeIdentity();
 
         if (composite == null || composite.length == 0) {
-            throw new MappingException("No composite identifier properties found for class [" + hibernatePersistentEntity.getName() + "]");
+            throw new MappingException(
+                    "No composite identifier properties found for class [" + hibernatePersistentEntity.getName() + "]");
         }
         PersistentClass persistentClass = hibernatePersistentEntity.getPersistentClass();
         Table table = persistentClass.getTable();
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/CompositeIdentifierToManyToOneBinder.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/CompositeIdentifierToManyToOneBinder.java
index 99e664eb40..bbcf3bfc16 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/CompositeIdentifierToManyToOneBinder.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/CompositeIdentifierToManyToOneBinder.java
@@ -84,8 +84,8 @@ public class CompositeIdentifierToManyToOneBinder {
         String[] propertyNames = compositeId.getPropertyNames();
         List<ColumnConfig> columns = property.getHibernateMappedForm().getColumns();
         int existingCount = columns.size();
-        if (existingCount !=
-                foreignKeyColumnCountCalculator.calculateForeignKeyColumnCount(refDomainClass, propertyNames)) {
+        if (existingCount
+                != foreignKeyColumnCountCalculator.calculateForeignKeyColumnCount(refDomainClass, propertyNames)) {
             String prefix = refDomainClass.getTableName(namingStrategy);
             IntStream.range(0, propertyNames.length)
                     .boxed()
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/EnumTypeBinder.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/EnumTypeBinder.java
index b9fc7889c8..ee3078d2b7 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/EnumTypeBinder.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/EnumTypeBinder.java
@@ -37,7 +37,6 @@ import org.grails.orm.hibernate.cfg.PropertyConfig;
 import org.grails.orm.hibernate.cfg.domainbinding.hibernate.HibernateBasicProperty;
 import org.grails.orm.hibernate.cfg.domainbinding.hibernate.HibernateEnumProperty;
 import org.grails.orm.hibernate.cfg.domainbinding.hibernate.HibernatePersistentProperty;
-import org.grails.orm.hibernate.cfg.domainbinding.hibernate.HibernateToManyProperty;
 import org.grails.orm.hibernate.cfg.domainbinding.util.ColumnNameForPropertyAndPathFetcher;
 import org.grails.orm.hibernate.cfg.domainbinding.util.GrailsEnumType;
 
@@ -53,19 +52,22 @@ public class EnumTypeBinder {
 
     public EnumTypeBinder(
             MetadataBuildingContext metadataBuildingContext,
-            ColumnNameForPropertyAndPathFetcher columnNameForPropertyAndPathFetcher, PersistentEntityNamingStrategy namingStrategy) {
+            ColumnNameForPropertyAndPathFetcher columnNameForPropertyAndPathFetcher,
+            PersistentEntityNamingStrategy namingStrategy) {
         this(
                 metadataBuildingContext,
                 columnNameForPropertyAndPathFetcher,
                 new IndexBinder(),
-                new ColumnConfigToColumnBinder(), namingStrategy);
+                new ColumnConfigToColumnBinder(),
+                namingStrategy);
     }
 
     protected EnumTypeBinder(
             MetadataBuildingContext metadataBuildingContext,
             ColumnNameForPropertyAndPathFetcher columnNameForPropertyAndPathFetcher,
             IndexBinder indexBinder,
-            ColumnConfigToColumnBinder columnConfigToColumnBinder, PersistentEntityNamingStrategy namingStrategy) {
+            ColumnConfigToColumnBinder columnConfigToColumnBinder,
+            PersistentEntityNamingStrategy namingStrategy) {
         this.metadataBuildingContext = metadataBuildingContext;
         this.columnNameForPropertyAndPathFetcher = columnNameForPropertyAndPathFetcher;
         this.indexBinder = indexBinder;
@@ -86,10 +88,10 @@ public class EnumTypeBinder {
         return simpleValue;
     }
 
-    public BasicValue bindEnumTypeForColumn(@Nonnull HibernateBasicProperty property, @Nonnull String _columnName) {
+    public BasicValue bindEnumTypeForColumn(@Nonnull HibernateBasicProperty property) {
         String columnName = property.joinTableColumName(namingStrategy);
         BasicValue simpleValue = new BasicValue(metadataBuildingContext, property.getTable());
-        bindEnumType(property,  property.getComponentType(), simpleValue, columnName);
+        bindEnumType(property, property.getComponentType(), simpleValue, columnName);
         return simpleValue;
     }
 
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/ForeignKeyOneToOneBinder.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/ForeignKeyOneToOneBinder.java
index 9b63fdb357..2269135f35 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/ForeignKeyOneToOneBinder.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/ForeignKeyOneToOneBinder.java
@@ -67,8 +67,8 @@ public class ForeignKeyOneToOneBinder {
         }
         if (!config.isUniqueWithinGroup()) {
             c.setUnique(config.isUnique());
-        } else if (property.isBidirectional() &&
-                property.getHibernateInverseSide().isValidHibernateOneToOne()) {
+        } else if (property.isBidirectional()
+                && property.getHibernateInverseSide().isValidHibernateOneToOne()) {
             c.setUnique(true);
         }
     }
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/GrailsDomainBinder.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/GrailsDomainBinder.java
index 6d5c1b51c3..f16f5cd717 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/GrailsDomainBinder.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/GrailsDomainBinder.java
@@ -81,7 +81,12 @@ public class GrailsDomainBinder implements AdditionalMappingContributor, TypeCon
 
     public GrailsDomainBinder(
             String dataSourceName, String sessionFactoryName, HibernateMappingContext hibernateMappingContext) {
-        this(dataSourceName, sessionFactoryName, hibernateMappingContext, new NamingStrategyProvider(), new MappingCacheHolder());
+        this(
+                dataSourceName,
+                sessionFactoryName,
+                hibernateMappingContext,
+                new NamingStrategyProvider(),
+                new MappingCacheHolder());
     }
 
     public GrailsDomainBinder(
@@ -229,8 +234,7 @@ public class GrailsDomainBinder implements AdditionalMappingContributor, TypeCon
                 metadataCollector,
                 mappingCacheHolder);
 
-        hibernateMappingContext.getHibernatePersistentEntities(dataSourceName)
-                .stream()
+        hibernateMappingContext.getHibernatePersistentEntities(dataSourceName).stream()
                 .filter(persistentEntity -> persistentEntity.forGrailsDomainMapping(dataSourceName))
                 .forEach(rootBinder::bindRoot);
     }
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/GrailsPropertyBinder.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/GrailsPropertyBinder.java
index cf92cfc134..a154bfbb87 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/GrailsPropertyBinder.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/GrailsPropertyBinder.java
@@ -25,13 +25,13 @@ import org.hibernate.mapping.Value;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import org.grails.orm.hibernate.cfg.domainbinding.hibernate.HibernateCustomProperty;
 import org.grails.orm.hibernate.cfg.domainbinding.hibernate.HibernateEmbeddedProperty;
 import org.grails.orm.hibernate.cfg.domainbinding.hibernate.HibernateEnumProperty;
 import org.grails.orm.hibernate.cfg.domainbinding.hibernate.HibernateManyToOneProperty;
 import org.grails.orm.hibernate.cfg.domainbinding.hibernate.HibernateOneToOneProperty;
 import org.grails.orm.hibernate.cfg.domainbinding.hibernate.HibernatePersistentProperty;
 import org.grails.orm.hibernate.cfg.domainbinding.hibernate.HibernateSimpleProperty;
-import org.grails.orm.hibernate.cfg.domainbinding.hibernate.HibernateCustomProperty;
 import org.grails.orm.hibernate.cfg.domainbinding.hibernate.HibernateTenantIdProperty;
 import org.grails.orm.hibernate.cfg.domainbinding.hibernate.HibernateToManyProperty;
 
@@ -65,7 +65,9 @@ public class GrailsPropertyBinder {
     }
 
     public Value bindProperty(
-            @Nonnull HibernatePersistentProperty currentGrailsProp, HibernatePersistentProperty parentProperty, String path) {
+            @Nonnull HibernatePersistentProperty currentGrailsProp,
+            HibernatePersistentProperty parentProperty,
+            String path) {
         Table table = currentGrailsProp.getTable();
         if (LOG.isDebugEnabled()) {
             LOG.debug("[GrailsPropertyBinder] Binding persistent property [" + currentGrailsProp.getName() + "]");
@@ -95,10 +97,12 @@ public class GrailsPropertyBinder {
             value = simpleValueBinder.bindSimpleValue(custom, parentProperty, table, path);
         } else if (currentGrailsProp instanceof HibernateTenantIdProperty tenantId) {
             value = simpleValueBinder.bindSimpleValue(tenantId, parentProperty, table, path);
-        } else if (currentGrailsProp instanceof HibernateToManyProperty toMany && currentGrailsProp.isSerializableType()) {
+        } else if (currentGrailsProp instanceof HibernateToManyProperty toMany
+                && currentGrailsProp.isSerializableType()) {
             value = simpleValueBinder.bindSimpleValue(toMany, parentProperty, table, path);
         } else {
-            throw new RuntimeException("Unsupported property type: " + currentGrailsProp.getClass().getName());
+            throw new RuntimeException(
+                    "Unsupported property type: " + currentGrailsProp.getClass().getName());
         }
 
         return value;
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/JoinedSubClassBinder.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/JoinedSubClassBinder.java
index da26cae58d..70af5ac708 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/JoinedSubClassBinder.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/JoinedSubClassBinder.java
@@ -89,10 +89,9 @@ public class JoinedSubClassBinder {
 
         joinedSubclass.setTable(mytable);
         if (LOG.isInfoEnabled()) {
-            LOG.info("Mapping joined-subclass: " +
-                    joinedSubclass.getEntityName() +
-                    " -> " +
-                    joinedSubclass.getTable().getName());
+            LOG.info("Mapping joined-subclass: " + joinedSubclass.getEntityName()
+                    + " -> "
+                    + joinedSubclass.getTable().getName());
         }
 
         SimpleValue key = new DependantValue(metadataBuildingContext, mytable, joinedSubclass.getIdentifier());
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/NumericColumnConstraintsBinder.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/NumericColumnConstraintsBinder.java
index 9dad2d3837..fd1a3b4aea 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/NumericColumnConstraintsBinder.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/NumericColumnConstraintsBinder.java
@@ -22,6 +22,7 @@ import java.math.BigDecimal;
 import java.util.Optional;
 
 import org.codehaus.groovy.runtime.DefaultGroovyMethods;
+
 import org.hibernate.dialect.Dialect;
 import org.hibernate.dialect.H2Dialect;
 import org.hibernate.dialect.OracleDialect;
@@ -65,21 +66,18 @@ public class NumericColumnConstraintsBinder {
                 defaultPrecision = 15;
             }
 
-            int precision = minConstraintValueLength > 0 && maxConstraintValueLength > 0 ?
-                    Math.max(minConstraintValueLength, maxConstraintValueLength) :
-                    DefaultGroovyMethods.max(new Integer[] {
-                        defaultPrecision,
-                        minConstraintValueLength,
-                        maxConstraintValueLength
-                    });
+            int precision = minConstraintValueLength > 0 && maxConstraintValueLength > 0
+                    ? Math.max(minConstraintValueLength, maxConstraintValueLength)
+                    : DefaultGroovyMethods.max(
+                            new Integer[] {defaultPrecision, minConstraintValueLength, maxConstraintValueLength});
             column.setPrecision(precision);
         }
     }
 
-    private int getConstraintValueLength(Comparable min, int scale) {
-        return min instanceof Number number ?
-                Math.max(countDigits(number), countDigits((number).longValue()) + scale) :
-                0;
+    private int getConstraintValueLength(Comparable<?> min, int scale) {
+        return min instanceof Number number
+                ? Math.max(countDigits(number), countDigits((number).longValue()) + scale)
+                : 0;
     }
 
     private int countDigits(Number number) {
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/OneToOneBinder.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/OneToOneBinder.java
index cb75ac5a34..0dc991c0f9 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/OneToOneBinder.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/OneToOneBinder.java
@@ -35,9 +35,7 @@ public class OneToOneBinder {
         this.simpleValueBinder = simpleValueBinder;
     }
 
-    public OneToOne bindOneToOne(
-            final HibernateOneToOneProperty property,
-            String path) {
+    public OneToOne bindOneToOne(final HibernateOneToOneProperty property, String path) {
         Table table = property.getTable();
         PersistentClass owner = property.getHibernateOwner().getPersistentClass();
         OneToOne oneToOne = new OneToOne(metadataBuildingContext, table, owner);
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/PropertyBinder.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/PropertyBinder.java
index 15845dabe3..7f775fbc60 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/PropertyBinder.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/PropertyBinder.java
@@ -65,8 +65,8 @@ public class PropertyBinder {
             config = new PropertyConfig();
         }
 
-        if (persistentProperty instanceof HibernateAssociation assoc &&
-                assoc.isBidirectionalManyToOneWithListMapping(prop)) {
+        if (persistentProperty instanceof HibernateAssociation assoc
+                && assoc.isBidirectionalManyToOneWithListMapping(prop)) {
             prop.setInsertable(false);
             prop.setUpdatable(false);
         } else {
@@ -76,18 +76,18 @@ public class PropertyBinder {
 
         var accessType = AccessType.getAccessStrategy(config.getAccessType());
 
-        var accessorName = accessType == AccessType.FIELD ?
-                Optional.ofNullable(persistentProperty.getReader())
+        var accessorName = accessType == AccessType.FIELD
+                ? Optional.ofNullable(persistentProperty.getReader())
                         .map(EntityReflector.PropertyReader::getter)
                         .map(getter -> getter.getAnnotation(Traits.Implemented.class))
                         .map(annotation -> TraitPropertyAccessStrategy.class.getName())
-                        .orElse(accessType.getType()) :
-                accessType.getType();
+                        .orElse(accessType.getType())
+                : accessType.getType();
         prop.setPropertyAccessorName(accessorName);
 
         prop.setOptional(persistentProperty.isNullable());
-        if (persistentProperty instanceof Association<?> association &&
-                !(persistentProperty instanceof HibernateEnumProperty)) {
+        if (persistentProperty instanceof Association<?> association
+                && !(persistentProperty instanceof HibernateEnumProperty)) {
             prop.setCascade(cascadeBehaviorFetcher.getCascadeBehaviour(association));
         }
 
@@ -95,7 +95,7 @@ public class PropertyBinder {
         prop.setLazy(persistentProperty.isLazy());
 
         prop.setInsertable(value.hasAnyInsertableColumns());
-        prop.setUpdateable(value.hasAnyUpdatableColumns());
+        prop.setUpdatable(value.hasAnyUpdatableColumns());
 
         return prop;
     }
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/RootBinder.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/RootBinder.java
index 24125be882..050bb86c73 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/RootBinder.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/RootBinder.java
@@ -53,7 +53,8 @@ public class RootBinder {
             SubClassBinder subClassBinder,
             RootPersistentClassCommonValuesBinder rootPersistentClassCommonValuesBinder,
             DiscriminatorPropertyBinder discriminatorPropertyBinder,
-            InFlightMetadataCollector mappings, MappingCacheHolder mappingCacheHolder) {
+            InFlightMetadataCollector mappings,
+            MappingCacheHolder mappingCacheHolder) {
         this.dataSourceName = dataSourceName;
         this.multiTenantFilterBinder = multiTenantFilterBinder;
         this.subClassBinder = subClassBinder;
@@ -83,9 +84,7 @@ public class RootBinder {
         }
 
         // bind the sub classes
-        children.stream()
-                .flatMap(sub -> getSubclassStream(sub, root))
-                .forEach(subClass -> addSubclass(subClass, root));
+        children.stream().flatMap(sub -> getSubclassStream(sub, root)).forEach(subClass -> addSubclass(subClass, root));
 
         multiTenantFilterBinder.bind(entity, root);
 
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/RootPersistentClassCommonValuesBinder.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/RootPersistentClassCommonValuesBinder.java
index 0fbfacd579..241897b1cf 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/RootPersistentClassCommonValuesBinder.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/RootPersistentClassCommonValuesBinder.java
@@ -75,7 +75,8 @@ public class RootPersistentClassCommonValuesBinder {
             if ("read-only".equalsIgnoreCase(cc.getUsage().toString())) {
                 root.setMutable(false);
             }
-            root.setLazyPropertiesCacheable(!"non-lazy".equalsIgnoreCase(cc.getInclude().toString()));
+            root.setLazyPropertiesCacheable(
+                    !"non-lazy".equalsIgnoreCase(cc.getInclude().toString()));
         }
 
         var schema = hibernatePersistentEntity.getSchema(mappings);
@@ -92,10 +93,9 @@ public class RootPersistentClassCommonValuesBinder {
                 metadataBuildingContext);
         root.setTable(table);
         if (LOG.isDebugEnabled()) {
-            LOG.debug("[GrailsDomainBinder] Mapping Grails domain class: " +
-                    hibernatePersistentEntity.getName() +
-                    " -> " +
-                    root.getTable().getName());
+            LOG.debug("[GrailsDomainBinder] Mapping Grails domain class: " + hibernatePersistentEntity.getName()
+                    + " -> "
+                    + root.getTable().getName());
         }
 
         identityBinder.bindIdentity(hibernatePersistentEntity, root);
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/SimpleValueBinder.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/SimpleValueBinder.java
index 8d8da50302..615b078f5e 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/SimpleValueBinder.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/SimpleValueBinder.java
@@ -101,10 +101,10 @@ public class SimpleValueBinder {
         if (generator != null && simpleValue instanceof BasicValue basicValue) {
             basicValue.setCustomIdGeneratorCreator(context -> createGenerator(
                     property,
-                    context.getValue() == null ?
-                            new org.grails.orm.hibernate.cfg.domainbinding.util.GeneratorCreationContextWrapper(
-                                    context, basicValue) :
-                            context,
+                    context.getValue() == null
+                            ? new org.grails.orm.hibernate.cfg.domainbinding.util.GeneratorCreationContextWrapper(
+                                    context, basicValue)
+                            : context,
                     generator));
         }
 
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/SingleTableSubclassBinder.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/SingleTableSubclassBinder.java
index f874f12b08..78413b9354 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/SingleTableSubclassBinder.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/SingleTableSubclassBinder.java
@@ -57,8 +57,8 @@ public class SingleTableSubclassBinder {
         classBinder.bindClass(sub, subClass);
         subClass.setDiscriminatorValue(sub.getDiscriminatorValue());
         if (LOG.isDebugEnabled()) {
-            LOG.debug("Mapping subclass: " + subClass.getEntityName() + " -> " +
-                    subClass.getTable().getName());
+            LOG.debug("Mapping subclass: " + subClass.getEntityName() + " -> "
+                    + subClass.getTable().getName());
         }
         return subClass;
     }
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/UnionSubclassBinder.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/UnionSubclassBinder.java
index 0851724ac0..25027062c2 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/UnionSubclassBinder.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/UnionSubclassBinder.java
@@ -85,10 +85,9 @@ public class UnionSubclassBinder {
         unionSubclass.setClassName(subClass.getName());
 
         if (LOG.isInfoEnabled()) {
-            LOG.info("Mapping union-subclass: " +
-                    unionSubclass.getEntityName() +
-                    " -> " +
-                    unionSubclass.getTable().getName());
+            LOG.info("Mapping union-subclass: " + unionSubclass.getEntityName()
+                    + " -> "
+                    + unionSubclass.getTable().getName());
         }
         return unionSubclass;
     }
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/generator/GrailsNativeGenerator.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/generator/GrailsNativeGenerator.java
index 2e3c762c4b..b8ccb20027 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/generator/GrailsNativeGenerator.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/generator/GrailsNativeGenerator.java
@@ -74,7 +74,8 @@ public class GrailsNativeGenerator extends NativeGenerator {
             Object delegate = field.get(this);
             if (delegate instanceof SequenceStyleGenerator ssg) {
                 if (ssg.getDatabaseStructure() == null) {
-                    throw new HibernateException("Identifier generator (SequenceStyleGenerator) was not properly initialized. This usually happens if table creation failed (check previous logs for DDL errors).");
+                    throw new HibernateException(
+                            "Identifier generator (SequenceStyleGenerator) was not properly initialized. This usually happens if table creation failed (check previous logs for DDL errors).");
                 }
             }
         } catch (HibernateException e) {
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/hibernate/HibernateAssociation.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/hibernate/HibernateAssociation.java
index dbcd2cb5b4..389e7e948b 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/hibernate/HibernateAssociation.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/hibernate/HibernateAssociation.java
@@ -87,11 +87,11 @@ public interface HibernateAssociation extends HibernatePersistentProperty {
     }
 
     default boolean isBidirectionalManyToOneWithListMapping(Property prop) {
-        return isBidirectional() &&
-                getInverseSide() != null &&
-                List.class.isAssignableFrom(getType()) &&
-                prop != null &&
-                prop.getValue() instanceof ManyToOne;
+        return isBidirectional()
+                && getInverseSide() != null
+                && List.class.isAssignableFrom(getType())
+                && prop != null
+                && prop.getValue() instanceof ManyToOne;
     }
 
     /**
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/hibernate/HibernateOneToOneProperty.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/hibernate/HibernateOneToOneProperty.java
index 145a7bbef6..17af6a5877 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/hibernate/HibernateOneToOneProperty.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/hibernate/HibernateOneToOneProperty.java
@@ -39,9 +39,8 @@ public class HibernateOneToOneProperty extends OneToOneWithMapping<PropertyConfi
     public void validateAssociation() {
         HibernateToOneProperty.super.validateAssociation();
         if (isHasOne() && !isBidirectional()) {
-            throw new MappingException("hasOne property [" +
-                    getName() +
-                    "] is not bidirectional. Specify the other side of the relationship!");
+            throw new MappingException("hasOne property [" + getName()
+                    + "] is not bidirectional. Specify the other side of the relationship!");
         }
     }
 
@@ -67,9 +66,9 @@ public class HibernateOneToOneProperty extends OneToOneWithMapping<PropertyConfi
      */
     public String getHibernateReferencedEntityName() {
         HibernateOneToOneProperty otherSide = getHibernateInverseSide();
-        return otherSide != null ?
-                otherSide.getOwner().getName() :
-                getAssociatedEntity().getName();
+        return otherSide != null
+                ? otherSide.getOwner().getName()
+                : getAssociatedEntity().getName();
     }
 
     /**
@@ -102,8 +101,8 @@ public class HibernateOneToOneProperty extends OneToOneWithMapping<PropertyConfi
 
     public boolean isValidHibernateOneToOne() {
         validateAssociation();
-        return canBindOneToOneWithSingleColumnAndForeignKey() ||
-                isHasOne() && isBidirectional() && getInverseSide() != null;
+        return canBindOneToOneWithSingleColumnAndForeignKey()
+                || isHasOne() && isBidirectional() && getInverseSide() != null;
     }
 
     public boolean isValidHibernateManyToOne() {
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/hibernate/HibernateToManyProperty.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/hibernate/HibernateToManyProperty.java
index 91b2c26dc6..11760434c5 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/hibernate/HibernateToManyProperty.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/hibernate/HibernateToManyProperty.java
@@ -111,7 +111,9 @@ public interface HibernateToManyProperty extends PropertyWithMapping<PropertyCon
         }
 
         if (mapped == null || mapped.getColumns().isEmpty()) {
-            return namingStrategy.resolveColumnName(getName()) + UNDERSCORE + IndexedCollection.DEFAULT_INDEX_COLUMN_NAME;
+            return namingStrategy.resolveColumnName(getName())
+                    + UNDERSCORE
+                    + IndexedCollection.DEFAULT_INDEX_COLUMN_NAME;
         }
 
         ColumnConfig primaryCol = mapped.getColumns().get(0);
@@ -133,8 +135,7 @@ public interface HibernateToManyProperty extends PropertyWithMapping<PropertyCon
             if (StringUtils.hasText(colName)) {
                 return colName;
             }
-        }
-        catch (Exception e) {
+        } catch (Exception e) {
             // ignore
         }
 
@@ -171,8 +172,7 @@ public interface HibernateToManyProperty extends PropertyWithMapping<PropertyCon
             if (StringUtils.hasText(typeName)) {
                 return typeName;
             }
-        }
-        catch (Exception e) {
+        } catch (Exception e) {
             // ignore
         }
 
@@ -194,14 +194,14 @@ public interface HibernateToManyProperty extends PropertyWithMapping<PropertyCon
                 .map(PropertyConfig::getJoinTableColumnConfig)
                 .map(ColumnConfig::getName)
                 .orElseGet(() -> namingStrategy.resolveColumnName(getHibernateAssociatedEntity()
-                        .getHibernateRootEntity()
-                        .getJavaClass()
-                        .getSimpleName())
+                                .getHibernateRootEntity()
+                                .getJavaClass()
+                                .getSimpleName())
                         + GrailsDomainBinder.FOREIGN_KEY_SUFFIX);
     }
 
     default String joinTableColumName(PersistentEntityNamingStrategy namingStrategy) {
-        final Class<?> referencedType =getComponentType();
+        final Class<?> referencedType = getComponentType();
         var joinColumnMappingOptional = getColumnConfigOptional();
         boolean present = joinColumnMappingOptional.isPresent();
         String columnName;
@@ -237,5 +237,6 @@ public interface HibernateToManyProperty extends PropertyWithMapping<PropertyCon
     }
 
     void setCollection(Collection collection);
+
     Collection getCollection();
-}
\ No newline at end of file
+}
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/secondpass/BasicCollectionElementBinder.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/secondpass/BasicCollectionElementBinder.java
index 2ded6e0ab5..576253a1e9 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/secondpass/BasicCollectionElementBinder.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/secondpass/BasicCollectionElementBinder.java
@@ -20,7 +20,6 @@ package org.grails.orm.hibernate.cfg.domainbinding.secondpass;
 
 import jakarta.annotation.Nonnull;
 
-import org.checkerframework.checker.nullness.qual.MonotonicNonNull;
 import org.hibernate.boot.spi.MetadataBuildingContext;
 import org.hibernate.mapping.BasicValue;
 import org.hibernate.mapping.Collection;
@@ -64,7 +63,7 @@ public class BasicCollectionElementBinder {
     public BasicValue bind(@Nonnull HibernateBasicProperty property) {
         String columnName = property.joinTableColumName(namingStrategy);
         if (property.isEnum()) {
-            return enumTypeBinder.bindEnumTypeForColumn(property, columnName);
+            return enumTypeBinder.bindEnumTypeForColumn(property);
         } else {
             final Class<?> referencedType = property.getComponentType();
             String typeName = property.getTypeName(referencedType);
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/secondpass/CollectionKeyBinder.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/secondpass/CollectionKeyBinder.java
index 66b3eb7cad..938ccf68bb 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/secondpass/CollectionKeyBinder.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/secondpass/CollectionKeyBinder.java
@@ -50,8 +50,7 @@ public class CollectionKeyBinder {
     }
 
     /** Creates the {@link DependantValue} key, sets it on the collection, and binds it. */
-    public DependantValue bind(
-            HibernateToManyProperty property, PersistentClass associatedClass) {
+    public DependantValue bind(HibernateToManyProperty property, PersistentClass associatedClass) {
         Collection collection = property.getCollection();
         DependantValue key = primaryKeyValueCreator.createPrimaryKeyValue(collection);
         collection.setKey(key);
@@ -59,8 +58,8 @@ public class CollectionKeyBinder {
             var inverseSide = property.getHibernateInverseSide();
             if (inverseSide instanceof ToOne && property.shouldBindWithForeignKey()) {
                 bidirectionalOneToManyLinker.link(collection, associatedClass, key, inverseSide);
-            } else if (inverseSide instanceof HibernateManyToManyProperty ||
-                    Map.class.isAssignableFrom(property.getType())) {
+            } else if (inverseSide instanceof HibernateManyToManyProperty
+                    || Map.class.isAssignableFrom(property.getType())) {
                 dependentKeyValueBinder.bind(property, key);
             }
         } else {
@@ -68,7 +67,10 @@ public class CollectionKeyBinder {
                 simpleValueColumnBinder.bindSimpleValue(
                         key,
                         "long",
-                        property.getHibernateMappedForm().getJoinTable().getKey().getName(),
+                        property.getHibernateMappedForm()
+                                .getJoinTable()
+                                .getKey()
+                                .getName(),
                         true);
             } else {
                 dependentKeyValueBinder.bind(property, key);
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/secondpass/CollectionKeyColumnUpdater.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/secondpass/CollectionKeyColumnUpdater.java
index c8b73d679b..f90f81f419 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/secondpass/CollectionKeyColumnUpdater.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/secondpass/CollectionKeyColumnUpdater.java
@@ -20,7 +20,6 @@ package org.grails.orm.hibernate.cfg.domainbinding.secondpass;
 
 import java.util.Objects;
 
-import org.hibernate.mapping.Collection;
 import org.hibernate.mapping.DependantValue;
 import org.hibernate.mapping.PersistentClass;
 
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/secondpass/CollectionOrderByBinder.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/secondpass/CollectionOrderByBinder.java
index 19268df678..9dbf536913 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/secondpass/CollectionOrderByBinder.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/secondpass/CollectionOrderByBinder.java
@@ -55,11 +55,11 @@ public class CollectionOrderByBinder {
 
         if (property.hasSort()) {
             if (!property.isBidirectional() && property instanceof HibernateOneToManyProperty) {
-                throw new DatastoreConfigurationException("Default sort for associations [" +
-                        property.getHibernateOwner().getName() +
-                        "->" +
-                        property.getName() +
-                        "] are not supported with unidirectional one to many relationships.");
+                throw new DatastoreConfigurationException("Default sort for associations ["
+                        + property.getHibernateOwner().getName()
+                        + "->"
+                        + property.getName()
+                        + "] are not supported with unidirectional one to many relationships.");
             }
             HibernatePersistentProperty sortBy = referenced.getHibernatePropertyByName(property.getSort());
             String order = Optional.ofNullable(property.getOrder()).orElse("asc");
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/secondpass/CollectionSecondPassBinder.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/secondpass/CollectionSecondPassBinder.java
index fe8d68ae51..56fa3f32d6 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/secondpass/CollectionSecondPassBinder.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/secondpass/CollectionSecondPassBinder.java
@@ -18,14 +18,17 @@
  */
 package org.grails.orm.hibernate.cfg.domainbinding.secondpass;
 
-import java.util.*;
 import java.util.Map;
+import java.util.Optional;
+
 import jakarta.annotation.Nonnull;
 
-import org.grails.datastore.mapping.model.types.Basic;
 import org.hibernate.MappingException;
-import org.hibernate.mapping.*;
 import org.hibernate.mapping.Collection;
+import org.hibernate.mapping.OneToMany;
+import org.hibernate.mapping.PersistentClass;
+
+import org.grails.datastore.mapping.model.types.Basic;
 import org.grails.orm.hibernate.cfg.domainbinding.binder.CollectionForPropertyConfigBinder;
 import org.grails.orm.hibernate.cfg.domainbinding.hibernate.HibernateManyToManyProperty;
 import org.grails.orm.hibernate.cfg.domainbinding.hibernate.HibernateOneToManyProperty;
@@ -73,8 +76,6 @@ public class CollectionSecondPassBinder {
             collectionMultiTenantFilterBinder.bind(property);
             collection.setSorted(property.isSorted());
             collectionKeyColumnUpdater.bind(property, null);
-            collection.setCacheConcurrencyStrategy(property.getCacheUsage());
-            bindCollectionElement(property);
         } else {
             PersistentClass associatedClass = resolveAssociatedClass(property, persistentClasses);
             collectionOrderByBinder.bind(property, associatedClass);
@@ -82,9 +83,9 @@ public class CollectionSecondPassBinder {
             collectionMultiTenantFilterBinder.bind(property);
             collection.setSorted(property.isSorted());
             collectionKeyColumnUpdater.bind(property, associatedClass);
-            collection.setCacheConcurrencyStrategy(property.getCacheUsage());
-            bindCollectionElement(property);
         }
+        collection.setCacheConcurrencyStrategy(property.getCacheUsage());
+        bindCollectionElement(property);
     }
 
     private void bindOneToManyAssociation(HibernateToManyProperty property, PersistentClass associatedClass) {
@@ -105,7 +106,8 @@ public class CollectionSecondPassBinder {
             manyToManyElementBinder.bind(manyToMany);
         } else if (property.isBidirectionalOneToManyMap() && property.isBidirectional()) {
             bidirectionalMapElementBinder.bind(property);
-        } else if (property instanceof HibernateOneToManyProperty oneToManyProperty && oneToManyProperty.isUnidirectionalOneToMany()) {
+        } else if (property instanceof HibernateOneToManyProperty oneToManyProperty
+                && oneToManyProperty.isUnidirectionalOneToMany()) {
             unidirectionalOneToManyBinder.bind(oneToManyProperty);
         } else if (property.supportsJoinColumnMapping()) {
             collectionWithJoinTableBinder.bindCollectionWithJoinTable(property);
@@ -115,6 +117,7 @@ public class CollectionSecondPassBinder {
     protected PersistentClass resolveAssociatedClass(HibernateToManyProperty property, Map<?, ?> persistentClasses) {
         return Optional.ofNullable(property.getHibernateAssociatedEntity())
                 .map(referenced -> (PersistentClass) persistentClasses.get(referenced.getName()))
-                .orElseThrow(() -> new MappingException("Association [" + property.getName() + "] has no associated class"));
+                .orElseThrow(
+                        () -> new MappingException("Association [" + property.getName() + "] has no associated class"));
     }
-}
\ No newline at end of file
+}
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/secondpass/DependentKeyValueBinder.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/secondpass/DependentKeyValueBinder.java
index 304c34add5..e65b66861f 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/secondpass/DependentKeyValueBinder.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/secondpass/DependentKeyValueBinder.java
@@ -46,9 +46,9 @@ public class DependentKeyValueBinder {
     public void bind(HibernateToManyProperty property, DependantValue key) {
         GrailsHibernatePersistentEntity refDomainClass = property.getHibernateOwner();
 
-        Optional<CompositeIdentity> compositeIdentity = property.supportsJoinColumnMapping() ?
-                refDomainClass.getHibernateCompositeIdentity() :
-                Optional.empty();
+        Optional<CompositeIdentity> compositeIdentity = property.supportsJoinColumnMapping()
+                ? refDomainClass.getHibernateCompositeIdentity()
+                : Optional.empty();
 
         compositeIdentity.ifPresentOrElse(
                 ci -> {
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/secondpass/ListSecondPass.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/secondpass/ListSecondPass.java
index 0c29c2caa3..bcf1c16064 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/secondpass/ListSecondPass.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/secondpass/ListSecondPass.java
@@ -33,9 +33,7 @@ public class ListSecondPass implements org.hibernate.boot.spi.SecondPass, Grails
     private final ListSecondPassBinder listSecondPassBinder;
     protected final HibernateToManyProperty property;
 
-    public ListSecondPass(
-            ListSecondPassBinder listSecondPassBinder,
-            HibernateToManyProperty property) {
+    public ListSecondPass(ListSecondPassBinder listSecondPassBinder, HibernateToManyProperty property) {
         this.listSecondPassBinder = listSecondPassBinder;
         this.property = property;
     }
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/secondpass/ListSecondPassBinder.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/secondpass/ListSecondPassBinder.java
index 44b2c51377..465d3846c6 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/secondpass/ListSecondPassBinder.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/secondpass/ListSecondPassBinder.java
@@ -27,7 +27,6 @@ import org.hibernate.boot.spi.InFlightMetadataCollector;
 import org.hibernate.boot.spi.MetadataBuildingContext;
 import org.hibernate.mapping.Backref;
 import org.hibernate.mapping.BasicValue;
-import org.hibernate.mapping.Collection;
 import org.hibernate.mapping.DependantValue;
 import org.hibernate.mapping.IndexBackref;
 import org.hibernate.mapping.List;
@@ -69,8 +68,7 @@ public class ListSecondPassBinder {
         this.mappings = mappings;
     }
 
-    public void bindListSecondPass(
-            @Nonnull HibernateToManyProperty property, Map<?, ?> persistentClasses) {
+    public void bindListSecondPass(@Nonnull HibernateToManyProperty property, Map<?, ?> persistentClasses) {
 
         List list = (List) property.getCollection();
         collectionSecondPassBinder.bindCollectionSecondPass(property, persistentClasses);
@@ -78,9 +76,8 @@ public class ListSecondPassBinder {
         final boolean isManyToMany = property instanceof HibernateManyToManyProperty;
 
         if (isManyToMany && !property.isOwningSide()) {
-            throw new MappingException("Invalid association [" +
-                    property +
-                    "]. List collection types only supported on the owning side of a many-to-many relationship.");
+            throw new MappingException("Invalid association [" + property
+                    + "]. List collection types only supported on the owning side of a many-to-many relationship.");
         }
 
         Table collectionTable = list.getCollectionTable();
@@ -112,11 +109,11 @@ public class ListSecondPassBinder {
                 final PersistentEntity owner = property.getOwner();
                 prop.setEntityName(owner.getName());
                 String s2 = property.getName();
-                prop.setName(UNDERSCORE +
-                        new BackticksRemover().apply(owner.getJavaClass().getSimpleName()) +
-                        UNDERSCORE +
-                        new BackticksRemover().apply(s2) +
-                        "Backref");
+                prop.setName(UNDERSCORE
+                        + new BackticksRemover().apply(owner.getJavaClass().getSimpleName())
+                        + UNDERSCORE
+                        + new BackticksRemover().apply(s2)
+                        + "Backref");
                 prop.setSelectable(false);
                 prop.setUpdatable(false);
                 if (isManyToMany) {
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/secondpass/MapSecondPass.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/secondpass/MapSecondPass.java
index ac8f159c5a..bde83e0fc0 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/secondpass/MapSecondPass.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/secondpass/MapSecondPass.java
@@ -33,9 +33,7 @@ public class MapSecondPass implements org.hibernate.boot.spi.SecondPass, GrailsS
     private final MapSecondPassBinder mapSecondPassBinder;
     protected final HibernateToManyProperty property;
 
-    public MapSecondPass(
-            MapSecondPassBinder mapSecondPassBinder,
-            HibernateToManyProperty property) {
+    public MapSecondPass(MapSecondPassBinder mapSecondPassBinder, HibernateToManyProperty property) {
         this.mapSecondPassBinder = mapSecondPassBinder;
         this.property = property;
     }
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/secondpass/MapSecondPassBinder.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/secondpass/MapSecondPassBinder.java
index a2f93ff43a..2b3da3a6c9 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/secondpass/MapSecondPassBinder.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/secondpass/MapSecondPassBinder.java
@@ -64,9 +64,7 @@ public class MapSecondPassBinder {
         this.simpleValueColumnFetcher = simpleValueColumnFetcher;
     }
 
-    public void bindMapSecondPass(
-            @Nonnull HibernateToManyProperty property,
-            Map<?, ?> persistentClasses) {
+    public void bindMapSecondPass(@Nonnull HibernateToManyProperty property, Map<?, ?> persistentClasses) {
         org.hibernate.mapping.Map map = (org.hibernate.mapping.Map) property.getCollection();
         collectionSecondPassBinder.bindCollectionSecondPass(property, persistentClasses);
 
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/secondpass/SetSecondPass.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/secondpass/SetSecondPass.java
index 9cde91b44b..55da26907d 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/secondpass/SetSecondPass.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/secondpass/SetSecondPass.java
@@ -40,9 +40,7 @@ public class SetSecondPass implements org.hibernate.boot.spi.SecondPass, GrailsS
     private final CollectionSecondPassBinder collectionSecondPassBinder;
     protected final HibernateToManyProperty property;
 
-    public SetSecondPass(
-            CollectionSecondPassBinder collectionSecondPassBinder,
-            HibernateToManyProperty property) {
+    public SetSecondPass(CollectionSecondPassBinder collectionSecondPassBinder, HibernateToManyProperty property) {
         this.collectionSecondPassBinder = collectionSecondPassBinder;
         this.property = property;
     }
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/secondpass/UnidirectionalOneToManyInverseValuesBinder.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/secondpass/UnidirectionalOneToManyInverseValuesBinder.java
index a5cc34de04..b65e3d7afb 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/secondpass/UnidirectionalOneToManyInverseValuesBinder.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/secondpass/UnidirectionalOneToManyInverseValuesBinder.java
@@ -18,9 +18,6 @@
  */
 package org.grails.orm.hibernate.cfg.domainbinding.secondpass;
 
-import java.util.Optional;
-
-import org.hibernate.FetchMode;
 import org.hibernate.boot.spi.MetadataBuildingContext;
 import org.hibernate.mapping.Collection;
 import org.hibernate.mapping.ManyToOne;
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/util/BasicValueIdCreator.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/util/BasicValueIdCreator.java
index 8f3f073db6..6faab8d025 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/util/BasicValueIdCreator.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/util/BasicValueIdCreator.java
@@ -69,10 +69,7 @@ public class BasicValueIdCreator {
         id.setCustomIdGeneratorCreator(context -> createGenerator(
                 mappedId,
                 domainClass,
-                context.getValue() == null ?
-                        new org.grails.orm.hibernate.cfg.domainbinding.util.GeneratorCreationContextWrapper(
-                                context, id) :
-                        context,
+                context.getValue() == null ? new GeneratorCreationContextWrapper(context, id) : context,
                 generatorName));
         return id;
     }
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/util/CascadeBehaviorFetcher.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/util/CascadeBehaviorFetcher.java
index e0a629a908..3ae9616b38 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/util/CascadeBehaviorFetcher.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/util/CascadeBehaviorFetcher.java
@@ -66,8 +66,8 @@ public class CascadeBehaviorFetcher {
      * Gets the cascade behaviour.
      */
     public String getCascadeBehaviour(Association<?> association) {
-        var cascadeStrategy = getDefinedBehavior((HibernatePersistentProperty) association)
-                .orElse(getImpliedBehavior(association));
+        var cascadeStrategy =
+                getDefinedBehavior((HibernatePersistentProperty) association).orElse(getImpliedBehavior(association));
 
         logCascadeMapping.logCascadeMapping(association, cascadeStrategy);
 
@@ -101,30 +101,22 @@ public class CascadeBehaviorFetcher {
 
         if (association.isHasOne()) {
             return ALL;
-        }
-        else if (association instanceof HibernateOneToOneProperty) {
+        } else if (association instanceof HibernateOneToOneProperty) {
             return association.isOwningSide() ? ALL : SAVE_UPDATE;
-        }
-        else if (association instanceof HibernateOneToManyProperty) {
+        } else if (association instanceof HibernateOneToManyProperty) {
             return association.isCorrectlyOwned() ? ALL : SAVE_UPDATE;
-        }
-        else if (association instanceof HibernateManyToManyProperty) {
+        } else if (association instanceof HibernateManyToManyProperty) {
             return association.isCorrectlyOwned() || association.isCircular() ? SAVE_UPDATE : NONE;
-        }
-        else if (association instanceof HibernateManyToOneProperty) {
+        } else if (association instanceof HibernateManyToOneProperty) {
             if (association.isCorrectlyOwned() && !association.isCircular()) {
                 return ALL;
-            }
-            else if (association.isCompositeIdProperty()) {
+            } else if (association.isCompositeIdProperty()) {
                 return ALL;
-            }
-            else {
+            } else {
                 return NONE;
             }
-        }
-        else {
+        } else {
             throw new MappingException("Unrecognized association type " + association.getType());
         }
     }
-
-}
\ No newline at end of file
+}
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/util/ColumnNameForPropertyAndPathFetcher.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/util/ColumnNameForPropertyAndPathFetcher.java
index f79b052930..2fd469e0fb 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/util/ColumnNameForPropertyAndPathFetcher.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/util/ColumnNameForPropertyAndPathFetcher.java
@@ -48,9 +48,9 @@ public class ColumnNameForPropertyAndPathFetcher {
             String suffix = defaultColumnNameFetcher.getDefaultColumnName(grailsProp);
             return Optional.ofNullable(path)
                     .filter(GrailsHibernateUtil::isNotEmpty)
-                    .map(p -> backticksRemover.apply(namingStrategy.resolveColumnName(p)) +
-                            UNDERSCORE +
-                            backticksRemover.apply(suffix))
+                    .map(p -> backticksRemover.apply(namingStrategy.resolveColumnName(p))
+                            + UNDERSCORE
+                            + backticksRemover.apply(suffix))
                     .orElse(suffix);
         });
     }
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/util/NamingStrategyProvider.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/util/NamingStrategyProvider.java
index da95f46f8c..7c74430e2f 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/util/NamingStrategyProvider.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/util/NamingStrategyProvider.java
@@ -88,8 +88,8 @@ public class NamingStrategyProvider {
         if (Objects.isNull(sessionFactoryBeanName) || sessionFactoryBeanName.isBlank()) {
             return ConnectionSource.DEFAULT;
         }
-        return "sessionFactory".equals(sessionFactoryBeanName) ?
-                ConnectionSource.DEFAULT :
-                sessionFactoryBeanName.substring("sessionFactory_".length());
+        return "sessionFactory".equals(sessionFactoryBeanName)
+                ? ConnectionSource.DEFAULT
+                : sessionFactoryBeanName.substring("sessionFactory_".length());
     }
 }
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/util/OrderByClauseBuilder.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/util/OrderByClauseBuilder.java
index b075ea0562..cfc978955d 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/util/OrderByClauseBuilder.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/util/OrderByClauseBuilder.java
@@ -22,12 +22,10 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.Locale;
 import java.util.stream.Collectors;
-import java.util.stream.StreamSupport;
 
 import org.hibernate.boot.model.internal.BinderHelper;
 import org.hibernate.mapping.PersistentClass;
 import org.hibernate.mapping.Property;
-import org.hibernate.mapping.Selectable;
 import org.hibernate.mapping.SingleTableSubclass;
 
 import org.grails.datastore.mapping.model.DatastoreConfigurationException;
@@ -43,9 +41,8 @@ public class OrderByClauseBuilder {
         }
 
         if (hqlOrderBy.isEmpty()) {
-            return StreamSupport.stream(
-                            associatedClass.getIdentifier().getSelectables().spliterator(), false)
-                    .map(selectable -> ((Selectable) selectable).getText() + " asc")
+            return associatedClass.getIdentifier().getSelectables().stream()
+                    .map(selectable -> selectable.getText() + " asc")
                     .collect(Collectors.joining(", "));
         }
 
@@ -96,17 +93,17 @@ public class OrderByClauseBuilder {
         String tablePrefix = getTablePrefix(p, associatedClass);
         String direction = entry.direction;
 
-        return StreamSupport.stream(p.getSelectables().spliterator(), false)
-                .map(selectable -> tablePrefix + ((Selectable) selectable).getText() + " " + direction)
+        return p.getSelectables().stream()
+                .map(selectable -> tablePrefix + selectable.getText() + " " + direction)
                 .collect(Collectors.joining(", "));
     }
 
     private String getTablePrefix(Property p, PersistentClass associatedClass) {
         PersistentClass pc = p.getPersistentClass();
-        if (pc == null ||
-                pc.equals(associatedClass) ||
-                (associatedClass instanceof SingleTableSubclass &&
-                        pc.getMappedClass().isAssignableFrom(associatedClass.getMappedClass()))) {
+        if (pc == null
+                || pc.equals(associatedClass)
+                || (associatedClass instanceof SingleTableSubclass
+                        && pc.getMappedClass().isAssignableFrom(associatedClass.getMappedClass()))) {
             return "";
         }
         return pc.getTable().getQuotedName() + ".";
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/util/SimpleValueColumnFetcher.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/util/SimpleValueColumnFetcher.java
index 1b3acbc3f8..9ece1cded1 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/util/SimpleValueColumnFetcher.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/util/SimpleValueColumnFetcher.java
@@ -23,8 +23,8 @@ import org.hibernate.mapping.SimpleValue;
 
 public class SimpleValueColumnFetcher {
     public Column getColumnForSimpleValue(SimpleValue element) {
-        return element.getColumns().isEmpty() ?
-                null :
-                element.getColumns().iterator().next();
+        return element.getColumns().isEmpty()
+                ? null
+                : element.getColumns().iterator().next();
     }
 }
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/util/TableForManyCalculator.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/util/TableForManyCalculator.java
index e80bc5261c..0f6773c194 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/util/TableForManyCalculator.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/util/TableForManyCalculator.java
@@ -77,9 +77,8 @@ public class TableForManyCalculator {
         // Only proceed with association logic if it's an actual Association and has an associated
         // entity
         if (!(property instanceof Association association)) {
-            throw new MappingException("Property [" +
-                    property.getName() +
-                    "] is not an association and is not a basic type for table calculation.");
+            throw new MappingException("Property [" + property.getName()
+                    + "] is not an association and is not a basic type for table calculation.");
         }
 
         GrailsHibernatePersistentEntity domainClass =
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/connections/HibernateConnectionSource.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/connections/HibernateConnectionSource.java
index a18aa131cd..1f6454d6bc 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/connections/HibernateConnectionSource.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/connections/HibernateConnectionSource.java
@@ -19,7 +19,6 @@
 package org.grails.orm.hibernate.connections;
 
 import java.io.IOException;
-
 import javax.sql.DataSource;
 
 import org.hibernate.SessionFactory;
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/event/listener/HibernateEventListener.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/event/listener/HibernateEventListener.java
index 8f211a9b14..7342df7509 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/event/listener/HibernateEventListener.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/event/listener/HibernateEventListener.java
@@ -23,6 +23,8 @@ import java.util.Optional;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
 
+import jakarta.annotation.Nonnull;
+
 import org.hibernate.Hibernate;
 import org.hibernate.engine.spi.SessionFactoryImplementor;
 import org.hibernate.event.spi.EventSource;
@@ -51,18 +53,6 @@ import org.grails.orm.hibernate.connections.HibernateConnectionSourceSettings;
 import org.grails.orm.hibernate.support.ClosureEventListener;
 import org.grails.orm.hibernate.support.SoftKey;
 
-import grails.gorm.MultiTenant;
-import org.grails.datastore.gorm.timestamp.DefaultTimestampProvider;
-import org.grails.datastore.gorm.timestamp.TimestampProvider;
-import org.grails.datastore.mapping.engine.event.AbstractPersistenceEvent;
-import org.grails.datastore.mapping.engine.event.AbstractPersistenceEventListener;
-import org.grails.datastore.mapping.engine.event.ValidationEvent;
-import org.grails.orm.hibernate.HibernateDatastore;
-import org.grails.orm.hibernate.cfg.domainbinding.hibernate.HibernatePersistentEntity;
-import org.grails.orm.hibernate.connections.HibernateConnectionSourceSettings;
-import org.grails.orm.hibernate.support.ClosureEventListener;
-import org.grails.orm.hibernate.support.SoftKey;
-
 /**
  * Invokes closure events on domain entities such as beforeInsert, beforeUpdate and beforeDelete.
  *
@@ -75,8 +65,7 @@ import org.grails.orm.hibernate.support.SoftKey;
 public class HibernateEventListener extends AbstractPersistenceEventListener {
 
     /** The cached should trigger. */
-    protected final transient ConcurrentMap<SoftKey<Class<?>>, Boolean> cachedShouldTrigger =
-            new ConcurrentHashMap<SoftKey<Class<?>>, Boolean>();
+    protected final transient ConcurrentMap<SoftKey<Class<?>>, Boolean> cachedShouldTrigger = new ConcurrentHashMap<>();
 
     /** The fail on error. */
     protected final boolean failOnError;
@@ -154,7 +143,7 @@ public class HibernateEventListener extends AbstractPersistenceEventListener {
         if (entity != null) {
             ClosureEventListener eventListener;
             EventSource session = event.getSession();
-            eventListener = findEventListener(entity, (SessionFactoryImplementor) session.getSessionFactory());
+            eventListener = findEventListener(entity, session.getSessionFactory());
             if (eventListener != null) {
                 eventListener.onPersist(event);
             }
@@ -166,7 +155,7 @@ public class HibernateEventListener extends AbstractPersistenceEventListener {
         if (entity != null) {
             ClosureEventListener eventListener;
             EventSource session = event.getSession();
-            eventListener = findEventListener(entity, (SessionFactoryImplementor) session.getSessionFactory());
+            eventListener = findEventListener(entity, session.getSessionFactory());
             if (eventListener != null) {
                 eventListener.onMerge(event);
             }
@@ -243,7 +232,7 @@ public class HibernateEventListener extends AbstractPersistenceEventListener {
         if (entity == null) return null;
         Class<?> clazz = Hibernate.getClass(entity);
 
-        SoftKey<Class<?>> key = new SoftKey<Class<?>>(clazz);
+        SoftKey<Class<?>> key = new SoftKey<>(clazz);
         ClosureEventListener eventListener = eventListeners.get(key);
         if (eventListener != null) {
             return eventListener;
@@ -255,9 +244,9 @@ public class HibernateEventListener extends AbstractPersistenceEventListener {
                 eventListener = eventListeners.get(key);
                 if (eventListener == null) {
                     HibernateDatastore datastore = getDatastore();
-                    boolean isValidSessionFactory = MultiTenant.class.isAssignableFrom(clazz) ||
-                            factory == null ||
-                            datastore.getSessionFactory().equals(factory);
+                    boolean isValidSessionFactory = MultiTenant.class.isAssignableFrom(clazz)
+                            || factory == null
+                            || datastore.getSessionFactory().equals(factory);
                     HibernatePersistentEntity persistentEntity = (HibernatePersistentEntity)
                             datastore.getMappingContext().getPersistentEntity(clazz.getName());
                     shouldTrigger = (persistentEntity != null && isValidSessionFactory);
@@ -281,7 +270,8 @@ public class HibernateEventListener extends AbstractPersistenceEventListener {
      * @see
      *     org.springframework.context.event.SmartApplicationListener#supportsEventType(java.lang.Class)
      */
-    public boolean supportsEventType(Class<? extends ApplicationEvent> eventType) {
+    @Override
+    public boolean supportsEventType(@Nonnull Class<? extends ApplicationEvent> eventType) {
         return AbstractPersistenceEvent.class.isAssignableFrom(eventType);
     }
 
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/multitenancy/MultiTenantEventListener.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/multitenancy/MultiTenantEventListener.java
index 3119c8a90a..7ce50c4e55 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/multitenancy/MultiTenantEventListener.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/multitenancy/MultiTenantEventListener.java
@@ -74,10 +74,10 @@ public class MultiTenantEventListener implements PersistenceEventListener {
                         hibernateDatastore.enableMultiTenancyFilter();
                     }
                 }
-            } else if (event instanceof AbstractPersistenceEvent persistenceEvent &&
-                    (persistenceEvent instanceof ValidationEvent ||
-                            persistenceEvent instanceof PreInsertEvent ||
-                            persistenceEvent instanceof PreUpdateEvent)) {
+            } else if (event instanceof AbstractPersistenceEvent persistenceEvent
+                    && (persistenceEvent instanceof ValidationEvent
+                            || persistenceEvent instanceof PreInsertEvent
+                            || persistenceEvent instanceof PreUpdateEvent)) {
                 PersistentEntity entity = persistenceEvent.getEntity();
                 if (entity.isMultiTenant()) {
                     TenantId<?> tenantId = entity.getTenantId();
@@ -95,12 +95,11 @@ public class MultiTenantEventListener implements PersistenceEventListener {
                                 persistenceEvent.getEntityAccess().setProperty(tenantId.getName(), currentId);
                             } catch (Exception e) {
                                 throw new TenantException(
-                                        "Could not assigned tenant id [" +
-                                                currentId +
-                                                "] to property [" +
-                                                tenantId +
-                                                "], probably due to a type mismatch. You should return a type from the tenant resolver that matches the property type of the tenant id!: " +
-                                                e.getMessage(),
+                                        "Could not assigned tenant id [" + currentId
+                                                + "] to property ["
+                                                + tenantId
+                                                + "], probably due to a type mismatch. You should return a type from the tenant resolver that matches the property type of the tenant id!: "
+                                                + e.getMessage(),
                                         e);
                             }
                         }
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/proxy/ByteBuddyGroovyInterceptor.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/proxy/ByteBuddyGroovyInterceptor.java
index 451ac61575..27c9d561aa 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/proxy/ByteBuddyGroovyInterceptor.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/proxy/ByteBuddyGroovyInterceptor.java
@@ -47,27 +47,36 @@ public class ByteBuddyGroovyInterceptor extends ByteBuddyInterceptor {
             CompositeType componentIdType,
             SharedSessionContractImplementor session,
             boolean overridesEquals) {
-        super(entityName, persistentClass, interfaces, id, getIdentifierMethod, setIdentifierMethod, componentIdType, session, overridesEquals);
+        super(
+                entityName,
+                persistentClass,
+                interfaces,
+                id,
+                getIdentifierMethod,
+                setIdentifierMethod,
+                componentIdType,
+                session,
+                overridesEquals);
         this.getIdentifierMethod = getIdentifierMethod;
     }
 
     @Override
     public Object intercept(Object proxy, Method method, Object[] args) throws Throwable {
         String methodName = method.getName();
-        System.out.println("Intercepting method: " + methodName + " on proxy: " + getEntityName() + ":" + getIdentifier() + " (Uninitialized: " + isUninitialized() + ")");
+        System.out.println("Intercepting method: " + methodName + " on proxy: " + getEntityName() + ":"
+                + getIdentifier() + " (Uninitialized: " + isUninitialized() + ")");
 
         // Check these BEFORE calling this.invoke() to avoid premature initialization in Hibernate 7
-        if ((getIdentifierMethod != null && methodName.equals(getIdentifierMethod.getName())) || methodName.equals("getId") || methodName.equals("getIdentifier")) {
+        if ((getIdentifierMethod != null && methodName.equals(getIdentifierMethod.getName()))
+                || methodName.equals("getId")
+                || methodName.equals("getIdentifier")) {
             System.out.println("Handling ID access for: " + methodName);
             return getIdentifier();
         }
 
         if (isUninitialized()) {
             GroovyProxyInterceptorLogic.InterceptorState state = new GroovyProxyInterceptorLogic.InterceptorState(
-                    getEntityName(),
-                    getPersistentClass(),
-                    getIdentifier()
-            );
+                    getEntityName(), getPersistentClass(), getIdentifier());
             Object result = GroovyProxyInterceptorLogic.handleUninitialized(state, methodName, args);
             if (result != GroovyProxyInterceptorLogic.INVOKE_IMPLEMENTATION) {
                 System.out.println("Handled uninitialized access for: " + methodName);
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/proxy/ByteBuddyGroovyProxyFactory.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/proxy/ByteBuddyGroovyProxyFactory.java
index 3ebdfd373d..7e3430af9f 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/proxy/ByteBuddyGroovyProxyFactory.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/proxy/ByteBuddyGroovyProxyFactory.java
@@ -18,16 +18,13 @@
  */
 package org.grails.orm.hibernate.proxy;
 
-import java.io.Serializable;
 import java.lang.reflect.Method;
 import java.util.Set;
 
 import org.hibernate.HibernateException;
-import org.hibernate.engine.spi.PrimeAmongSecondarySupertypes;
 import org.hibernate.engine.spi.SharedSessionContractImplementor;
 import org.hibernate.internal.util.ReflectHelper;
 import org.hibernate.proxy.HibernateProxy;
-import org.hibernate.proxy.ProxyFactory;
 import org.hibernate.proxy.pojo.bytebuddy.ByteBuddyProxyFactory;
 import org.hibernate.proxy.pojo.bytebuddy.ByteBuddyProxyHelper;
 import org.hibernate.type.CompositeType;
@@ -65,7 +62,8 @@ public class ByteBuddyGroovyProxyFactory extends ByteBuddyProxyFactory {
             Set<Class<?>> interfaces,
             Method getIdentifierMethod,
             Method setIdentifierMethod,
-            CompositeType componentIdType) throws HibernateException {
+            CompositeType componentIdType)
+            throws HibernateException {
         this.entityName = entityName;
         this.persistentClass = persistentClass;
         this.interfaces = interfaces == null ? EMPTY_CLASS_ARRAY : interfaces.toArray(EMPTY_CLASS_ARRAY);
@@ -94,19 +92,19 @@ public class ByteBuddyGroovyProxyFactory extends ByteBuddyProxyFactory {
                     setIdentifierMethod,
                     componentIdType,
                     session,
-                    overridesEquals
-            );
+                    overridesEquals);
 
             // 1. Create the instance
-            final Object instance = proxyClass.getDeclaredConstructor().newInstance();
+            final HibernateProxy hibernateProxy = (HibernateProxy) proxyClass.getDeclaredConstructor().newInstance();
 
             // 2. Cast to ProxyConfiguration to set the custom interceptor
             // Hibernate 7 proxies implement ProxyConfiguration
-            if (instance instanceof org.hibernate.proxy.ProxyConfiguration) {
-                ((org.hibernate.proxy.ProxyConfiguration) instance).$$_hibernate_set_interceptor(interceptor);
+            if (hibernateProxy instanceof org.hibernate.proxy.ProxyConfiguration instance
+            ) {
+                instance.$$_hibernate_set_interceptor(interceptor);
             }
 
-            return (HibernateProxy) instance;
+            return  hibernateProxy;
         } catch (Throwable t) {
             throw new HibernateException("Unable to generate proxy for " + entityName, t);
         }
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/proxy/HibernateProxyHandler.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/proxy/HibernateProxyHandler.java
index 613221cb30..65534a18cf 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/proxy/HibernateProxyHandler.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/proxy/HibernateProxyHandler.java
@@ -115,10 +115,10 @@ public class HibernateProxyHandler implements ProxyHandler, ProxyFactory {
 
     @Override
     public boolean isProxy(Object o) {
-        return GroovyProxyInterceptorLogic.getProxyInstanceMetaClass(o) != null ||
-                o instanceof EntityProxy ||
-                o instanceof HibernateProxy ||
-                o instanceof PersistentCollection;
+        return GroovyProxyInterceptorLogic.getProxyInstanceMetaClass(o) != null
+                || o instanceof EntityProxy
+                || o instanceof HibernateProxy
+                || o instanceof PersistentCollection;
     }
 
     @Override
@@ -144,7 +144,8 @@ public class HibernateProxyHandler implements ProxyHandler, ProxyFactory {
                 return org.hibernate.Hibernate.createDetachedProxy(sessionFactory, type, key);
             }
         }
-        throw new IllegalStateException("Could not obtain native Hibernate SessionFactory from Session#getNativeInterface()");
+        throw new IllegalStateException(
+                "Could not obtain native Hibernate SessionFactory from Session#getNativeInterface()");
     }
 
     @Override
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/HibernateQuery.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/HibernateQuery.java
index d7a1cf2d38..b95b6ed79c 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/HibernateQuery.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/HibernateQuery.java
@@ -344,11 +344,11 @@ public class HibernateQuery extends Query {
                     subCriteria.associationPath,
                     alias);
         }
-        throw new InvalidDataAccessApiUsageException("Cannot query association [" +
-                calculatePropertyName(associationName) +
-                "] of entity [" +
-                entity +
-                "]. Property is not an association!");
+        throw new InvalidDataAccessApiUsageException(
+                "Cannot query association [" + calculatePropertyName(associationName)
+                        + "] of entity ["
+                        + entity
+                        + "]. Property is not an association!");
     }
 
     @SuppressWarnings("PMD.DataflowAnomalyAnalysis")
@@ -480,8 +480,7 @@ public class HibernateQuery extends Query {
             JpaSubQuery<Tuple> innerSubquery = countQuery.subquery(Tuple.class);
 
             ConversionService cs = getSession().getMappingContext().getConversionService();
-            new JpaCriteriaQueryCreator(projections, cb, entity, detachedCriteria, cs)
-                    .populateSubquery(innerSubquery);
+            new JpaCriteriaQueryCreator(projections, cb, entity, detachedCriteria, cs).populateSubquery(innerSubquery);
 
             countQuery.from(innerSubquery);
             countQuery.select(cb.count(cb.literal(1)));
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/HibernateQueryArgument.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/HibernateQueryArgument.java
index 792777f067..1e22059ea2 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/HibernateQueryArgument.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/HibernateQueryArgument.java
@@ -32,6 +32,7 @@ import org.grails.datastore.gorm.finders.DynamicFinder;
  *
  * @since 8.0
  */
+@SuppressWarnings("PMD.AvoidFieldNameMatchingMethodName")
 public enum HibernateQueryArgument {
 
     // ── pagination & execution ────────────────────────────────────────────────
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/HibernateQueryConstants.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/HibernateQueryConstants.java
index 6fbc0e8c8d..a574354c2a 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/HibernateQueryConstants.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/HibernateQueryConstants.java
@@ -22,6 +22,7 @@ package org.grails.orm.hibernate.query;
  * @deprecated Use {@link HibernateQueryArgument} instead.
  */
 @Deprecated(since = "8.0", forRemoval = true)
+@SuppressWarnings("PMD.ConstantsInInterface")
 public interface HibernateQueryConstants {
 
     String ARGUMENT_FETCH_SIZE = HibernateQueryArgument.FETCH_SIZE.value();
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/JpaCriteriaQueryCreator.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/JpaCriteriaQueryCreator.java
index 59e5e4080a..144bbbafb7 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/JpaCriteriaQueryCreator.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/JpaCriteriaQueryCreator.java
@@ -83,8 +83,11 @@ public class JpaCriteriaQueryCreator {
         var cq = createCriteriaQuery(projectionList);
         Class<?> javaClass = entity.getJavaClass();
         Root<?> root = cq.from(javaClass);
-        var tablesByName = new JpaFromProvider(detachedCriteria, projectionList, 
-                hibernateQuery != null ? hibernateQuery.getAliases() : List.of(), root);
+        var tablesByName = new JpaFromProvider(
+                detachedCriteria,
+                projectionList,
+                hibernateQuery != null ? hibernateQuery.getAliases() : List.of(),
+                root);
         assignProjections(projectionList, cq, tablesByName);
         assignGroupBy(cq, tablesByName);
 
@@ -93,13 +96,15 @@ public class JpaCriteriaQueryCreator {
         return cq;
     }
 
-    @SuppressWarnings("unchecked")
     public <T> void populateSubquery(JpaSubQuery<T> subquery) {
         var projectionList = collectProjections();
         Class<?> javaClass = entity.getJavaClass();
         Root<?> root = subquery.from(javaClass);
-        var tablesByName = new JpaFromProvider(detachedCriteria, projectionList, 
-                hibernateQuery != null ? hibernateQuery.getAliases() : List.of(), root);
+        var tablesByName = new JpaFromProvider(
+                detachedCriteria,
+                projectionList,
+                hibernateQuery != null ? hibernateQuery.getAliases() : List.of(),
+                root);
 
         var aliasedProjections = new java.util.concurrent.atomic.AtomicInteger(0);
         var projectionExpressions = projectionList.stream()
@@ -140,13 +145,13 @@ public class JpaCriteriaQueryCreator {
 
     private JpaCriteriaQuery<?> createCriteriaQuery(List<Query.Projection> projections) {
         var cq = projections.stream()
-                                .filter(it -> !(it instanceof Query.DistinctProjection ||
-                                        it instanceof Query.DistinctPropertyProjection))
+                                .filter(it -> !(it instanceof Query.DistinctProjection
+                                        || it instanceof Query.DistinctPropertyProjection))
                                 .toList()
-                                .size() >
-                        1 ?
-                criteriaBuilder.createTupleQuery() :
-                criteriaBuilder.createQuery(Object.class);
+                                .size()
+                        > 1
+                ? criteriaBuilder.createTupleQuery()
+                : criteriaBuilder.createQuery(Object.class);
         projections.stream()
                 .filter(it -> it instanceof Query.DistinctProjection || it instanceof Query.DistinctPropertyProjection)
                 .findFirst()
@@ -186,13 +191,13 @@ public class JpaCriteriaQueryCreator {
                     .map(order -> {
                         Path<?> expression = tablesByName.getFullyQualifiedPath(order.getProperty());
                         if (order.isIgnoreCase() && expression.getJavaType().equals(String.class)) {
-                            return order.getDirection().equals(Query.Order.Direction.ASC) ?
-                                    criteriaBuilder.asc(criteriaBuilder.lower((Expression<String>) expression)) :
-                                    criteriaBuilder.desc(criteriaBuilder.lower((Expression<String>) expression));
+                            return order.getDirection().equals(Query.Order.Direction.ASC)
+                                    ? criteriaBuilder.asc(criteriaBuilder.lower((Expression<String>) expression))
+                                    : criteriaBuilder.desc(criteriaBuilder.lower((Expression<String>) expression));
                         } else {
-                            return order.getDirection().equals(Query.Order.Direction.ASC) ?
-                                    criteriaBuilder.asc(expression) :
-                                    criteriaBuilder.desc(expression);
+                            return order.getDirection().equals(Query.Order.Direction.ASC)
+                                    ? criteriaBuilder.asc(expression)
+                                    : criteriaBuilder.desc(expression);
                         }
                     })
                     .toArray(Order[]::new);
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/JpaFromProvider.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/JpaFromProvider.java
index d3cb2d9563..3a23f6b1e8 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/JpaFromProvider.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/JpaFromProvider.java
@@ -22,11 +22,9 @@ import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
-import java.util.function.Function;
 import java.util.stream.Collectors;
 
 import jakarta.persistence.FetchType;
-import jakarta.persistence.criteria.AbstractQuery;
 import jakarta.persistence.criteria.From;
 import jakarta.persistence.criteria.JoinType;
 import jakarta.persistence.criteria.Path;
@@ -55,6 +53,7 @@ public class JpaFromProvider implements Cloneable {
         this(detachedCriteria, projections, List.of(), root);
     }
 
+    @SuppressWarnings("PMD.ConstructorCallsOverridableMethod")
     public JpaFromProvider(
             DetachedCriteria<?> detachedCriteria,
             List<Query.Projection> projections,
@@ -63,6 +62,7 @@ public class JpaFromProvider implements Cloneable {
         fromMap = getFromsByName(detachedCriteria, projections, aliases, root);
     }
 
+    @SuppressWarnings("PMD.ConstructorCallsOverridableMethod")
     public JpaFromProvider(
             JpaFromProvider parent,
             DetachedCriteria<?> detachedCriteria,
@@ -91,7 +91,7 @@ public class JpaFromProvider implements Cloneable {
                 .toList();
 
         var aliasMap = createAliasMap(detachedAssociationCriteriaList);
-        
+
         // Also scan for HibernateAlias (basic collections)
         Map<String, String> basicAliasMap = new HashMap<>();
         for (HibernateAlias ha : aliases) {
@@ -136,7 +136,7 @@ public class JpaFromProvider implements Cloneable {
             String[] segments = path.split("\\.");
             StringBuilder current = new StringBuilder();
             for (String segment : segments) {
-                if (current.length() > 0) {
+                if (!current.isEmpty()) {
                     current.append(".");
                 }
                 current.append(segment);
@@ -168,7 +168,9 @@ public class JpaFromProvider implements Cloneable {
             JoinType joinType = JoinType.INNER;
             if (detachedCriteria.getJoinTypes().containsKey(path)) {
                 joinType = detachedCriteria.getJoinTypes().get(path);
-            } else if (finalProjectedPaths.contains(path) || eagerPaths.contains(path) || collectionPaths.contains(path)) {
+            } else if (finalProjectedPaths.contains(path)
+                    || eagerPaths.contains(path)
+                    || collectionPaths.contains(path)) {
                 joinType = JoinType.LEFT;
             }
 
@@ -179,7 +181,7 @@ public class JpaFromProvider implements Cloneable {
             if (dac != null && dac.getAlias() != null) {
                 fromsByPath.put(dac.getAlias(), table);
             }
-            
+
             String basicAlias = basicAliasMap.get(path);
             if (basicAlias != null) {
                 fromsByPath.put(basicAlias, table);
@@ -196,21 +198,6 @@ public class JpaFromProvider implements Cloneable {
         return fromsByPath;
     }
 
-    private Map<String, From<?, ?>> createDetachedFroms(
-            AbstractQuery<?> cq, List<DetachedAssociationCriteria<?>> detachedAssociationCriteriaList) {
-        Function<DetachedAssociationCriteria<?>, String> getAssociationPath =
-                DetachedAssociationCriteria::getAssociationPath;
-        return detachedAssociationCriteriaList.stream()
-                .collect(Collectors.toMap(
-                        getAssociationPath,
-                        criteria -> {
-                            Class<?> javaClass =
-                                    criteria.getAssociation().getOwner().getJavaClass();
-                            return cq.from(javaClass);
-                        },
-                        (oldValue, newValue) -> newValue));
-    }
-
     private Map<String, DetachedAssociationCriteria<?>> createAliasMap(
             List<DetachedAssociationCriteria<?>> detachedAssociationCriteriaList) {
         // Use a merge function and a stable map type to avoid DuplicateKey exceptions when the same
@@ -237,7 +224,8 @@ public class JpaFromProvider implements Cloneable {
         String[] parsed = propertyName.split("\\.");
         if (parsed.length == SINGLE_PROPERTY) {
             From<?, ?> root = fromMap.get("root");
-            if (propertyName.equals(root.getJavaType().getSimpleName()) || propertyName.equals(root.getJavaType().getName())) {
+            if (propertyName.equals(root.getJavaType().getSimpleName())
+                    || propertyName.equals(root.getJavaType().getName())) {
                 return root;
             }
             return root.get(propertyName);
@@ -263,6 +251,7 @@ public class JpaFromProvider implements Cloneable {
         return path;
     }
 
+    @Override
     public Object clone() {
         return new JpaFromProvider(fromMap);
     }
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/PredicateGenerator.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/PredicateGenerator.java
index 4b141302b0..e9a20cbd27 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/PredicateGenerator.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/PredicateGenerator.java
@@ -5,7 +5,6 @@ import java.util.Arrays;
 import java.util.Collection;
 import java.util.List;
 import java.util.Objects;
-import java.util.Optional;
 import java.util.stream.Stream;
 
 import groovy.util.logging.Slf4j;
@@ -40,11 +39,11 @@ import org.grails.datastore.mapping.query.api.QueryableCriteria;
 
 @Slf4j
 @SuppressWarnings({
-        "PMD.DataflowAnomalyAnalysis",
-        "PMD.AvoidLiteralsInIfCondition",
-        "PMD.AvoidDuplicateLiterals",
-        "unchecked",
-        "rawtypes"
+    "PMD.DataflowAnomalyAnalysis",
+    "PMD.AvoidLiteralsInIfCondition",
+    "PMD.AvoidDuplicateLiterals",
+    "unchecked",
+    "rawtypes"
 })
 public class PredicateGenerator {
     private static final Logger log = LoggerFactory.getLogger(PredicateGenerator.class);
@@ -96,10 +95,12 @@ public class PredicateGenerator {
         } else if (criterion instanceof Query.PropertyNameCriterion c) {
             return handlePropertyNameCriterion(cb, fromsByProvider, c);
         } else if (criterion instanceof Query.Exists c) {
-            return handleExists(cb, criteriaQuery, root, fromsByProvider, c.getSubquery().getPersistentEntity(), c);
+            return handleExists(
+                    cb, criteriaQuery, root, fromsByProvider, c.getSubquery().getPersistentEntity(), c);
         } else if (criterion instanceof Query.NotExists c) {
             PersistentEntity childEntity = c.getSubquery().getPersistentEntity();
-            return cb.not(handleExists(cb, criteriaQuery, root, fromsByProvider, childEntity, new Query.Exists(c.getSubquery())));
+            return cb.not(handleExists(
+                    cb, criteriaQuery, root, fromsByProvider, childEntity, new Query.Exists(c.getSubquery())));
         } else if (criterion instanceof HibernateAlias) {
             return null; // Metadata only, handled by JpaFromProvider
         }
@@ -141,14 +142,7 @@ public class PredicateGenerator {
 
         PersistentEntity associatedEntity = c.getAssociation().getAssociatedEntity();
 
-        return cb.and(getPredicates(
-                cb,
-                criteriaQuery,
-                child,
-                c.getCriteria(),
-                childTablesByName,
-                associatedEntity
-        ));
+        return cb.and(getPredicates(cb, criteriaQuery, child, c.getCriteria(), childTablesByName, associatedEntity));
     }
 
     private Predicate handleHibernateAssociationQuery(
@@ -160,7 +154,8 @@ public class PredicateGenerator {
         var child = root.join(haq.associationPath, JoinType.LEFT);
         JpaFromProvider childFroms = (JpaFromProvider) fromsByProvider.clone();
         childFroms.put("root", child);
-        return cb.and(getPredicates(cb, criteriaQuery, child, haq.getAssociationCriteria(), childFroms, haq.getEntity()));
+        return cb.and(
+                getPredicates(cb, criteriaQuery, child, haq.getAssociationCriteria(), childFroms, haq.getEntity()));
     }
 
     private Predicate handlePropertyCriterion(
@@ -172,10 +167,12 @@ public class PredicateGenerator {
             Query.PropertyCriterion pc) {
 
         String propertyName = pc.getProperty();
-        if (!"id".equals(propertyName) && !propertyName.contains(".") && 
-                entity.getPropertyByName(propertyName) == null && !fromsByProvider.hasAlias(propertyName)) {
-            throw new ConfigurationException("Property [" + propertyName +
-                    "] is not a valid property of class [" + entity.getName() + "]");
+        if (!"id".equals(propertyName)
+                && !propertyName.contains(".")
+                && entity.getPropertyByName(propertyName) == null
+                && !fromsByProvider.hasAlias(propertyName)) {
+            throw new ConfigurationException(
+                    "Property [" + propertyName + "] is not a valid property of class [" + entity.getName() + "]");
         }
 
         var fullyQualifiedPath = fromsByProvider.getFullyQualifiedPath(pc.getProperty());
@@ -187,7 +184,8 @@ public class PredicateGenerator {
         } else if (pc instanceof Query.In c) {
             return handleIn(cb, criteriaQuery, fromsByProvider, entity, c, fullyQualifiedPath);
         } else if (pc instanceof Query.ILike c) {
-            return cb.ilike((Expression<String>) fullyQualifiedPath, c.getValue().toString());
+            return cb.ilike(
+                    (Expression<String>) fullyQualifiedPath, c.getValue().toString());
         } else if (pc instanceof Query.RLike c) {
             return handleRLike(cb, fullyQualifiedPath, c);
         } else if (pc instanceof Query.Like c) {
@@ -234,7 +232,8 @@ public class PredicateGenerator {
         var queryableCriteria = getQueryableCriteriaFromInCriteria(c);
         if (Objects.nonNull(queryableCriteria)) {
             return cb.not(getQueryableCriteriaValue(cb, criteriaQuery, fromsByProvider, entity, c, queryableCriteria));
-        } else if (Objects.nonNull(c.getSubquery()) && !c.getSubquery().getProjections().isEmpty()) {
+        } else if (Objects.nonNull(c.getSubquery())
+                && !c.getSubquery().getProjections().isEmpty()) {
             Subquery subquery2 = criteriaQuery.subquery(Number.class);
             PersistentEntity subEntity = c.getValue().getPersistentEntity();
             Root from2 = subquery2.from(subEntity.getJavaClass());
@@ -242,11 +241,16 @@ public class PredicateGenerator {
             var projection = c.getSubquery().getProjections().get(0);
             if (projection instanceof Query.PropertyProjection pp) {
                 boolean distinct = projection instanceof Query.DistinctPropertyProjection;
-                Predicate[] predicates2 = getPredicates(cb, criteriaQuery, from2, c.getValue().getCriteria(), newMap2, subEntity);
-                subquery2.select(from2.get(pp.getPropertyName())).distinct(distinct).where(cb.and(predicates2));
+                Predicate[] predicates2 =
+                        getPredicates(cb, criteriaQuery, from2, c.getValue().getCriteria(), newMap2, subEntity);
+                subquery2
+                        .select(from2.get(pp.getPropertyName()))
+                        .distinct(distinct)
+                        .where(cb.and(predicates2));
                 return cb.not(cb.in(fullyQualifiedPath).value(subquery2));
             } else if (projection instanceof Query.IdProjection) {
-                Predicate[] predicates2 = getPredicates(cb, criteriaQuery, from2, c.getValue().getCriteria(), newMap2, subEntity);
+                Predicate[] predicates2 =
+                        getPredicates(cb, criteriaQuery, from2, c.getValue().getCriteria(), newMap2, subEntity);
                 subquery2.select(from2).where(cb.and(predicates2));
                 return cb.not(cb.in(fullyQualifiedPath).value(subquery2));
             }
@@ -268,12 +272,14 @@ public class PredicateGenerator {
             if (c.getValues().iterator().next() instanceof GormEntity firstEntity) {
                 List<GormEntity> gormEntities = new ArrayList<>(c.getValues());
                 Path id = criteriaQuery.from(firstEntity.getClass()).get("id");
-                Collection newValues = gormEntities.stream().map(GormEntity::ident).toList();
+                Collection newValues =
+                        gormEntities.stream().map(GormEntity::ident).toList();
                 return cb.in(id, newValues);
             }
-            
+
             // Hibernate 7: If the path is a collection, we must ensure it's correctly handled
-            if (fullyQualifiedPath instanceof SqmPath sqmPath && sqmPath.getReferencedPathSource() instanceof jakarta.persistence.metamodel.PluralAttribute) {
+            if (fullyQualifiedPath instanceof SqmPath sqmPath
+                    && sqmPath.getReferencedPathSource() instanceof jakarta.persistence.metamodel.PluralAttribute) {
                 // For basic collections, GORM's 'in' traditionally implies joining.
                 // We'll check if the path is already a join (From)
                 if (fullyQualifiedPath instanceof From) {
@@ -283,7 +289,7 @@ public class PredicateGenerator {
                 // but usually JpaFromProvider should have joined it if it was a property path
                 // that refers to a collection.
             }
-            
+
             return cb.in(fullyQualifiedPath, c.getValues());
         }
         return null;
@@ -291,7 +297,10 @@ public class PredicateGenerator {
 
     private Predicate handleRLike(HibernateCriteriaBuilder cb, Path fullyQualifiedPath, Query.RLike c) {
         String pattern = c.getPattern().replaceAll("^/|/$", "");
-        return cb.equal(cb.function(GrailsRLikeFunctionContributor.RLIKE, Boolean.class, fullyQualifiedPath, cb.literal(pattern)), true);
+        return cb.equal(
+                cb.function(
+                        GrailsRLikeFunctionContributor.RLIKE, Boolean.class, fullyQualifiedPath, cb.literal(pattern)),
+                true);
     }
 
     private Predicate handleSubqueryCriterion(
@@ -304,7 +313,8 @@ public class PredicateGenerator {
         Root from = subquery.from(subEntity.getJavaClass());
         JpaFromProvider newMap = (JpaFromProvider) fromsByProvider.clone();
         newMap.put("root", from);
-        Predicate[] predicates = getPredicates(cb, criteriaQuery, from, c.getValue().getCriteria(), newMap, subEntity);
+        Predicate[] predicates =
+                getPredicates(cb, criteriaQuery, from, c.getValue().getCriteria(), newMap, subEntity);
         Path path = fromsByProvider.getFullyQualifiedPath(c.getProperty());
 
         if (c instanceof Query.GreaterThanEqualsAll) {
@@ -383,10 +393,12 @@ public class PredicateGenerator {
         Root subRoot = subquery.from(entity.getJavaClass());
         JpaFromProvider newMap = (JpaFromProvider) fromsByProvider.clone();
         newMap.put("root", subRoot);
-        var predicates = getPredicates(cb, criteriaQuery, subRoot, c.getSubquery().getCriteria(), newMap, entity);
+        var predicates =
+                getPredicates(cb, criteriaQuery, subRoot, c.getSubquery().getCriteria(), newMap, entity);
         var existsPredicate = getExistsPredicate(cb, root_, entity, subRoot);
         Predicate[] allPredicates = existsPredicate != null
-                ? Stream.concat(Arrays.stream(predicates), Stream.of(existsPredicate)).toArray(Predicate[]::new)
+                ? Stream.concat(Arrays.stream(predicates), Stream.of(existsPredicate))
+                        .toArray(Predicate[]::new)
                 : predicates;
         subquery.select(cb.literal(1)).where(cb.and(allPredicates));
         return cb.exists(subquery);
@@ -418,26 +430,36 @@ public class PredicateGenerator {
                 PersistentProperty simpleProp = subEntity.getPropertyByName(simplePropName);
                 if (simpleProp != null) {
                     subqueryType = simpleProp.getType();
-                } else if (simplePropName.equals("id")) {
-                    subqueryType = subEntity.getIdentity() != null ? subEntity.getIdentity().getType() : Long.class;
+                } else if ("id".equals(simplePropName)) {
+                    subqueryType = subEntity.getIdentity() != null
+                            ? subEntity.getIdentity().getType()
+                            : Long.class;
                 }
             }
         } else if (projection instanceof Query.IdProjection) {
-            subqueryType = subEntity.getIdentity() != null ? subEntity.getIdentity().getType() : Long.class;
+            subqueryType =
+                    subEntity.getIdentity() != null ? subEntity.getIdentity().getType() : Long.class;
         } else if (isAssociation) {
-            subqueryType = subEntity.getIdentity() != null ? subEntity.getIdentity().getType() : Long.class;
+            subqueryType =
+                    subEntity.getIdentity() != null ? subEntity.getIdentity().getType() : Long.class;
         }
 
         var subquery = criteriaQuery.subquery(subqueryType);
         var from = subquery.from(subEntity.getJavaClass());
-        var clonedProviderByName = new JpaFromProvider(fromsByProvider, (DetachedCriteria<?>) queryableCriteria, java.util.Collections.emptyList(), from);
-        var predicates = getPredicates(cb, criteriaQuery, from, queryableCriteria.getCriteria(), clonedProviderByName, subEntity);
-        subquery.select((Expression) clonedProviderByName.getFullyQualifiedPath(subProperty)).distinct(true).where(cb.and(predicates));
+        var clonedProviderByName = new JpaFromProvider(
+                fromsByProvider, (DetachedCriteria<?>) queryableCriteria, java.util.Collections.emptyList(), from);
+        var predicates = getPredicates(
+                cb, criteriaQuery, from, queryableCriteria.getCriteria(), clonedProviderByName, subEntity);
+        subquery.select((Expression) clonedProviderByName.getFullyQualifiedPath(subProperty))
+                .distinct(true)
+                .where(cb.and(predicates));
         return in.value(subquery);
     }
 
     private boolean isAssociation(PersistentEntity entity, String propertyName) {
-        if (propertyName.equals("id") || (entity.getIdentity() != null && propertyName.equals(entity.getIdentity().getName()))) {
+        if ("id".equals(propertyName)
+                || (entity.getIdentity() != null
+                        && propertyName.equals(entity.getIdentity().getName()))) {
             return false;
         }
         PersistentProperty prop = entity.getPropertyByName(propertyName);
@@ -486,18 +508,18 @@ public class PredicateGenerator {
         if (value != null) {
             try {
                 return conversionService.convert(value, Number.class);
-            } catch (org.springframework.core.convert.ConversionException ignored) {
-                throw new ConfigurationException(String.format(
-                        "Operation '%s' on property '%s' only accepts a numeric value, but received a %s",
-                        criterion.getClass().getSimpleName(),
-                        criterion.getProperty(),
-                        value.getClass().getName()));
+            } catch (org.springframework.core.convert.ConversionException e) {
+                throw new ConfigurationException(
+                        String.format(
+                                "Operation '%s' on property '%s' only accepts a numeric value, but received a %s",
+                                criterion.getClass().getSimpleName(),
+                                criterion.getProperty(),
+                                value.getClass().getName()),
+                        e);
             }
         }
         throw new ConfigurationException(String.format(
                 "Operation '%s' on property '%s' only accepts a numeric value, but received a %s",
-                criterion.getClass().getSimpleName(),
-                criterion.getProperty(),
-                "null"));
+                criterion.getClass().getSimpleName(), criterion.getProperty(), "null"));
     }
 }
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/support/ClosureEventListener.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/support/ClosureEventListener.java
index 147a15b235..f8b248e1c2 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/support/ClosureEventListener.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/support/ClosureEventListener.java
@@ -18,6 +18,8 @@
  */
 package org.grails.orm.hibernate.support;
 
+import java.io.Serial;
+import java.io.Serializable;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -32,6 +34,7 @@ import org.hibernate.Session;
 import org.hibernate.engine.spi.SharedSessionContractImplementor;
 import org.hibernate.event.spi.AbstractEvent;
 import org.hibernate.event.spi.AbstractPreDatabaseOperationEvent;
+import org.hibernate.event.spi.EventSource;
 import org.hibernate.event.spi.MergeContext;
 import org.hibernate.event.spi.MergeEvent;
 import org.hibernate.event.spi.MergeEventListener;
@@ -75,7 +78,7 @@ import org.grails.datastore.mapping.validation.ValidationException;
 import org.grails.orm.hibernate.HibernateGormValidationApi;
 import org.grails.orm.hibernate.cfg.domainbinding.hibernate.GrailsHibernatePersistentEntity;
 
-@SuppressWarnings({"rawtypes", "unchecked", "serial"})
+@SuppressWarnings({"rawtypes", "unchecked", "PMD.CloseResource"})
 public class ClosureEventListener
         implements PreLoadEventListener,
                 PostLoadEventListener,
@@ -87,9 +90,12 @@ public class ClosureEventListener
                 PreUpdateEventListener,
                 MergeEventListener,
                 PersistEventListener,
-                CallbackRegistryConsumer {
+                CallbackRegistryConsumer,
+                Serializable {
 
+    @Serial
     private static final long serialVersionUID = 1;
+
     protected static final Logger LOG = LoggerFactory.getLogger(ClosureEventListener.class);
 
     private final EventTriggerCaller beforeInsertCaller;
@@ -114,9 +120,9 @@ public class ClosureEventListener
 
         beforeInsertCaller = buildCaller(AbstractPersistenceEvent.BEFORE_INSERT_EVENT, domainClazz);
         EventTriggerCaller preLoadCaller = buildCaller(AbstractPersistenceEvent.ONLOAD_EVENT, domainClazz);
-        this.preLoadEventCaller = (preLoadCaller != null) ?
-                preLoadCaller :
-                buildCaller(AbstractPersistenceEvent.BEFORE_LOAD_EVENT, domainClazz);
+        this.preLoadEventCaller = (preLoadCaller != null)
+                ? preLoadCaller
+                : buildCaller(AbstractPersistenceEvent.BEFORE_LOAD_EVENT, domainClazz);
 
         postLoadEventListener = buildCaller(AbstractPersistenceEvent.AFTER_LOAD_EVENT, domainClazz);
         postInsertEventListener = buildCaller(AbstractPersistenceEvent.AFTER_INSERT_EVENT, domainClazz);
@@ -126,9 +132,9 @@ public class ClosureEventListener
         preUpdateEventListener = buildCaller(AbstractPersistenceEvent.BEFORE_UPDATE_EVENT, domainClazz);
 
         beforeValidateEventListener = new BeforeValidateEventTriggerCaller(domainClazz, domainMetaClass);
-        failOnErrorEnabled = !failOnErrorPackages.isEmpty() ?
-                ClassUtils.isClassBelowPackage(domainClazz, failOnErrorPackages) :
-                failOnError;
+        failOnErrorEnabled = !failOnErrorPackages.isEmpty()
+                ? ClassUtils.isClassBelowPackage(domainClazz, failOnErrorPackages)
+                : failOnError;
 
         validateParams = new HashMap();
         validateParams.put(HibernateGormValidationApi.ARGUMENT_DEEP_VALIDATE, Boolean.FALSE);
@@ -163,8 +169,11 @@ public class ClosureEventListener
     // --- Specific manual session versions for PreLoad and PostLoad ---
 
     private void doPreLoadWithManualSession(PreLoadEvent event, Runnable action) {
-        SharedSessionContractImplementor sessionImpl = event.getSession();
-        if (sessionImpl instanceof Session session) {
+        flushOrRun(event.getSession(), action);
+    }
+
+    private void flushOrRun(EventSource event, Runnable action) {
+        if ((SharedSessionContractImplementor) event instanceof Session session) {
             FlushMode current = session.getHibernateFlushMode();
             try {
                 session.setHibernateFlushMode(FlushMode.MANUAL);
@@ -178,18 +187,7 @@ public class ClosureEventListener
     }
 
     private void doPostLoadWithManualSession(PostLoadEvent event, Runnable action) {
-        SharedSessionContractImplementor sessionImpl = event.getSession();
-        if (sessionImpl instanceof Session session) {
-            FlushMode current = session.getHibernateFlushMode();
-            try {
-                session.setHibernateFlushMode(FlushMode.MANUAL);
-                action.run();
-            } finally {
-                session.setHibernateFlushMode(current);
-            }
-        } else {
-            action.run();
-        }
+        flushOrRun(event.getSession(), action);
     }
 
     // --- Standard Overrides ---
@@ -245,8 +243,8 @@ public class ClosureEventListener
         if (!validateable.shouldSkipValidation() && !validateable.validate(validateParams)) {
             if (failOnErrorEnabled) {
                 throw ValidationException.newInstance(
-                        "Validation error whilst flushing entity [" +
-                                entity.getClass().getName() + "]",
+                        "Validation error whilst flushing entity ["
+                                + entity.getClass().getName() + "]",
                         validateable.getErrors());
             }
             return true;
@@ -314,17 +312,17 @@ public class ClosureEventListener
     }
 
     @Override
-    public void onMerge(MergeEvent event) { }
+    public void onMerge(MergeEvent event) {}
 
     @Override
-    public void onMerge(MergeEvent event, MergeContext copiedAlready) { }
+    public void onMerge(MergeEvent event, MergeContext copiedAlready) {}
 
     @Override
-    public void onPersist(PersistEvent event) { }
+    public void onPersist(PersistEvent event) {}
 
     @Override
-    public void onPersist(PersistEvent event, PersistContext createdAlready) { }
+    public void onPersist(PersistEvent event, PersistContext createdAlready) {}
 
     @Override
-    public void injectCallbackRegistry(CallbackRegistry callbackRegistry) { }
+    public void injectCallbackRegistry(CallbackRegistry callbackRegistry) {}
 }
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/support/ClosureEventTriggeringInterceptor.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/support/ClosureEventTriggeringInterceptor.java
index 16bcf887c8..1bcbe4e36c 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/support/ClosureEventTriggeringInterceptor.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/support/ClosureEventTriggeringInterceptor.java
@@ -18,10 +18,13 @@
  */
 package org.grails.orm.hibernate.support;
 
+import java.io.Serial;
 import java.io.Serializable;
 import java.util.Map;
 import java.util.Optional;
 
+import jakarta.annotation.Nullable;
+
 import org.hibernate.Hibernate;
 import org.hibernate.HibernateException;
 import org.hibernate.event.internal.DefaultMergeEventListener;
@@ -96,6 +99,7 @@ public class ClosureEventTriggeringInterceptor
                 CallbackRegistryConsumer {
 
     //    private final Logger log = LoggerFactory.getLogger(getClass());
+    @Serial
     private static final long serialVersionUID = 1;
 
     private final DefaultPersistEventListener persistEventListener = new DefaultPersistEventListener();
@@ -239,12 +243,14 @@ public class ClosureEventTriggeringInterceptor
         persistEventListener.injectCallbackRegistry(callbackRegistry);
     }
 
+    @Override
     public void onPreLoad(PreLoadEvent hibernateEvent) {
         org.grails.datastore.mapping.engine.event.PreLoadEvent grailsEvent =
                 new org.grails.datastore.mapping.engine.event.PreLoadEvent(this.datastore, hibernateEvent.getEntity());
         publishEvent(hibernateEvent, grailsEvent);
     }
 
+    @Override
     public void onPostLoad(PostLoadEvent hibernateEvent) {
         Object entity = hibernateEvent.getEntity();
         activateDirtyChecking(entity);
@@ -252,9 +258,10 @@ public class ClosureEventTriggeringInterceptor
                 hibernateEvent, new org.grails.datastore.mapping.engine.event.PostLoadEvent(this.datastore, entity));
     }
 
+    @Override
     public boolean onPreInsert(PreInsertEvent hibernateEvent) {
         Object entity = hibernateEvent.getEntity();
-        Class type = Hibernate.getClass(entity);
+        Class<?> type = Hibernate.getClass(entity);
         PersistentEntity persistentEntity = mappingContext.getPersistentEntity(type.getName());
         AbstractPersistenceEvent grailsEvent;
         ModificationTrackingEntityAccess entityAccess = null;
@@ -315,9 +322,9 @@ public class ClosureEventTriggeringInterceptor
         // Only for "dateCreated" property, "lastUpdated" is handled correctly
         if (dateCreatedMapping != null) {
             int dateCreatedIdx = dateCreatedMapping.getStateArrayPosition();
-            if (oldState != null &&
-                    oldState[dateCreatedIdx] != null &&
-                    !oldState[dateCreatedIdx].equals(state[dateCreatedIdx])) {
+            if (oldState != null
+                    && oldState[dateCreatedIdx] != null
+                    && !oldState[dateCreatedIdx].equals(state[dateCreatedIdx])) {
                 modifiedProperties.put(AutoTimestampEventListener.DATE_CREATED_PROPERTY, oldState[dateCreatedIdx]);
             }
         }
@@ -334,6 +341,7 @@ public class ClosureEventTriggeringInterceptor
         }
     }
 
+    @Override
     public void onPostInsert(PostInsertEvent hibernateEvent) {
         Object entity = hibernateEvent.getEntity();
         org.grails.datastore.mapping.engine.event.PostInsertEvent grailsEvent =
@@ -342,9 +350,10 @@ public class ClosureEventTriggeringInterceptor
         publishEvent(hibernateEvent, grailsEvent);
     }
 
+    @Override
     public boolean onPreUpdate(PreUpdateEvent hibernateEvent) {
         Object entity = hibernateEvent.getEntity();
-        Class type = Hibernate.getClass(entity);
+        Class<?> type = Hibernate.getClass(entity);
         MappingContext mappingContext = datastore.getMappingContext();
         PersistentEntity persistentEntity = mappingContext.getPersistentEntity(type.getName());
         AbstractPersistenceEvent grailsEvent;
@@ -368,6 +377,7 @@ public class ClosureEventTriggeringInterceptor
         return cancelled;
     }
 
+    @Override
     public void onPostUpdate(PostUpdateEvent hibernateEvent) {
         Object entity = hibernateEvent.getEntity();
         activateDirtyChecking(entity);
@@ -375,6 +385,7 @@ public class ClosureEventTriggeringInterceptor
                 hibernateEvent, new org.grails.datastore.mapping.engine.event.PostUpdateEvent(this.datastore, entity));
     }
 
+    @Override
     public boolean onPreDelete(PreDeleteEvent hibernateEvent) {
         AbstractPersistenceEvent event = new org.grails.datastore.mapping.engine.event.PreDeleteEvent(
                 this.datastore, hibernateEvent.getEntity());
@@ -382,6 +393,7 @@ public class ClosureEventTriggeringInterceptor
         return event.isCancelled();
     }
 
+    @Override
     public void onPostDelete(PostDeleteEvent hibernateEvent) {
         org.grails.datastore.mapping.engine.event.PostDeleteEvent grailsEvent =
                 new org.grails.datastore.mapping.engine.event.PostDeleteEvent(
@@ -399,7 +411,7 @@ public class ClosureEventTriggeringInterceptor
     }
 
     @Override
-    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
+    public void setApplicationContext(@Nullable ApplicationContext applicationContext) throws BeansException {
         if (applicationContext instanceof ConfigurableApplicationContext) {
 
             this.eventPublisher = new ConfigurableApplicationContextEventPublisher(
@@ -417,7 +429,7 @@ public class ClosureEventTriggeringInterceptor
                     persistentEntity.getReflector().getDirtyCheckingState(entity);
             if (dirtyCheckingState == null) {
                 dirtyCheckable.trackChanges();
-                for (Embedded association : persistentEntity.getEmbedded()) {
+                for (Embedded<?> association : persistentEntity.getEmbedded()) {
                     if (DirtyCheckable.class.isAssignableFrom(association.getType())) {
                         Object embedded = association.getReader().read(entity);
                         if (embedded != null) {
@@ -431,9 +443,4 @@ public class ClosureEventTriggeringInterceptor
             }
         }
     }
-
-    @Override
-    public boolean requiresPostCommitHandling(EntityPersister persister) {
-        return false;
-    }
 }
diff --git a/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/cfg/domainbinding/EnumTypeBinderSpec.groovy b/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/cfg/domainbinding/EnumTypeBinderSpec.groovy
index 1469524bd6..b9c78c09bd 100644
--- a/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/cfg/domainbinding/EnumTypeBinderSpec.groovy
+++ b/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/cfg/domainbinding/EnumTypeBinderSpec.groovy
@@ -1,8 +1,11 @@
 package org.grails.orm.hibernate.cfg.domainbinding
 
+import org.hibernate.type.descriptor.WrapperOptions
+
 import grails.gorm.specs.HibernateGormDatastoreSpec
 import grails.persistence.Entity
 import org.grails.datastore.mapping.model.PersistentProperty
+import org.grails.orm.hibernate.cfg.domainbinding.hibernate.HibernateBasicProperty
 import org.grails.orm.hibernate.cfg.domainbinding.hibernate.HibernateEnumProperty
 import org.grails.orm.hibernate.cfg.IdentityEnumType
 import jakarta.persistence.EnumType
@@ -61,11 +64,11 @@ class EnumTypeBinderSpec extends HibernateGormDatastoreSpec {
         def property = setupProperty(PersonWithCollection, "statuses", table)
 
         expect: "The property is a ToMany property"
-        property instanceof HibernateToManyProperty
+        property instanceof HibernateBasicProperty == true
 
-                when: "the enum is bound for the collection column"
+        when: "the enum is bound for the collection column"
         // This will now successfully call property.getComponentType() internally
-        def result = binder.bindEnumTypeForColumn(property as HibernateToManyProperty, "status_name")
+        def result = binder.bindEnumTypeForColumn(property as HibernateBasicProperty)
 
         then: "The BasicValue is configured correctly"
         result.getEnumerationStyle() == EnumType.STRING
@@ -159,8 +162,8 @@ class UserTypeEnumType implements UserType {
     @Override Class returnedClass() { Status01 }
     @Override boolean equals(Object x, Object y) { x == y }
     @Override int hashCode(Object x) { x.hashCode() }
-    @Override Object nullSafeGet(ResultSet rs, int position, SharedSessionContractImplementor session, Object owner) throws SQLException { null }
-    @Override void nullSafeSet(PreparedStatement st, Object value, int index, SharedSessionContractImplementor session) throws SQLException {}
+    @Override Object nullSafeGet(ResultSet rs, int position, WrapperOptions options) throws SQLException { null }
+    @Override void nullSafeSet(PreparedStatement st, Object value, int index, WrapperOptions options) throws SQLException {}
     @Override Object deepCopy(Object value) { value }
     @Override boolean isMutable() { false }
     @Override Serializable disassemble(Object value) { (Serializable)value }
diff --git a/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/cfg/domainbinding/secondpass/BasicCollectionElementBinderSpec.groovy b/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/cfg/domainbinding/secondpass/BasicCollectionElementBinderSpec.groovy
index 6747c23e98..2464add98e 100644
--- a/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/cfg/domainbinding/secondpass/BasicCollectionElementBinderSpec.groovy
+++ b/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/cfg/domainbinding/secondpass/BasicCollectionElementBinderSpec.groovy
@@ -78,7 +78,7 @@ class BasicCollectionElementBinderSpec extends HibernateGormDatastoreSpec {
         then:
         element != null
         // Corrected: Match the 3-argument signature (Property, Class, String)
-        1 * enumTypeBinder.bindEnumTypeForColumn(property, _ as String) >> mockValue
+        1 * enumTypeBinder.bindEnumTypeForColumn(property) >> mockValue
     }
 
     void "test bind with custom column mapping and backticks"() {
@@ -167,7 +167,7 @@ class BasicCollectionElementBinderSpec extends HibernateGormDatastoreSpec {
         then: "columnName is the resolved fully qualified Enum class name"
         // The namingStrategy resolves 'org.grails.orm.hibernate.cfg.domainbinding.secondpass.BCEBStatus'
         // to 'org_grails_orm_hibernate_cfg_domainbinding_secondpass_bcebstatus'
-        1 * enumTypeBinder.bindEnumTypeForColumn(property, 'org_grails_orm_hibernate_cfg_domainbinding_secondpass_bcebstatus') >> mockValue
+        1 * enumTypeBinder.bindEnumTypeForColumn(property) >> mockValue
         element == mockValue
     }
 
diff --git a/grails-datastore-core/src/main/groovy/org/grails/datastore/mapping/model/AbstractMappingContext.java b/grails-datastore-core/src/main/groovy/org/grails/datastore/mapping/model/AbstractMappingContext.java
index dea811c223..8afab3ed45 100644
--- a/grails-datastore-core/src/main/groovy/org/grails/datastore/mapping/model/AbstractMappingContext.java
+++ b/grails-datastore-core/src/main/groovy/org/grails/datastore/mapping/model/AbstractMappingContext.java
@@ -436,7 +436,7 @@ public abstract class AbstractMappingContext implements MappingContext, Initiali
         return null;
     }
 
-    protected abstract PersistentEntity createPersistentEntity(Class javaClass);
+    protected abstract PersistentEntity createPersistentEntity(Class<?> javaClass);
 
     protected Object resolveMappingStrategy(Class javaClass) {
         try {
@@ -451,7 +451,7 @@ public abstract class AbstractMappingContext implements MappingContext, Initiali
         return null;
     }
 
-    protected boolean isValidMappingStrategy(Class javaClass, Object mappingStrategy) {
+    protected boolean isValidMappingStrategy(Class<?> javaClass, Object mappingStrategy) {
         if (mappingStrategy == null) {
             return true;
         }
@@ -465,11 +465,11 @@ public abstract class AbstractMappingContext implements MappingContext, Initiali
         return false;
     }
 
-    protected PersistentEntity createPersistentEntity(Class javaClass, boolean external) {
+    protected PersistentEntity createPersistentEntity(Class<?> javaClass, boolean external) {
         return createPersistentEntity(javaClass);
     }
 
-    public PersistentEntity createEmbeddedEntity(Class type) {
+    public PersistentEntity createEmbeddedEntity(Class<?> type) {
         EmbeddedPersistentEntity embedded = new EmbeddedPersistentEntity(type, this);
         embedded.initialize();
         return embedded;


(grails-core) 03/08: hibernate 7: linting and EventListenerIntegrator tightening

Posted by bo...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

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

commit 45c7764f70a021cb5c29e455de1ab1d14dbb17a9
Author: Walter Duque de Estrada <wb...@mac.com>
AuthorDate: Sun Mar 22 11:21:59 2026 -0500

    hibernate 7: linting and EventListenerIntegrator tightening
---
 .../orm/hibernate/EventListenerIntegrator.java     |  7 ++-
 .../hibernate/HibernatePersistentProperty.java     | 17 +++-----
 .../secondpass/UnidirectionalOneToManyBinder.java  | 19 ++++----
 .../util/DefaultColumnNameFetcher.java             | 16 +++----
 .../hibernate/proxy/GrailsBytecodeProvider.java    | 13 ++----
 .../hibernate/EventListenerIntegratorSpec.groovy   | 51 ++++++++++++++++++++++
 6 files changed, 83 insertions(+), 40 deletions(-)

diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/EventListenerIntegrator.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/EventListenerIntegrator.java
index 7574f08676..c4e470b0ce 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/EventListenerIntegrator.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/EventListenerIntegrator.java
@@ -44,7 +44,6 @@ public class EventListenerIntegrator implements Integrator {
         this.eventListeners = eventListeners;
     }
 
-    @SuppressWarnings("unchecked")
     protected static final List<EventType<?>> TYPES = Arrays.asList(
             EventType.AUTO_FLUSH,
             EventType.MERGE,
@@ -83,6 +82,9 @@ public class EventListenerIntegrator implements Integrator {
     public void integrate(Metadata metadata, BootstrapContext bootstrapContext, SessionFactoryImplementor sfi) {
 
         EventListenerRegistry listenerRegistry = sfi.getServiceRegistry().getService(EventListenerRegistry.class);
+        if (listenerRegistry == null) {
+            throw new IllegalStateException("EventListenerRegistry not available from ServiceRegistry");
+        }
 
         if (eventListeners != null) {
             for (Map.Entry<String, Object> entry : eventListeners.entrySet()) {
@@ -115,7 +117,7 @@ public class EventListenerIntegrator implements Integrator {
                     // since ClosureEventTriggeringInterceptor extends DefaultSaveOrUpdateEventListener we
                     // want to override instead of append the listener here
                     // to avoid there being 2 implementations which would impact performance too
-                    group.clear();
+                    group.clearListeners();
                     group.appendListener(listener);
                 } else {
                     group.appendListener(listener);
@@ -151,6 +153,7 @@ public class EventListenerIntegrator implements Integrator {
         }
     }
 
+    @Override
     public void disintegrate(SessionFactoryImplementor sessionFactory, SessionFactoryServiceRegistry serviceRegistry) {
         // nothing to do
     }
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/hibernate/HibernatePersistentProperty.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/hibernate/HibernatePersistentProperty.java
index 6ed7139205..f45c0071ff 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/hibernate/HibernatePersistentProperty.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/hibernate/HibernatePersistentProperty.java
@@ -104,7 +104,7 @@ public interface HibernatePersistentProperty extends PersistentProperty<Property
     }
 
     default GrailsHibernatePersistentEntity getHibernateOwner() {
-        return (GrailsHibernatePersistentEntity )getOwner() ;
+        return (GrailsHibernatePersistentEntity) getOwner();
     }
 
     @SuppressWarnings("PMD.DataflowAnomalyAnalysis")
@@ -154,15 +154,15 @@ public interface HibernatePersistentProperty extends PersistentProperty<Property
 
     @Override
     default boolean isLazyAble() {
-        return this instanceof HibernateAssociation ||
-                !(this instanceof Embedded) && !this.equals(this.getOwner().getIdentity());
+        return this instanceof HibernateAssociation
+                || !(this instanceof Embedded) && !this.equals(this.getOwner().getIdentity());
     }
 
     /**
      * @return The mapped form
      */
     default PropertyConfig getHibernateMappedForm() {
-        return (PropertyConfig) getMappedForm();
+        return getMappedForm();
     }
 
     /**
@@ -181,10 +181,7 @@ public interface HibernatePersistentProperty extends PersistentProperty<Property
     }
 
     default String getMappedColumnName() {
-        if (getMappedForm() != null) {
-            return getMappedForm().getColumn();
-        }
-        return null;
+        return Optional.ofNullable(getMappedForm()).map(PropertyConfig::getColumn).orElse(null);
     }
 
     default String getColumnName(ColumnConfig cc) {
@@ -228,10 +225,10 @@ public interface HibernatePersistentProperty extends PersistentProperty<Property
     }
 
     default Table getTable() {
-      return getPersistentClass().getTable();
+        return getPersistentClass().getTable();
     }
 
-    default PersistentClass getPersistentClass(){
+    default PersistentClass getPersistentClass() {
         return getHibernateOwner().getPersistentClass();
     }
 }
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/secondpass/UnidirectionalOneToManyBinder.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/secondpass/UnidirectionalOneToManyBinder.java
index 79bdbbf293..321c7c4193 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/secondpass/UnidirectionalOneToManyBinder.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/secondpass/UnidirectionalOneToManyBinder.java
@@ -26,8 +26,7 @@ import org.hibernate.mapping.Collection;
 import org.hibernate.mapping.ManyToOne;
 import org.hibernate.mapping.OneToMany;
 import org.hibernate.mapping.Value;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
+
 
 import org.grails.orm.hibernate.cfg.domainbinding.hibernate.GrailsHibernatePersistentEntity;
 import org.grails.orm.hibernate.cfg.domainbinding.hibernate.HibernateOneToManyProperty;
@@ -38,7 +37,6 @@ import static org.grails.orm.hibernate.cfg.domainbinding.binder.GrailsDomainBind
 /** Binds unidirectional one-to-many associations. */
 public class UnidirectionalOneToManyBinder {
 
-    private static final Logger LOG = LoggerFactory.getLogger(UnidirectionalOneToManyBinder.class);
     private final CollectionWithJoinTableBinder collectionWithJoinTableBinder;
     private final BackticksRemover backticksRemover = new BackticksRemover();
     private final InFlightMetadataCollector mappings;
@@ -63,9 +61,9 @@ public class UnidirectionalOneToManyBinder {
         Value element = collection.getElement();
         element.createForeignKey();
 
-        String entityName = (element instanceof ManyToOne manyToOne) ?
-                manyToOne.getReferencedEntityName() :
-                ((OneToMany) element).getReferencedEntityName();
+        String entityName = (element instanceof ManyToOne manyToOne)
+                ? manyToOne.getReferencedEntityName()
+                : ((OneToMany) element).getReferencedEntityName();
 
         collection.setInverse(false);
 
@@ -76,11 +74,10 @@ public class UnidirectionalOneToManyBinder {
         GrailsHibernatePersistentEntity owner = (GrailsHibernatePersistentEntity) property.getOwner();
         Backref backref = new Backref();
         backref.setEntityName(owner.getName());
-        backref.setName(UNDERSCORE +
-                backticksRemover.apply(owner.getJavaClass().getSimpleName()) +
-                UNDERSCORE +
-                backticksRemover.apply(property.getName()) +
-                "Backref");
+        backref.setName(UNDERSCORE + backticksRemover.apply(owner.getJavaClass().getSimpleName())
+                + UNDERSCORE
+                + backticksRemover.apply(property.getName())
+                + "Backref");
         backref.setUpdatable(false);
         backref.setInsertable(true);
         backref.setCollectionRole(collection.getRole());
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/util/DefaultColumnNameFetcher.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/util/DefaultColumnNameFetcher.java
index 8ca63530bb..7594cbd244 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/util/DefaultColumnNameFetcher.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/util/DefaultColumnNameFetcher.java
@@ -65,20 +65,20 @@ public class DefaultColumnNameFetcher {
             if (!association.isBidirectional() && association instanceof HibernateOneToManyProperty) {
                 String prefix = namingStrategyWrapper.resolveTableName(
                         property.getOwner().getRootEntity().getJavaClass().getSimpleName());
-                return backticksRemover.apply(prefix) +
-                        UNDERSCORE +
-                        backticksRemover.apply(columnName) +
-                        FOREIGN_KEY_SUFFIX;
+                return backticksRemover.apply(prefix)
+                        + UNDERSCORE
+                        + backticksRemover.apply(columnName)
+                        + FOREIGN_KEY_SUFFIX;
             }
 
             if (property.isInherited() && property.isBidirectionalManyToOne()) {
                 return namingStrategyWrapper.resolveColumnName(property.getOwner()
                                 .getRootEntity()
                                 .getJavaClass()
-                                .getSimpleName()) +
-                        '_' +
-                        columnName +
-                        FOREIGN_KEY_SUFFIX;
+                                .getSimpleName())
+                        + '_'
+                        + columnName
+                        + FOREIGN_KEY_SUFFIX;
             }
 
             return columnName + FOREIGN_KEY_SUFFIX;
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/proxy/GrailsBytecodeProvider.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/proxy/GrailsBytecodeProvider.java
index 43044f3fd7..e4548d09ae 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/proxy/GrailsBytecodeProvider.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/proxy/GrailsBytecodeProvider.java
@@ -20,13 +20,13 @@ package org.grails.orm.hibernate.proxy;
 
 import java.util.Map;
 
-import org.hibernate.bytecode.enhance.spi.Enhancer;
 import org.hibernate.bytecode.enhance.spi.EnhancementContext;
+import org.hibernate.bytecode.enhance.spi.Enhancer;
 import org.hibernate.bytecode.spi.BytecodeProvider;
 import org.hibernate.bytecode.spi.ProxyFactoryFactory;
 import org.hibernate.bytecode.spi.ReflectionOptimizer;
-import org.hibernate.proxy.pojo.bytebuddy.ByteBuddyProxyHelper;
 import org.hibernate.property.access.spi.PropertyAccess;
+import org.hibernate.proxy.pojo.bytebuddy.ByteBuddyProxyHelper;
 
 /**
  * A {@link BytecodeProvider} implementation for Hibernate 7 that provides Groovy-aware proxies.
@@ -53,17 +53,12 @@ public class GrailsBytecodeProvider implements BytecodeProvider {
 
     @Override
     public ReflectionOptimizer getReflectionOptimizer(
-            Class clazz,
-            String[] getterNames,
-            String[] setterNames,
-            Class[] types) {
+            Class clazz, String[] getterNames, String[] setterNames, Class[] types) {
         return null;
     }
 
     @Override
-    public ReflectionOptimizer getReflectionOptimizer(
-            Class<?> clazz,
-            Map<String, PropertyAccess> propertyAccessMap) {
+    public ReflectionOptimizer getReflectionOptimizer(Class<?> clazz, Map<String, PropertyAccess> propertyAccessMap) {
         return null;
     }
 
diff --git a/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/EventListenerIntegratorSpec.groovy b/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/EventListenerIntegratorSpec.groovy
new file mode 100644
index 0000000000..1c6e21b298
--- /dev/null
+++ b/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/EventListenerIntegratorSpec.groovy
@@ -0,0 +1,51 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you under the Apache License, Version 2.0 (the
+ *  "License"); you may not use this file except in compliance
+ *  with the License.  You may obtain a copy of the License at
+ *
+ *    https://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing,
+ *  software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ *  specific language governing permissions and limitations
+ *  under the License.
+ */
+package org.grails.orm.hibernate
+
+import org.hibernate.boot.Metadata
+import org.hibernate.boot.spi.BootstrapContext
+import org.hibernate.engine.spi.SessionFactoryImplementor
+import org.hibernate.event.service.spi.EventListenerRegistry
+import org.hibernate.service.spi.SessionFactoryServiceRegistry
+import spock.lang.Specification
+
+class EventListenerIntegratorSpec extends Specification {
+
+    def "test that integrate throws IllegalStateException if EventListenerRegistry is not available"() {
+        given:
+        HibernateEventListeners hibernateEventListeners = Mock(HibernateEventListeners)
+        Map<String, Object> eventListeners = [:]
+        EventListenerIntegrator integrator = new EventListenerIntegrator(hibernateEventListeners, eventListeners)
+
+        Metadata metadata = Mock(Metadata)
+        BootstrapContext bootstrapContext = Mock(BootstrapContext)
+        SessionFactoryImplementor sfi = Mock(SessionFactoryImplementor)
+        SessionFactoryServiceRegistry serviceRegistry = Mock(SessionFactoryServiceRegistry)
+
+        when:
+        integrator.integrate(metadata, bootstrapContext, sfi)
+
+        then:
+        1 * sfi.getServiceRegistry() >> serviceRegistry
+        1 * serviceRegistry.getService(EventListenerRegistry) >> null
+        
+        def e = thrown(IllegalStateException)
+        e.message == "EventListenerRegistry not available from ServiceRegistry"
+    }
+}


(grails-core) 02/08: hibernate 7: linting

Posted by bo...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

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

commit a788ce1e984a92ab4a1974654366acab0c98cfcb
Author: Walter Duque de Estrada <wb...@mac.com>
AuthorDate: Sun Mar 22 11:00:18 2026 -0500

    hibernate 7: linting
---
 .../grails/orm/hibernate/cfg/domainbinding/util/CascadeBehavior.java  | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/util/CascadeBehavior.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/util/CascadeBehavior.java
index 195a648314..0a56a527dc 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/util/CascadeBehavior.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/util/CascadeBehavior.java
@@ -103,8 +103,8 @@ public enum CascadeBehavior {
     /** From string. */
     public static CascadeBehavior fromString(String value) {
         return Arrays.stream(CascadeBehavior.values())
-                .filter(behavior -> behavior.value.equalsIgnoreCase(value) ||
-                        ("save-update".equalsIgnoreCase(value) && behavior == SAVE_UPDATE))
+                .filter(behavior -> behavior.value.equalsIgnoreCase(value)
+                        || ("save-update".equalsIgnoreCase(value) && behavior == SAVE_UPDATE))
                 .findFirst()
                 .orElseThrow(() -> new MappingException("Invalid Cascade value: " + value + "."));
     }


(grails-core) 04/08: hibernate 7: Internally DataSource Connection.DEFAULT value was incorrect, still support legacy value hardcoded

Posted by bo...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

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

commit 0d2c60704c50b80d863e05a3a118e158551ce259
Author: Walter Duque de Estrada <wb...@mac.com>
AuthorDate: Sun Mar 22 13:25:05 2026 -0500

    hibernate 7: Internally DataSource Connection.DEFAULT value was incorrect, still support legacy value hardcoded
---
 grails-data-hibernate7/core/ISSUES.md              | 98 ++++++++++++++++++++++
 .../orm/hibernate/GrailsHibernateTemplate.java     | 17 ++--
 .../grails/orm/hibernate/HibernateDatastore.java   | 51 ++++++-----
 .../domainbinding/binder/GrailsDomainBinder.java   |  3 +-
 .../hibernate/GrailsHibernatePersistentEntity.java | 49 +++++------
 .../util/MultiTenantFilterBinder.java              |  3 +-
 .../HibernateConnectionSourceFactory.java          | 15 ++--
 .../proxy/GroovyProxyInterceptorLogic.java         | 26 +++---
 .../grails/orm/hibernate/query/HibernateAlias.java | 18 +---
 .../orm/hibernate/query/HqlQueryContext.java       | 42 +++++-----
 .../orm/hibernate/query/JpaFromProvider.java       |  2 +-
 .../orm/hibernate/HibernateDatastoreSpec.groovy    | 77 ++++++++++++++---
 .../cfg/GrailsHibernatePersistentEntitySpec.groovy |  3 +-
 .../cfg/HibernateMappingContextSpec.groovy         |  5 +-
 .../cfg/domainbinding/binder/RootBinderSpec.groovy |  7 +-
 .../domainbinding/binder/SubClassBinderSpec.groovy | 10 +--
 .../mapping/core/connections/ConnectionSource.java |  9 +-
 .../datastore/mapping/model/MappingContext.java    |  2 +-
 18 files changed, 294 insertions(+), 143 deletions(-)

diff --git a/grails-data-hibernate7/core/ISSUES.md b/grails-data-hibernate7/core/ISSUES.md
index 524d83cb6d..e9194b2bc3 100644
--- a/grails-data-hibernate7/core/ISSUES.md
+++ b/grails-data-hibernate7/core/ISSUES.md
@@ -1,7 +1,105 @@
 # Known Issues in Hibernate 7 Migration
 
+## [TODO] Review impact of changing `ConnectionSource.DEFAULT` to "default"
 
+**Description:**
+The value of `ConnectionSource.DEFAULT` was changed from `"DEFAULT"` to `"default"` (lowercase) to align with Grails 7 official conventions. 
+A new constant `ConnectionSource.OLD_DEFAULT = "DEFAULT"` was added for backward compatibility.
 
+In Grails 7:
+- GORM Connection Name: `"default"` (via `ConnectionSource.DEFAULT`)
+- Spring Bean ID: `"dataSource"`
+- Configuration Key: `"dataSource"`
 
+**Actions taken in H7:**
+- `HibernateDatastore.getDatastoreForConnection` supports `"dataSource"`, `ConnectionSource.DEFAULT` ("default"), and `ConnectionSource.OLD_DEFAULT` ("DEFAULT").
+- Raw `"default"` and `"DEFAULT"` strings in H7 production code and key tests have been replaced with `ConnectionSource.DEFAULT`.
+- `HibernateMappingContextConfiguration` and `HibernateDatastore` correctly use `ConnectionSource.DEFAULT` for the primary datasource name.
 
+**Risk & Potential Propagation:**
+- This change might affect other GORM modules (Neo4j, MongoDB, etc.) if they rely on the uppercase `"DEFAULT"` string literal and don't yet support the lowercase `"default"`.
+- Production systems referencing the raw string `"DEFAULT"` should be encouraged to use the `ConnectionSource.DEFAULT` constant.
 
+**Action Required:**
+- Audit other GORM implementations for consistency.
+
+## Static Analysis Violations (hibernate7-core)
+
+### Checkstyle
+| Class | Line | Error |
+|-------|------|-------|
+| `org.grails.orm.hibernate.proxy.HibernateProxyHandler` | 119-121 | '||' should be on the previous line. |
+| `org.grails.orm.hibernate.proxy.ByteBuddyGroovyInterceptor` | 67 | '+' should be on the previous line. |
+| `org.grails.orm.hibernate.proxy.ByteBuddyGroovyInterceptor` | 71-72 | '||' should be on the previous line. |
+| `org.grails.orm.hibernate.proxy.GroovyProxyInterceptorLogic` | 44 | '&&' should be on the previous line. |
+| `org.grails.orm.hibernate.proxy.GroovyProxyInterceptorLogic` | 64-67 | '||' should be on the previous line. |
+| `org.grails.orm.hibernate.access.TraitPropertyAccessStrategy` | 72 | '&&' should be on the previous line. |
+| `org.grails.orm.hibernate.access.TraitPropertyAccessStrategy` | 73 | '||' should be on the previous line. |
+| `org.grails.orm.hibernate.access.TraitPropertyAccessStrategy` | 80-113 | '+' should be on the previous line. (Multiple occurrences) |
+| `org.grails.orm.hibernate.HibernateDatastore` | 34 | 'javax.sql.DataSource' should be separated from previous imports. |
+| `org.grails.orm.hibernate.HibernateDatastore` | 332 | '||' should be on the previous line. |
+| `org.grails.orm.hibernate.HibernateDatastore` | 339-823 | '+' should be on the previous line. (Multiple occurrences) |
+| `org.grails.orm.hibernate.HibernateDatastore` | 927 | '?' should be on the previous line. |
+| `org.grails.orm.hibernate.HibernateDatastore` | 928 | ':' should be on the previous line. |
+| `org.grails.orm.hibernate.cfg.domainbinding.util.TableForManyCalculator` | 81 | '+' should be on the previous line. |
+| `org.grails.orm.hibernate.cfg.domainbinding.util.NamingStrategyProvider` | 92 | '?' should be on the previous line. |
+| `org.grails.orm.hibernate.cfg.domainbinding.util.NamingStrategyProvider` | 93 | ':' should be on the previous line. |
+| `org.grails.orm.hibernate.cfg.domainbinding.util.SimpleValueColumnFetcher` | 27 | '?' should be on the previous line. |
+| `org.grails.orm.hibernate.cfg.domainbinding.util.SimpleValueColumnFetcher` | 28 | ':' should be on the previous line. |
+| `org.grails.orm.hibernate.cfg.domainbinding.util.BasicValueIdCreator` | 73 | '?' should be on the previous line. |
+| `org.grails.orm.hibernate.cfg.domainbinding.util.BasicValueIdCreator` | 75 | ':' should be on the previous line. |
+| `org.grails.orm.hibernate.cfg.domainbinding.util.CascadeBehavior` | 107 | '||' should be on the previous line. |
+| `org.grails.orm.hibernate.cfg.domainbinding.util.DefaultColumnNameFetcher` | 69-81 | '+' should be on the previous line. (Multiple occurrences) |
+| `org.grails.orm.hibernate.cfg.domainbinding.util.OrderByClauseBuilder` | 107-108 | '||' should be on the previous line. |
+| `org.grails.orm.hibernate.cfg.domainbinding.util.OrderByClauseBuilder` | 109 | '&&' should be on the previous line. |
+| `org.grails.orm.hibernate.cfg.domainbinding.util.ColumnNameForPropertyAndPathFetcher` | 52-53 | '+' should be on the previous line. |
+| `org.grails.orm.hibernate.cfg.domainbinding.binder.ColumnBinder` | 130-149 | '+' should be on the previous line. (Multiple occurrences) |
+| `org.grails.orm.hibernate.cfg.domainbinding.binder.JoinedSubClassBinder` | 93-94 | '+' should be on the previous line. |
+| `org.grails.orm.hibernate.cfg.domainbinding.binder.SimpleValueBinder` | 105 | '?' should be on the previous line. |
+| `org.grails.orm.hibernate.cfg.domainbinding.binder.SimpleValueBinder` | 107 | ':' should be on the previous line. |
+| `org.grails.orm.hibernate.cfg.domainbinding.binder.UnionSubclassBinder` | 89-90 | '+' should be on the previous line. |
+| `org.grails.orm.hibernate.cfg.domainbinding.binder.ForeignKeyOneToOneBinder` | 71 | '&&' should be on the previous line. |
+
+### PMD
+| Class | Line | Error | Rule |
+|-------|------|-------|------|
+| `org.grails.orm.hibernate.GrailsHibernateTemplate` | 341 | New exception is thrown in catch block, original stack trace may be lost | PreserveStackTrace |
+| `org.grails.orm.hibernate.HibernateDatastore` | 661 | Avoid using Literals in Conditional Statements | AvoidLiteralsInIfCondition |
+| `org.grails.orm.hibernate.cfg.GrailsHibernateUtil` | 274 | Position literals first in String comparisons | LiteralsFirstInComparisons |
+| `org.grails.orm.hibernate.cfg.GrailsHibernateUtil` | 292 | Logger calls should be surrounded by log level guards. | GuardLogStatement |
+| `org.grails.orm.hibernate.cfg.GrailsHibernateUtil` | 294 | Logger calls should be surrounded by log level guards. | GuardLogStatement |
+| `org.grails.orm.hibernate.cfg.HibernateMappingContext` | 123 | Avoid reassigning parameters such as 'name' | AvoidReassigningParameters |
+| `org.grails.orm.hibernate.cfg.HibernateMappingContextConfiguration` | 106 | Field 'hibernateMappingContext' is of non-serializable type | NonSerializableClass |
+| `org.grails.orm.hibernate.cfg.HibernateMappingContextConfiguration` | 108 | Field 'hibernateEventListeners' is of non-serializable type | NonSerializableClass |
+| `org.grails.orm.hibernate.cfg.HibernateMappingContextConfiguration` | 114 | Field 'namingStrategyProvider' is of non-serializable type | NonSerializableClass |
+| `org.grails.orm.hibernate.cfg.HibernateMappingContextConfiguration` | 146 | The String literal "false" appears 5 times in this file | AvoidDuplicateLiterals |
+| `org.grails.orm.hibernate.cfg.HibernateMappingContextConfiguration` | 187 | The method 'addAnnotatedClasses(Class...)' is missing an @Override annotation. | MissingOverride |
+| `org.grails.orm.hibernate.cfg.HibernateMappingContextConfiguration` | 207 | The method 'addPackages(String...)' is missing an @Override annotation. | MissingOverride |
+| `org.grails.orm.hibernate.cfg.HibernateMappingContextConfiguration` | 348 | The method 'sessionFactoryClosed(SessionFactory)' is missing an @Override annotation. | MissingOverride |
+| `org.grails.orm.hibernate.cfg.IdentityEnumType$BidiEnumMap` | 203 | Logger calls should be surrounded by log level guards. | GuardLogStatement |
+| `org.grails.orm.hibernate.cfg.domainbinding.binder.ComponentBinder` | 69 | Avoid unused local variables such as 'table'. | UnusedLocalVariable |
+| `org.grails.orm.hibernate.cfg.domainbinding.binder.CompositeIdBinder` | 78 | Avoid unused local variables such as 'table'. | UnusedLocalVariable |
+| `org.grails.orm.hibernate.cfg.domainbinding.binder.EnumTypeBinder` | 107 | Switch statements should be exhaustive, add a default case | SwitchStmtsShouldHaveDefault |
+| `org.grails.orm.hibernate.cfg.domainbinding.binder.RootBinder` | 75 | Logger calls should be surrounded by log level guards. | GuardLogStatement |
+| `org.grails.orm.hibernate.cfg.domainbinding.binder.SimpleValueColumnBinder` | 36 | Avoid unused constructor parameters such as 'ignore'. | UnusedFormalParameter |
+| `org.grails.orm.hibernate.cfg.domainbinding.generator.GrailsNativeGenerator` | 73 | You should not modify visibility using setAccessible() | AvoidAccessibilityAlteration |
+| `org.grails.orm.hibernate.cfg.domainbinding.hibernate.GrailsHibernatePersistentEntity` | 50 | The method 'getMappedForm()' is missing an @Override annotation. | MissingOverride |
+| `org.grails.orm.hibernate.cfg.domainbinding.hibernate.HibernateAssociation` | 89 | The method 'isBidirectionalManyToOneWithListMapping(Property)' is missing an @Override annotation. | MissingOverride |
+| `org.grails.orm.hibernate.cfg.domainbinding.hibernate.HibernateAssociation` | 103 | The method 'getTypeName(Class, PropertyConfig, Mapping)' is missing an @Override annotation. | MissingOverride |
+| `org.grails.orm.hibernate.cfg.domainbinding.hibernate.HibernateBasicProperty` | 38 | The method 'getCollection()' is missing an @Override annotation. | MissingOverride |
+| `org.grails.orm.hibernate.cfg.domainbinding.hibernate.HibernateBasicProperty` | 42 | The method 'setCollection(Collection)' is missing an @Override annotation. | MissingOverride |
+| `org.grails.orm.hibernate.cfg.domainbinding.hibernate.HibernateEmbeddedCollectionProperty` | 43 | The method 'getCollection()' is missing an @Override annotation. | MissingOverride |
+| `org.grails.orm.hibernate.cfg.domainbinding.hibernate.HibernateEmbeddedCollectionProperty` | 47 | The method 'setCollection(Collection)' is missing an @Override annotation. | MissingOverride |
+| `org.grails.orm.hibernate.cfg.domainbinding.hibernate.HibernateEmbeddedPersistentEntity` | 35 | The method 'getMappedForm()' is missing an @Override annotation. | MissingOverride |
+| `org.grails.orm.hibernate.cfg.domainbinding.hibernate.HibernateIdentityMapping` | 60 | Returning 'DEFAULT_IDENTITY_MAPPING' may expose an internal array. | MethodReturnsInternalArray |
+| `org.grails.orm.hibernate.cfg.domainbinding.hibernate.HibernateManyToManyProperty` | 44 | The method 'getReferencedEntityName()' is missing an @Override annotation. | MissingOverride |
+
+### SpotBugs
+| Class | Line | Error | Bug Type |
+|-------|------|-------|----------|
+| `org.grails.orm.hibernate.query.PagedResultList` | 50-93 | Class shadows the simple name of the superclass | NM_SAME_SIMPLE_NAME_AS_SUPERCLASS |
+| `org.grails.orm.hibernate.cfg.HibernateMappingContextConfiguration` | N/A | Non-serializable field `hibernateEventListeners` | SE_BAD_FIELD |
+| `org.grails.orm.hibernate.cfg.HibernateMappingContextConfiguration` | N/A | Non-serializable field `hibernateMappingContext` | SE_BAD_FIELD |
+| `org.grails.orm.hibernate.cfg.HibernateMappingContextConfiguration` | N/A | Non-serializable field `namingStrategyProvider` | SE_BAD_FIELD |
+| `org.grails.orm.hibernate.proxy.ByteBuddyGroovyInterceptor` | N/A | Potential null pointer dereference in proxy logic | NP_NULL_ON_SOME_PATH |
+| `org.grails.orm.hibernate.proxy.ByteBuddyGroovyProxyFactory` | N/A | Class implements Serializable but doesn't define serialVersionUID | SE_NO_SERIALVERSIONID |
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/GrailsHibernateTemplate.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/GrailsHibernateTemplate.java
index d44afc3747..60049f9100 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/GrailsHibernateTemplate.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/GrailsHibernateTemplate.java
@@ -26,7 +26,6 @@ import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
 import java.util.Objects;
-
 import javax.sql.DataSource;
 
 import groovy.lang.Closure;
@@ -148,7 +147,8 @@ public class GrailsHibernateTemplate implements IHibernateTemplate {
 
     @Override
     public <T> T execute(Closure<T> callable) {
-        HibernateCallback<T> hibernateCallback = DefaultGroovyMethods.asType(callable, HibernateCallback.class);
+        @SuppressWarnings("unchecked")
+        HibernateCallback<T> hibernateCallback = (HibernateCallback<T>) DefaultGroovyMethods.asType(callable, HibernateCallback.class);
         return execute(hibernateCallback);
     }
 
@@ -207,8 +207,8 @@ public class GrailsHibernateTemplate implements IHibernateTemplate {
                         (ConnectionHolder) TransactionSynchronizationManager.unbindResourceIfPossible(dataSource);
                 // if there is a connection holder and it holds an open connection close it
                 try {
-                    if (connectionHolder != null &&
-                            !connectionHolder.getConnection().isClosed()) {
+                    if (connectionHolder != null
+                            && !connectionHolder.getConnection().isClosed()) {
                         Connection conn = connectionHolder.getConnection();
                         DataSourceUtils.releaseConnection(conn, dataSource);
                     }
@@ -216,8 +216,8 @@ public class GrailsHibernateTemplate implements IHibernateTemplate {
                     // ignore, connection closed already?
                     if (LOG.isDebugEnabled()) {
                         LOG.debug(
-                                "Could not close opened JDBC connection. Did the application close the connection manually?: " +
-                                        e.getMessage());
+                                "Could not close opened JDBC connection. Did the application close the connection manually?: "
+                                        + e.getMessage());
                     }
                 }
             } finally {
@@ -284,8 +284,8 @@ public class GrailsHibernateTemplate implements IHibernateTemplate {
     }
 
     protected boolean shouldPassReadOnlyToHibernate() {
-        if ((passReadOnlyToHibernate || osivReadOnly) &&
-                TransactionSynchronizationManager.hasResource(getSessionFactory())) {
+        if ((passReadOnlyToHibernate || osivReadOnly)
+                && TransactionSynchronizationManager.hasResource(getSessionFactory())) {
             if (TransactionSynchronizationManager.isActualTransactionActive()) {
                 return passReadOnlyToHibernate && TransactionSynchronizationManager.isCurrentTransactionReadOnly();
             } else {
@@ -338,6 +338,7 @@ public class GrailsHibernateTemplate implements IHibernateTemplate {
             throw convertHibernateAccessException(ex);
         } catch (PersistenceException ex) {
             if (ex.getCause() instanceof HibernateException) {
+                // @SuppressWarnings("PMD.PreserveStackTrace")
                 throw SessionFactoryUtils.convertHibernateAccessException((HibernateException) ex.getCause());
             }
             throw ex;
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/HibernateDatastore.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/HibernateDatastore.java
index 07f32bf806..23262b6a9b 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/HibernateDatastore.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/HibernateDatastore.java
@@ -31,7 +31,6 @@ import java.util.List;
 import java.util.Map;
 import java.util.Objects;
 import java.util.concurrent.Callable;
-
 import javax.sql.DataSource;
 
 import groovy.lang.Closure;
@@ -109,7 +108,6 @@ import org.grails.datastore.mapping.multitenancy.resolvers.FixedTenantResolver;
 import org.grails.datastore.mapping.transactions.TransactionCapableDatastore;
 import org.grails.datastore.mapping.validation.ValidatorRegistry;
 import org.grails.orm.hibernate.cfg.HibernateMappingContext;
-import org.grails.orm.hibernate.cfg.MappingCacheHolder;
 import org.grails.orm.hibernate.cfg.Settings;
 import org.grails.orm.hibernate.connections.HibernateConnectionSource;
 import org.grails.orm.hibernate.connections.HibernateConnectionSourceFactory;
@@ -219,7 +217,7 @@ public class HibernateDatastore extends AbstractDatastore
         this.connectionSources = connectionSources;
         final HibernateConnectionSource defaultConnectionSource =
                 (HibernateConnectionSource) connectionSources.getDefaultConnectionSource();
-        this.dataSourceName = defaultConnectionSource.getName();
+        this.dataSourceName = ConnectionSource.DEFAULT;
         this.sessionFactory = defaultConnectionSource.getSource();
         HibernateConnectionSourceSettings settings = defaultConnectionSource.getSettings();
         HibernateConnectionSourceSettings.HibernateSettings hibernateSettings = settings.getHibernate();
@@ -330,16 +328,15 @@ public class HibernateDatastore extends AbstractDatastore
 
             @Override
             public HibernateDatastore getDatastoreForConnection(String connectionName) {
-                if (connectionName.equals(Settings.SETTING_DATASOURCE) ||
-                        connectionName.equals(ConnectionSource.DEFAULT)) {
+                if (Settings.SETTING_DATASOURCE.equals(connectionName)
+                        || ConnectionSource.DEFAULT.equals(connectionName)) {
                     return parent;
                 } else {
                     HibernateDatastore hibernateDatastore = parent.datastoresByConnectionSource.get(connectionName);
                     if (hibernateDatastore == null) {
                         throw new ConfigurationException(
-                                "DataSource not found for name [" +
-                                        connectionName +
-                                        "] in configuration. Please check your multiple data sources configuration and try again.");
+                                "DataSource not found for name [" + connectionName
+                                        + "] in configuration. Please check your multiple data sources configuration and try again.");
                     }
                     return hibernateDatastore;
                 }
@@ -576,6 +573,7 @@ public class HibernateDatastore extends AbstractDatastore
     /**
      * @return The {@link org.springframework.transaction.PlatformTransactionManager} instance
      */
+    @Override
     public GrailsHibernateTransactionManager getTransactionManager() {
         return transactionManager;
     }
@@ -588,14 +586,15 @@ public class HibernateDatastore extends AbstractDatastore
      */
     @Override
     public HibernateDatastore getDatastoreForConnection(String connectionName) {
-        if (Settings.SETTING_DATASOURCE.equals(connectionName) || ConnectionSource.DEFAULT.equals(connectionName)) {
+        if (Settings.SETTING_DATASOURCE.equals(connectionName)
+                || ConnectionSource.DEFAULT.equals(connectionName)
+                || ConnectionSource.OLD_DEFAULT.equals(connectionName)) {
             return this;
         } else {
             HibernateDatastore hibernateDatastore = this.datastoresByConnectionSource.get(connectionName);
             if (hibernateDatastore == null) {
-                throw new ConfigurationException("DataSource not found for name [" +
-                        connectionName +
-                        "] in configuration. Please check your multiple data sources configuration and try again.");
+                throw new ConfigurationException("DataSource not found for name [" + connectionName
+                        + "] in configuration. Please check your multiple data sources configuration and try again.");
             }
             return hibernateDatastore;
         }
@@ -661,7 +660,7 @@ public class HibernateDatastore extends AbstractDatastore
                                     schemaHandler.resolveSchemaNames(defaultConnectionSource.getDataSource());
                             for (String schemaName : schemaNames) {
                                 // skip common internal schemas
-                                if (schemaName.equals("INFORMATION_SCHEMA") || schemaName.equals("PUBLIC")) continue;
+                                if ("INFORMATION_SCHEMA".equals(schemaName) || "PUBLIC".equals(schemaName)) continue;
                                 for (String connectionName : datastoresByConnectionSource.keySet()) {
                                     if (schemaName.equalsIgnoreCase(connectionName)) {
                                         allQualifiers.add(connectionName);
@@ -689,6 +688,7 @@ public class HibernateDatastore extends AbstractDatastore
         return new HibernateSession(this, sessionFactory);
     }
 
+    @Override
     public void setApplicationContext(@Nullable ApplicationContext applicationContext) throws BeansException {
         if (applicationContext instanceof ConfigurableApplicationContext) {
             super.setApplicationContext(applicationContext);
@@ -764,7 +764,9 @@ public class HibernateDatastore extends AbstractDatastore
                 try {
                     connectionSources.close();
                 } catch (IOException e) {
-                    LOG.error("There was an error shutting down GORM for an entity: {}", e.getMessage(), e);
+                    if (LOG.isErrorEnabled()) {
+                        LOG.error("There was an error shutting down GORM for an entity: {}", e.getMessage(), e);
+                    }
                 }
             } finally {
                 getMappingContext().getMappingCacheHolder().clear();
@@ -773,7 +775,9 @@ public class HibernateDatastore extends AbstractDatastore
                         this.gormEnhancer.close();
                     }
                 } catch (IOException e) {
-                    LOG.error("There was an error shutting down GORM enhancer", e);
+                    if (LOG.isErrorEnabled()) {
+                        LOG.error("There was an error shutting down GORM enhancer", e);
+                    }
                 }
                 destroyed = true;
             }
@@ -817,16 +821,15 @@ public class HibernateDatastore extends AbstractDatastore
     private void addTenantForSchemaInternal(final String schemaName) {
         if (multiTenantMode != MultiTenancySettings.MultiTenancyMode.SCHEMA) {
             throw new ConfigurationException(
-                    "The method [addTenantForSchema] can only be called with multi-tenancy mode SCHEMA. Current mode is: " +
-                            multiTenantMode);
+                    "The method [addTenantForSchema] can only be called with multi-tenancy mode SCHEMA. Current mode is: "
+                            + multiTenantMode);
         }
         HibernateConnectionSourceFactory factory = (HibernateConnectionSourceFactory) connectionSources.getFactory();
         HibernateConnectionSource defaultConnectionSource =
                 (HibernateConnectionSource) connectionSources.getDefaultConnectionSource();
         HibernateConnectionSourceSettings tenantSettings;
         try {
-            tenantSettings = (HibernateConnectionSourceSettings)
-                    connectionSources.getDefaultConnectionSource().getSettings().clone();
+            tenantSettings = (HibernateConnectionSourceSettings) connectionSources.getDefaultConnectionSource().getSettings().clone();
         } catch (CloneNotSupportedException e) {
             throw new ConfigurationException("Couldn't clone default Hibernate settings! " + e.getMessage(), e);
         }
@@ -921,9 +924,9 @@ public class HibernateDatastore extends AbstractDatastore
 
     @Override
     public MultiTenancySettings.MultiTenancyMode getMultiTenancyMode() {
-        return this.multiTenantMode == MultiTenancySettings.MultiTenancyMode.SCHEMA ?
-                MultiTenancySettings.MultiTenancyMode.DATABASE :
-                this.multiTenantMode;
+        return this.multiTenantMode == MultiTenancySettings.MultiTenancyMode.SCHEMA
+                ? MultiTenancySettings.MultiTenancyMode.DATABASE
+                : this.multiTenantMode;
     }
 
     @Override
@@ -1111,7 +1114,9 @@ public class HibernateDatastore extends AbstractDatastore
         try {
             destroy();
         } catch (Exception e) {
-            LOG.error("Error closing hibernate datastore: {}", e.getMessage(), e);
+            if (LOG.isErrorEnabled()) {
+                LOG.error("Error closing hibernate datastore: {}", e.getMessage(), e);
+            }
         }
     }
 }
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/GrailsDomainBinder.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/GrailsDomainBinder.java
index f16f5cd717..eabaa2d192 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/GrailsDomainBinder.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/GrailsDomainBinder.java
@@ -18,6 +18,7 @@
  */
 package org.grails.orm.hibernate.cfg.domainbinding.binder;
 
+import org.grails.datastore.mapping.core.connections.ConnectionSource;
 import org.hibernate.boot.ResourceStreamLocator;
 import org.hibernate.boot.internal.MetadataBuildingContextRootImpl;
 import org.hibernate.boot.model.TypeContributions;
@@ -116,7 +117,7 @@ public class GrailsDomainBinder implements AdditionalMappingContributor, TypeCon
             ResourceStreamLocator resourceStreamLocator,
             MetadataBuildingContext buildingContext) {
         this.metadataBuildingContext = new MetadataBuildingContextRootImpl(
-                "default",
+                ConnectionSource.DEFAULT,
                 metadataCollector.getBootstrapContext(),
                 metadataCollector.getMetadataBuildingOptions(),
                 metadataCollector,
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/hibernate/GrailsHibernatePersistentEntity.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/hibernate/GrailsHibernatePersistentEntity.java
index 84f119d6a1..e85c6e4f38 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/hibernate/GrailsHibernatePersistentEntity.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/hibernate/GrailsHibernatePersistentEntity.java
@@ -28,6 +28,7 @@ import java.util.stream.Stream;
 
 import jakarta.annotation.Nonnull;
 
+import org.hibernate.FetchMode;
 import org.hibernate.boot.spi.InFlightMetadataCollector;
 import org.hibernate.mapping.PersistentClass;
 
@@ -233,9 +234,7 @@ public interface GrailsHibernatePersistentEntity extends PersistentEntity {
     }
 
     default List<HibernatePersistentEntity> getChildEntities(String dataSourceName) {
-        return getMappingContext()
-                .getDirectChildEntities(this)
-                .stream()
+        return getMappingContext().getDirectChildEntities(this).stream()
                 .filter(HibernatePersistentEntity.class::isInstance)
                 .map(HibernatePersistentEntity.class::cast)
                 .filter(persistentEntity -> persistentEntity.usesConnectionSource(dataSourceName))
@@ -301,9 +300,9 @@ public interface GrailsHibernatePersistentEntity extends PersistentEntity {
     }
 
     private static String resolveDiscriminatorValue(DiscriminatorConfig discriminatorConfig) {
-        return discriminatorConfig.getColumn() != null ?
-                discriminatorConfig.getColumn().getName() :
-                discriminatorConfig.getFormula();
+        return discriminatorConfig.getColumn() != null
+                ? discriminatorConfig.getColumn().getName()
+                : discriminatorConfig.getFormula();
     }
 
     default List<HibernatePersistentProperty> getHibernatePersistentProperties() {
@@ -312,12 +311,13 @@ public interface GrailsHibernatePersistentEntity extends PersistentEntity {
                 .map(HibernatePersistentProperty.class::cast)
                 .toList());
         properties.sort((p1, p2) -> {
-            if (p1 instanceof org.grails.orm.hibernate.cfg.domainbinding.hibernate.HibernateEmbeddedProperty &&
-                    !(p2 instanceof
-                                                        org.grails.orm.hibernate.cfg.domainbinding.hibernate.HibernateEmbeddedProperty)) {
+            if (p1 instanceof org.grails.orm.hibernate.cfg.domainbinding.hibernate.HibernateEmbeddedProperty
+                    && !(p2
+                            instanceof
+                            org.grails.orm.hibernate.cfg.domainbinding.hibernate.HibernateEmbeddedProperty)) {
                 return -1;
-            } else if (!(p1 instanceof org.grails.orm.hibernate.cfg.domainbinding.hibernate.HibernateEmbeddedProperty) &&
-                    p2 instanceof org.grails.orm.hibernate.cfg.domainbinding.hibernate.HibernateEmbeddedProperty) {
+            } else if (!(p1 instanceof org.grails.orm.hibernate.cfg.domainbinding.hibernate.HibernateEmbeddedProperty)
+                    && p2 instanceof org.grails.orm.hibernate.cfg.domainbinding.hibernate.HibernateEmbeddedProperty) {
                 return 1;
             }
             return p1.getName().compareTo(p2.getName());
@@ -348,23 +348,14 @@ public interface GrailsHibernatePersistentEntity extends PersistentEntity {
             return false;
         }
 
-        org.grails.orm.hibernate.cfg.PropertyConfig config = property.getMappedForm();
-
-        if (property instanceof HibernateAssociation) {
-            // Explicit fetch: 'join' implies eager (not lazy) and takes precedence in Hibernate
-            if (config != null && org.hibernate.FetchMode.JOIN.equals(config.getFetchMode())) {
-                return false;
-            }
-            if (config != null && config.getLazy() != null) {
-                return config.getLazy();
-            }
-            return true;
-        }
-
-        if (config != null && config.getLazy() != null) {
-            return config.getLazy();
-        }
-
-        return false;
+        return Optional.ofNullable(property.getMappedForm())
+                .map(config -> {
+                    if (property instanceof HibernateAssociation &&
+                            FetchMode.JOIN.equals(config.getFetchMode())) {
+                        return false;
+                    }
+                    return config.getLazy();
+                })
+                .orElseGet(() -> property instanceof HibernateAssociation);
     }
 }
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/util/MultiTenantFilterBinder.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/util/MultiTenantFilterBinder.java
index 0d332dd5b2..9ae540fb11 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/util/MultiTenantFilterBinder.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/util/MultiTenantFilterBinder.java
@@ -81,8 +81,7 @@ public class MultiTenantFilterBinder {
      * @return null as it's redundant for single table subclasses
      */
     @Nullable
-    public FilterDefinition bind(
-            @Nonnull HibernatePersistentEntity entity, @Nonnull SingleTableSubclass subclass) {
+    public FilterDefinition bind(@Nonnull HibernatePersistentEntity entity, @Nonnull SingleTableSubclass subclass) {
         return null; // Redundant for SingleTableSubclass
     }
 
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/connections/HibernateConnectionSourceFactory.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/connections/HibernateConnectionSourceFactory.java
index 52e126bfe3..a8695cdd47 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/connections/HibernateConnectionSourceFactory.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/connections/HibernateConnectionSourceFactory.java
@@ -23,7 +23,6 @@ import java.io.IOException;
 import java.io.Serializable;
 import java.util.Collections;
 import java.util.Map;
-
 import javax.sql.DataSource;
 
 import jakarta.annotation.Nullable;
@@ -57,7 +56,6 @@ import org.grails.orm.hibernate.HibernateEventListeners;
 import org.grails.orm.hibernate.cfg.HibernateMappingContext;
 import org.grails.orm.hibernate.cfg.HibernateMappingContextConfiguration;
 import org.grails.orm.hibernate.cfg.Settings;
-import org.grails.orm.hibernate.cfg.domainbinding.binder.GrailsDomainBinder;
 import org.grails.orm.hibernate.support.ClosureEventTriggeringInterceptor;
 
 /**
@@ -145,11 +143,12 @@ public class HibernateConnectionSourceFactory
                 resolveEventTriggeringInterceptor(hibernateSettings.getClosureEventTriggeringInterceptorClass());
         hibernateSettings.setEventTriggeringInterceptor(eventTriggeringInterceptor);
 
-        configuration.setEventListeners(hibernateSettings.toHibernateEventListeners(eventTriggeringInterceptor));
+        configuration.setEventListeners(HibernateConnectionSourceSettings.HibernateSettings.toHibernateEventListeners(
+                eventTriggeringInterceptor));
         configuration.setHibernateEventListeners(
-                this.hibernateEventListeners != null ?
-                        this.hibernateEventListeners :
-                        hibernateSettings.getHibernateEventListeners());
+                this.hibernateEventListeners != null
+                        ? this.hibernateEventListeners
+                        : hibernateSettings.getHibernateEventListeners());
         configuration.setHibernateMappingContext(mappingContext);
         configuration.setDataSourceName(name);
         configuration.setSessionFactoryBeanName(
@@ -288,8 +287,8 @@ public class HibernateConnectionSourceFactory
         DataSourceSettings dsFallback = extractDataSourceFallback(fallbackSettings);
         HibernateConnectionSourceSettings settings =
                 new HibernateConnectionSourceSettingsBuilder(configuration, prefix, fallbackSettings).build();
-        if (prefix.isEmpty() ||
-                configuration
+        if (prefix.isEmpty()
+                || configuration
                         .getProperty(prefix + ".dataSource", Map.class, Collections.emptyMap())
                         .isEmpty()) {
             settings.setDataSource(new DataSourceSettingsBuilder(configuration, prefix, dsFallback).build());
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/proxy/GroovyProxyInterceptorLogic.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/proxy/GroovyProxyInterceptorLogic.java
index c972745ca5..2a7b9c9b89 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/proxy/GroovyProxyInterceptorLogic.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/proxy/GroovyProxyInterceptorLogic.java
@@ -24,6 +24,7 @@ import groovy.lang.GroovyObject;
 import groovy.lang.MetaClass;
 import org.codehaus.groovy.runtime.HandleMetaClass;
 import org.codehaus.groovy.runtime.InvokerHelper;
+
 import org.grails.datastore.gorm.proxy.ProxyInstanceMetaClass;
 
 /**
@@ -36,35 +37,34 @@ public class GroovyProxyInterceptorLogic {
 
     public static final Object INVOKE_IMPLEMENTATION = new Object();
 
-    public record InterceptorState(
-            String entityName,
-            Class<?> persistentClass,
-            Object identifier
-    ) {}
+    public record InterceptorState(String entityName, Class<?> persistentClass, Object identifier) {}
 
     public static Object handleUninitialized(InterceptorState state, String methodName, Object[] args) {
-        if ((methodName.equals("getMetaClass") || methodName.endsWith("getStaticMetaClass")) && (args == null || args.length == 0)) {
+        if (("getMetaClass".equals(methodName) || methodName.endsWith("getStaticMetaClass"))
+                && (args == null || args.length == 0)) {
             return InvokerHelper.getMetaClass(state.persistentClass());
         }
-        if (methodName.equals("getProperty") && args.length == 1 && args[0].equals("id")) {
+        if ("getProperty".equals(methodName) && args.length == 1 && "id".equals(args[0])) {
             return state.identifier();
         }
-        if (methodName.equals("ident") && (args == null || args.length == 0)) {
+        if ("ident".equals(methodName) && (args == null || args.length == 0)) {
             return state.identifier();
         }
-        if ((methodName.equals("isDirty") || methodName.equals("hasChanged")) && (args == null || args.length == 0)) {
+        if (("isDirty".equals(methodName) || "hasChanged".equals(methodName)) && (args == null || args.length == 0)) {
             return false;
         }
-        if (methodName.equals("toString") && (args == null || args.length == 0)) {
+        if ("toString".equals(methodName) && (args == null || args.length == 0)) {
             return state.entityName() + ":" + state.identifier();
         }
         return INVOKE_IMPLEMENTATION;
     }
 
     public static boolean isGroovyMethod(String methodName) {
-        return methodName.equals("getMetaClass") || methodName.equals("setMetaClass") ||
-               methodName.equals("getProperty") || methodName.equals("setProperty") ||
-               methodName.equals("invokeMethod");
+        return "getMetaClass".equals(methodName)
+                || "setMetaClass".equals(methodName)
+                || "getProperty".equals(methodName)
+                || "setProperty".equals(methodName)
+                || "invokeMethod".equals(methodName);
     }
 
     public static ProxyInstanceMetaClass getProxyInstanceMetaClass(Object o) {
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/HibernateAlias.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/HibernateAlias.java
index ece144f317..bd3fac0f6d 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/HibernateAlias.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/HibernateAlias.java
@@ -22,23 +22,9 @@ import org.grails.datastore.mapping.query.Query;
 
 /**
  * A internal criterion used to represent an alias for a basic collection join.
- * 
+ *
  * @author walterduquedeestrada
  */
-public class HibernateAlias implements Query.Criterion, Query.QueryElement {
-    private final String path;
-    private final String alias;
-
-    public HibernateAlias(String path, String alias) {
-        this.path = path;
-        this.alias = alias;
-    }
-
-    public String getPath() {
-        return path;
-    }
+public record HibernateAlias(String path, String alias) implements Query.Criterion, Query.QueryElement {
 
-    public String getAlias() {
-        return alias;
-    }
 }
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/HqlQueryContext.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/HqlQueryContext.java
index b1f6d72859..e50a5c35f7 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/HqlQueryContext.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/HqlQueryContext.java
@@ -49,7 +49,7 @@ public record HqlQueryContext(
         String hql,
         Class<?> targetClass,
         Map<String, Object> namedParams,
-        Collection positionalParams,
+        Collection<?> positionalParams,
         Map<String, Object> querySettings,
         boolean isUpdate,
         boolean isNative) {
@@ -65,13 +65,13 @@ public record HqlQueryContext(
             PersistentEntity entity,
             CharSequence queryCharseq,
             Map<?, ?> namedParams,
-            Collection positionalParams,
-            Map querySettings,
+            Collection<?> positionalParams,
+            Map<String, Object> querySettings,
             boolean isNative,
             boolean isUpdate) {
         Map<String, Object> _namedParams =
                 namedParams != null ? new HashMap<>((Map<String, Object>) namedParams) : new HashMap<>();
-        Collection positionalParamsCopy = positionalParams != null ? new ArrayList<>(positionalParams) : null;
+        Collection<Object> positionalParamsCopy = positionalParams != null ? new ArrayList<>(positionalParams) : null;
         Map<String, Object> querySettingsCopy = querySettings != null ? new HashMap<>(querySettings) : null;
 
         String hql;
@@ -93,18 +93,18 @@ public record HqlQueryContext(
 
     public static @Nullable String resolveHql(
             CharSequence queryCharseq, boolean isNative, Map<String, Object> namedParams) {
-        String raw = queryCharseq instanceof GString gstr ?
-                buildNamedParameterQueryFromGString(gstr, namedParams) :
-                queryCharseq != null ? queryCharseq.toString() : "";
+        String raw = queryCharseq instanceof GString gstr
+                ? buildNamedParameterQueryFromGString(gstr, namedParams)
+                : queryCharseq != null ? queryCharseq.toString() : "";
         String normalized = normalizeMultiLineQueryString(raw);
         return isNative ? normalized : normalizeNonAliasedSelect(normalized);
     }
 
     public static @Nullable String resolveHql(
-            CharSequence queryCharseq, boolean isNative, Collection positionalParams) {
-        String raw = queryCharseq instanceof GString gstr ?
-                buildPositionalParameterQueryFromGString(gstr, positionalParams, isNative) :
-                queryCharseq != null ? queryCharseq.toString() : "";
+            CharSequence queryCharseq, boolean isNative, Collection<Object> positionalParams) {
+        String raw = queryCharseq instanceof GString gstr
+                ? buildPositionalParameterQueryFromGString(gstr, positionalParams, isNative)
+                : queryCharseq != null ? queryCharseq.toString() : "";
         String normalized = normalizeMultiLineQueryString(raw);
         return isNative ? normalized : normalizeNonAliasedSelect(normalized);
     }
@@ -133,7 +133,7 @@ public record HqlQueryContext(
      * <p>Commas inside parentheses or string literals are ignored.
      */
     static int countHqlProjections(CharSequence hql) {
-        if (hql == null || hql.length() == 0) return 0;
+        if (hql == null || hql.isEmpty()) return 0;
         String s = hql.toString().trim();
         String lower = s.toLowerCase(Locale.ROOT);
         int selectIdx = lower.indexOf("select ");
@@ -152,6 +152,11 @@ public record HqlQueryContext(
             sel = sel.substring("all ".length()).trim();
 
         // Count top-level commas, ignoring those inside parens or string literals
+        int commas = getCommas(sel);
+        return commas == 0 ? 1 : 2;
+    }
+
+    private static int getCommas(String sel) {
         int depth = 0, commas = 0;
         boolean inSingle = false, inDouble = false;
         for (int i = 0; i < sel.length(); i++) {
@@ -170,7 +175,7 @@ public record HqlQueryContext(
                 else if (c == ',' && depth == 0) commas++;
             }
         }
-        return commas == 0 ? 1 : 2;
+        return commas;
     }
 
     // ─── HQL normalization ────────────────────────────────────────────────────
@@ -217,8 +222,8 @@ public record HqlQueryContext(
         int tokenEnd = cur;
         while (tokenEnd < s.length() && !Character.isWhitespace(s.charAt(tokenEnd))) tokenEnd++;
         String token = s.substring(cur, tokenEnd).toLowerCase(Locale.ROOT);
-        boolean hasAlias = !token.isEmpty() &&
-                !Set.of("where", "join", "left", "right", "inner", "outer", "group", "order", "having")
+        boolean hasAlias = !token.isEmpty()
+                && !Set.of("where", "join", "left", "right", "inner", "outer", "group", "order", "having")
                         .contains(token);
         if (hasAlias) return s;
 
@@ -269,7 +274,6 @@ public record HqlQueryContext(
         return query.trim().replace("\n", " ");
     }
 
-    @SuppressWarnings("unchecked")
     private static String buildNamedParameterQueryFromGString(GString query, Map<String, Object> params) {
         StringBuilder sql = new StringBuilder();
         Object[] values = query.getValues();
@@ -285,9 +289,8 @@ public record HqlQueryContext(
         return sql.toString();
     }
 
-    @SuppressWarnings("unchecked")
     private static String buildPositionalParameterQueryFromGString(
-            GString query, Collection positionalParams, boolean isNative) {
+            GString query, Collection<Object> positionalParams, boolean isNative) {
         StringBuilder sql = new StringBuilder();
         Object[] values = query.getValues();
         String[] strings = query.getStrings();
@@ -299,7 +302,8 @@ public record HqlQueryContext(
                 } else {
                     sql.append('?').append(positionalParams.size() + 1);
                 }
-                positionalParams.add(values[i]);
+                Object value = values[i];
+                positionalParams.add(value);
             }
         }
         return sql.toString();
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/JpaFromProvider.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/JpaFromProvider.java
index 3a23f6b1e8..7bc699eae9 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/JpaFromProvider.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/JpaFromProvider.java
@@ -95,7 +95,7 @@ public class JpaFromProvider implements Cloneable {
         // Also scan for HibernateAlias (basic collections)
         Map<String, String> basicAliasMap = new HashMap<>();
         for (HibernateAlias ha : aliases) {
-            basicAliasMap.put(ha.getPath(), ha.getAlias());
+            basicAliasMap.put(ha.path(), ha.alias());
         }
 
         var definedAliases = detachedAssociationCriteriaList.stream()
diff --git a/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/HibernateDatastoreSpec.groovy b/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/HibernateDatastoreSpec.groovy
index 6b320da48a..02b65e993a 100644
--- a/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/HibernateDatastoreSpec.groovy
+++ b/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/HibernateDatastoreSpec.groovy
@@ -18,22 +18,79 @@
  */
 package org.grails.orm.hibernate
 
+import grails.gorm.annotation.Entity
+import grails.gorm.specs.HibernateGormDatastoreSpec
 import org.grails.orm.hibernate.cfg.Settings
-import spock.lang.Specification
+import org.hibernate.FlushMode
+import org.springframework.context.support.GenericApplicationContext
 
-/**
- * Created by graemerocher on 22/09/2016.
- */
-class HibernateDatastoreSpec extends Specification {
+class HibernateDatastoreSpec extends HibernateGormDatastoreSpec {
+
+    void "test basic properties"() {
+        expect:
+        datastore.sessionFactory != null
+        datastore.dataSource != null
+        datastore.transactionManager != null
+        datastore.mappingContext != null
+        datastore.applicationEventPublisher != null
+        datastore.dataSourceName == 'default'
+    }
+
+    void "test configuration settings"() {
+        expect:
+        !datastore.autoFlush // COMMIT mode in setupSpec
+        datastore.defaultFlushMode == FlushMode.COMMIT
+        !datastore.failOnError
+        datastore.cacheQueries
+    }
+
+    void "test getDatastoreForConnection"() {
+        expect:
+        datastore.getDatastoreForConnection('dataSource') == datastore
+        datastore.getDatastoreForConnection('default') == datastore
+        datastore.getDatastoreForConnection('DEFAULT') == datastore
+    }
+
+    void "test withFlushMode"() {
+        when:
+        boolean result = false
+        datastore.withFlushMode(FlushMode.ALWAYS) {
+            result = datastore.sessionFactory.currentSession.hibernateFlushMode == FlushMode.ALWAYS
+            return true
+        }
 
-    void "test configure via map"() {
+        then:
+        result
+        datastore.sessionFactory.currentSession.hibernateFlushMode == FlushMode.COMMIT
+    }
+
+    void "test application context integration"() {
+        given:
+        def ctx = new GenericApplicationContext()
+        ctx.refresh()
+
+        when:
+        datastore.setApplicationContext(ctx)
+
+        then:
+        datastore.applicationContext == ctx
+    }
+
+    void "test configure via map (Legacy/Test constructor)"() {
         when:"The map constructor is used"
         def config = Collections.singletonMap(Settings.SETTING_DB_CREATE,  "create-drop")
-        HibernateDatastore datastore = new HibernateDatastore(config, Book)
+        HibernateDatastore testDatastore = new HibernateDatastore(config, GHUBook)
 
         then:"GORM is configured correctly"
-        Book.withNewSession {
-            Book.count()
-        } == 0
+        testDatastore.getMappingContext().getPersistentEntity(GHUBook.name) != null
+        
+        cleanup:
+        testDatastore.close()
     }
 }
+
+@Entity
+class GHUBook {
+    Long id
+    String title
+}
diff --git a/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/cfg/GrailsHibernatePersistentEntitySpec.groovy b/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/cfg/GrailsHibernatePersistentEntitySpec.groovy
index 3567ac20f8..7cd4236721 100644
--- a/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/cfg/GrailsHibernatePersistentEntitySpec.groovy
+++ b/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/cfg/GrailsHibernatePersistentEntitySpec.groovy
@@ -26,6 +26,7 @@ import org.grails.orm.hibernate.cfg.domainbinding.hibernate.GrailsHibernatePersi
 import org.grails.orm.hibernate.cfg.domainbinding.hibernate.HibernatePersistentProperty
 import org.grails.orm.hibernate.cfg.domainbinding.hibernate.HibernatePersistentEntity
 import org.grails.orm.hibernate.cfg.domainbinding.util.DefaultColumnNameFetcher
+import org.grails.datastore.mapping.core.connections.ConnectionSource
 
 class GrailsHibernatePersistentEntitySpec extends HibernateGormDatastoreSpec {
 
@@ -155,7 +156,7 @@ class GrailsHibernatePersistentEntitySpec extends HibernateGormDatastoreSpec {
         GrailsHibernatePersistentEntity vehicle = getPersistentEntity(Vehicle) as GrailsHibernatePersistentEntity
 
         when:
-        def children = vehicle.getChildEntities("DEFAULT")
+        def children = vehicle.getChildEntities(ConnectionSource.DEFAULT)
 
         then:
         children.size() == 2
diff --git a/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/cfg/HibernateMappingContextSpec.groovy b/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/cfg/HibernateMappingContextSpec.groovy
index a102789dd1..0dbd3bc783 100644
--- a/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/cfg/HibernateMappingContextSpec.groovy
+++ b/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/cfg/HibernateMappingContextSpec.groovy
@@ -30,6 +30,7 @@ import org.grails.orm.hibernate.cfg.domainbinding.hibernate.GrailsHibernatePersi
 import org.grails.orm.hibernate.cfg.domainbinding.hibernate.GrailsJpaMappingConfigurationStrategy
 import org.grails.orm.hibernate.connections.HibernateConnectionSourceSettings
 import org.springframework.validation.Errors
+import org.grails.datastore.mapping.core.connections.ConnectionSource
 
 class HibernateMappingContextSpec extends HibernateGormDatastoreSpec {
 
@@ -120,11 +121,11 @@ class HibernateMappingContextSpec extends HibernateGormDatastoreSpec {
 
     void "getHibernatePersistentEntities returns GrailsHibernatePersistentEntity instances"() {
         when:
-        def entities = mappingContext.getHibernatePersistentEntities("DEFAULT")
+        def entities = mappingContext.getHibernatePersistentEntities(ConnectionSource.DEFAULT)
 
         then:
         entities.every { it instanceof GrailsHibernatePersistentEntity }
-        entities.every { it.dataSourceName == "DEFAULT" }
+        entities.every { it.dataSourceName == ConnectionSource.DEFAULT }
     }
 
     void "getHibernatePersistentEntities sets the dataSourceName on each entity"() {
diff --git a/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/RootBinderSpec.groovy b/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/RootBinderSpec.groovy
index 10e34481b3..4ae93f37cb 100644
--- a/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/RootBinderSpec.groovy
+++ b/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/RootBinderSpec.groovy
@@ -27,6 +27,7 @@ import org.grails.orm.hibernate.cfg.domainbinding.hibernate.HibernatePersistentE
 import org.grails.orm.hibernate.cfg.domainbinding.util.MultiTenantFilterBinder
 import org.hibernate.boot.spi.MetadataBuildingContext
 import org.hibernate.mapping.RootClass
+import org.grails.datastore.mapping.core.connections.ConnectionSource
 
 class RootBinderSpec extends HibernateGormDatastoreSpec {
 
@@ -53,7 +54,7 @@ class RootBinderSpec extends HibernateGormDatastoreSpec {
         discriminatorPropertyBinder = Mock(DiscriminatorPropertyBinder)
 
         binder = new RootBinder(
-                "default",
+                ConnectionSource.DEFAULT,
                 multiTenantFilterBinder,
                 subClassBinder,
                 rootPersistentClassCommonValuesBinder,
@@ -67,7 +68,7 @@ class RootBinderSpec extends HibernateGormDatastoreSpec {
         given:
         def entity = Mock(HibernatePersistentEntity)
         entity.getName() >> "Parent"
-        entity.getChildEntities("default") >> []
+        entity.getChildEntities(ConnectionSource.DEFAULT) >> []
         entity.getMappedForm() >> new Mapping()
         
         def mappings = sharedCollector
@@ -91,7 +92,7 @@ class RootBinderSpec extends HibernateGormDatastoreSpec {
         def entity = Mock(HibernatePersistentEntity)
         def childEntity = Mock(HibernatePersistentEntity)
         entity.getName() >> "Parent"
-        entity.getChildEntities("default") >> [childEntity]
+        entity.getChildEntities(ConnectionSource.DEFAULT) >> [childEntity]
         def mapping = new Mapping()
         mapping.setTablePerHierarchy(true)
         entity.getMappedForm() >> mapping
diff --git a/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/SubClassBinderSpec.groovy b/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/SubClassBinderSpec.groovy
index 3e0e0c69e6..30d3aacec2 100644
--- a/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/SubClassBinderSpec.groovy
+++ b/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/SubClassBinderSpec.groovy
@@ -22,12 +22,12 @@ package org.grails.orm.hibernate.cfg.domainbinding.binder
 import org.hibernate.mapping.SingleTableSubclass
 
 import grails.gorm.specs.HibernateGormDatastoreSpec
-import org.grails.orm.hibernate.cfg.Mapping
 import org.grails.orm.hibernate.cfg.MappingCacheHolder
 import org.grails.orm.hibernate.cfg.domainbinding.hibernate.HibernatePersistentEntity
 import org.grails.orm.hibernate.cfg.domainbinding.util.MultiTenantFilterBinder
 import org.hibernate.boot.spi.MetadataBuildingContext
 import org.hibernate.mapping.RootClass
+import org.grails.datastore.mapping.core.connections.ConnectionSource
 
 class SubClassBinderSpec extends HibernateGormDatastoreSpec {
 
@@ -48,7 +48,7 @@ class SubClassBinderSpec extends HibernateGormDatastoreSpec {
         binder = new SubClassBinder(
                 subclassMappingBinder,
                 multiTenantFilterBinder,
-                "default"
+                ConnectionSource.DEFAULT,
         )
     }
 
@@ -56,7 +56,7 @@ class SubClassBinderSpec extends HibernateGormDatastoreSpec {
         given:
         def subEntity = Mock(HibernatePersistentEntity)
         subEntity.getName() >> "Child"
-        subEntity.getChildEntities("default") >> []
+        subEntity.getChildEntities(ConnectionSource.DEFAULT) >> []
         def rootClass = new RootClass(metadataBuildingContext)
         rootClass.setEntityName("Parent")
         rootClass.setJpaEntityName("Parent")
@@ -79,8 +79,8 @@ class SubClassBinderSpec extends HibernateGormDatastoreSpec {
         def grandChildEntity = Mock(HibernatePersistentEntity)
         subEntity.getName() >> "Child"
         grandChildEntity.getName() >> "GrandChild"
-        subEntity.getChildEntities("default") >> [grandChildEntity]
-        grandChildEntity.getChildEntities("default") >> []
+        subEntity.getChildEntities(ConnectionSource.DEFAULT) >> [grandChildEntity]
+        grandChildEntity.getChildEntities(ConnectionSource.DEFAULT) >> []
 
         def rootClass = new RootClass(metadataBuildingContext)
         rootClass.setEntityName("Parent")
diff --git a/grails-datastore-core/src/main/groovy/org/grails/datastore/mapping/core/connections/ConnectionSource.java b/grails-datastore-core/src/main/groovy/org/grails/datastore/mapping/core/connections/ConnectionSource.java
index 8e1614f6cd..ac42ac79aa 100644
--- a/grails-datastore-core/src/main/groovy/org/grails/datastore/mapping/core/connections/ConnectionSource.java
+++ b/grails-datastore-core/src/main/groovy/org/grails/datastore/mapping/core/connections/ConnectionSource.java
@@ -31,7 +31,14 @@ public interface ConnectionSource<T, S extends ConnectionSourceSettings> extends
     /**
      * The name of the default connection source
      */
-    String DEFAULT = "DEFAULT";
+    String DEFAULT = "default";
+
+    /**
+     * The name of the default connection source used in previous versions of GORM
+     * @deprecated Use {@link #DEFAULT} instead
+     */
+    @Deprecated
+    String OLD_DEFAULT = "DEFAULT";
 
     /**
      * Constance for a mapping to all connection sources
diff --git a/grails-datastore-core/src/main/groovy/org/grails/datastore/mapping/model/MappingContext.java b/grails-datastore-core/src/main/groovy/org/grails/datastore/mapping/model/MappingContext.java
index d65f463061..9300985ec7 100644
--- a/grails-datastore-core/src/main/groovy/org/grails/datastore/mapping/model/MappingContext.java
+++ b/grails-datastore-core/src/main/groovy/org/grails/datastore/mapping/model/MappingContext.java
@@ -236,7 +236,7 @@ public interface MappingContext {
      */
     void addMappingContextListener(Listener listener);
 
-    PersistentEntity createEmbeddedEntity(Class type);
+    PersistentEntity createEmbeddedEntity(Class<?> type);
 
     /**
      * Obtains a {@link EntityReflector} instance for the given entity


(grails-core) 05/08: hibernate 7: added more validations for GrailsHibernateUtil

Posted by bo...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

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

commit 31e1f796708494efacae79b2c2180e9d9be9790f
Author: Walter Duque de Estrada <wb...@mac.com>
AuthorDate: Sun Mar 22 13:34:51 2026 -0500

    hibernate 7: added more validations for GrailsHibernateUtil
---
 .../orm/hibernate/cfg/GrailsHibernateUtil.java     | 43 +++++-----
 .../hibernate/cfg/GrailsHibernateUtilSpec.groovy   | 91 ++++++++++++++++++----
 2 files changed, 103 insertions(+), 31 deletions(-)

diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/GrailsHibernateUtil.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/GrailsHibernateUtil.java
index b0643aa3d0..d875267ba2 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/GrailsHibernateUtil.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/GrailsHibernateUtil.java
@@ -57,50 +57,56 @@ import org.grails.orm.hibernate.support.HibernateRuntimeUtils;
 public class GrailsHibernateUtil extends HibernateRuntimeUtils {
     protected static final Logger LOG = LoggerFactory.getLogger(GrailsHibernateUtil.class);
 
+    private static final String VERSION_8_0 = "8.0";
+
     /** @deprecated Use {@link org.grails.orm.hibernate.query.HibernateQueryArgument#FETCH_SIZE} */
-    @Deprecated(since = "8.0", forRemoval = true)
+    @Deprecated(since = VERSION_8_0, forRemoval = true)
     public static final String ARGUMENT_FETCH_SIZE = HibernateQueryArgument.FETCH_SIZE.value();
     /** @deprecated Use {@link org.grails.orm.hibernate.query.HibernateQueryArgument#TIMEOUT} */
-    @Deprecated(since = "8.0", forRemoval = true)
+    @Deprecated(since = VERSION_8_0, forRemoval = true)
     public static final String ARGUMENT_TIMEOUT = HibernateQueryArgument.TIMEOUT.value();
     /** @deprecated Use {@link org.grails.orm.hibernate.query.HibernateQueryArgument#READ_ONLY} */
-    @Deprecated(since = "8.0", forRemoval = true)
+    @Deprecated(since = VERSION_8_0, forRemoval = true)
     public static final String ARGUMENT_READ_ONLY = HibernateQueryArgument.READ_ONLY.value();
     /** @deprecated Use {@link org.grails.orm.hibernate.query.HibernateQueryArgument#FLUSH_MODE} */
-    @Deprecated(since = "8.0", forRemoval = true)
+    @Deprecated(since = VERSION_8_0, forRemoval = true)
     public static final String ARGUMENT_FLUSH_MODE = HibernateQueryArgument.FLUSH_MODE.value();
     /** @deprecated Use {@link org.grails.orm.hibernate.query.HibernateQueryArgument#MAX} */
-    @Deprecated(since = "8.0", forRemoval = true)
+    @Deprecated(since = VERSION_8_0, forRemoval = true)
     public static final String ARGUMENT_MAX = HibernateQueryArgument.MAX.value();
     /** @deprecated Use {@link org.grails.orm.hibernate.query.HibernateQueryArgument#OFFSET} */
-    @Deprecated(since = "8.0", forRemoval = true)
+    @Deprecated(since = VERSION_8_0, forRemoval = true)
     public static final String ARGUMENT_OFFSET = HibernateQueryArgument.OFFSET.value();
     /** @deprecated Use {@link org.grails.orm.hibernate.query.HibernateQueryArgument#ORDER} */
-    @Deprecated(since = "8.0", forRemoval = true)
+    @Deprecated(since = VERSION_8_0, forRemoval = true)
     public static final String ARGUMENT_ORDER = HibernateQueryArgument.ORDER.value();
     /** @deprecated Use {@link org.grails.orm.hibernate.query.HibernateQueryArgument#SORT} */
-    @Deprecated(since = "8.0", forRemoval = true)
+    @Deprecated(since = VERSION_8_0, forRemoval = true)
     public static final String ARGUMENT_SORT = HibernateQueryArgument.SORT.value();
     /** @deprecated Use {@link org.grails.orm.hibernate.query.HibernateQueryArgument#ORDER_DESC} */
-    @Deprecated(since = "8.0", forRemoval = true)
+    @Deprecated(since = VERSION_8_0, forRemoval = true)
     public static final String ORDER_DESC = HibernateQueryArgument.ORDER_DESC.value();
     /** @deprecated Use {@link org.grails.orm.hibernate.query.HibernateQueryArgument#ORDER_ASC} */
-    @Deprecated(since = "8.0", forRemoval = true)
+    @Deprecated(since = VERSION_8_0, forRemoval = true)
     public static final String ORDER_ASC = HibernateQueryArgument.ORDER_ASC.value();
     /** @deprecated Use {@link org.grails.orm.hibernate.query.HibernateQueryArgument#FETCH} */
-    @Deprecated(since = "8.0", forRemoval = true)
+    @Deprecated(since = VERSION_8_0, forRemoval = true)
     public static final String ARGUMENT_FETCH = HibernateQueryArgument.FETCH.value();
     /** @deprecated Use {@link org.grails.orm.hibernate.query.HibernateQueryArgument#IGNORE_CASE} */
-    @Deprecated(since = "8.0", forRemoval = true)
+    @Deprecated(since = VERSION_8_0, forRemoval = true)
     public static final String ARGUMENT_IGNORE_CASE = HibernateQueryArgument.IGNORE_CASE.value();
     /** @deprecated Use {@link org.grails.orm.hibernate.query.HibernateQueryArgument#CACHE} */
-    @Deprecated(since = "8.0", forRemoval = true)
+    @Deprecated(since = VERSION_8_0, forRemoval = true)
     public static final String ARGUMENT_CACHE = HibernateQueryArgument.CACHE.value();
     /** @deprecated Use {@link org.grails.orm.hibernate.query.HibernateQueryArgument#LOCK} */
-    @Deprecated(since = "8.0", forRemoval = true)
+    @Deprecated(since = VERSION_8_0, forRemoval = true)
     public static final String ARGUMENT_LOCK = HibernateQueryArgument.LOCK.value();
 
-    private static final HibernateProxyHandler proxyHandler = new HibernateProxyHandler();
+    private static HibernateProxyHandler proxyHandler = new HibernateProxyHandler();
+
+    public static void setProxyHandler(HibernateProxyHandler handler) {
+        proxyHandler = handler;
+    }
 
     /**
      * Sets the target object to read-only using the given SessionFactory instance. This avoids
@@ -116,12 +122,13 @@ public class GrailsHibernateUtil extends HibernateRuntimeUtils {
         if (resource != null) {
             Session session = sessionFactory.getCurrentSession();
             if (canModifyReadWriteState(session, target)) {
-                if (target instanceof HibernateProxy) {
-                    target = ((HibernateProxy) target)
+                Object targetToUse = target;
+                if (targetToUse instanceof HibernateProxy) {
+                    targetToUse = ((HibernateProxy) targetToUse)
                             .getHibernateLazyInitializer()
                             .getImplementation();
                 }
-                session.setReadOnly(target, true);
+                session.setReadOnly(targetToUse, true);
                 session.setHibernateFlushMode(FlushMode.MANUAL);
             }
         }
diff --git a/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/cfg/GrailsHibernateUtilSpec.groovy b/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/cfg/GrailsHibernateUtilSpec.groovy
index a3e9c390b4..8e319dadf7 100644
--- a/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/cfg/GrailsHibernateUtilSpec.groovy
+++ b/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/cfg/GrailsHibernateUtilSpec.groovy
@@ -20,13 +20,24 @@ package org.grails.orm.hibernate.cfg
 
 import grails.gorm.annotation.Entity
 import grails.gorm.specs.HibernateGormDatastoreSpec
-import org.grails.datastore.mapping.model.config.GormProperties
+import org.grails.orm.hibernate.proxy.HibernateProxyHandler
 import org.hibernate.proxy.HibernateProxy
-import org.hibernate.proxy.LazyInitializer
+import spock.lang.Shared
 import spock.lang.Unroll
 
 class GrailsHibernateUtilSpec extends HibernateGormDatastoreSpec {
 
+    @Shared HibernateProxyHandler originalProxyHandler = GrailsHibernateUtil.proxyHandler
+    HibernateProxyHandler proxyHandlerMock = Mock(HibernateProxyHandler)
+
+    def setup() {
+        GrailsHibernateUtil.setProxyHandler(proxyHandlerMock)
+    }
+
+    def cleanup() {
+        GrailsHibernateUtil.setProxyHandler(originalProxyHandler)
+    }
+
     @Unroll
     def "test isDomainClass for #clazz.simpleName"() {
         expect:
@@ -75,25 +86,72 @@ class GrailsHibernateUtilSpec extends HibernateGormDatastoreSpec {
         !GrailsHibernateUtil.isNotEmpty(null)
     }
 
-    def "test unwrapIfProxy with non-proxy"() {
+    def "test unwrapIfProxy"() {
         given:
         def obj = new Object()
+        def unwrapped = new Object()
 
-        expect:
-        GrailsHibernateUtil.unwrapIfProxy(obj).is(obj)
-        GrailsHibernateUtil.unwrapIfProxy(null) == null
+        when:
+        def result = GrailsHibernateUtil.unwrapIfProxy(obj)
+
+        then:
+        1 * proxyHandlerMock.unwrap(obj) >> unwrapped
+        result == unwrapped
+    }
+
+    def "test unwrapProxy"() {
+        given:
+        def proxy = Mock(HibernateProxy)
+        def unwrapped = new Object()
+
+        when:
+        def result = GrailsHibernateUtil.unwrapProxy(proxy)
+
+        then:
+        1 * proxyHandlerMock.unwrap(proxy) >> unwrapped
+        result == unwrapped
+    }
+
+    def "test getAssociationProxy and isInitialized"() {
+        given:
+        def book = new GHUBook(title: "Carrie")
+        def proxy = Mock(HibernateProxy)
+
+        when:
+        def result = GrailsHibernateUtil.getAssociationProxy(book, "title")
+        def initialized = GrailsHibernateUtil.isInitialized(book, "title")
+
+        then:
+        1 * proxyHandlerMock.getAssociationProxy(book, "title") >> proxy
+        1 * proxyHandlerMock.isInitialized(book, "title") >> true
+        result == proxy
+        initialized
     }
 
-    def "test unwrapIfProxy with EntityProxy"() {
+    def "test isMappedWithHibernate"() {
         given:
-        def implementation = new Object()
-        def proxy = [
-            getTarget: { implementation },
-            isInitialized: { true }
-        ] as org.grails.datastore.mapping.proxy.EntityProxy
+        def hibernateEntity = Mock(org.grails.orm.hibernate.cfg.domainbinding.hibernate.GrailsHibernatePersistentEntity)
+        def otherEntity = Mock(org.grails.datastore.mapping.model.PersistentEntity)
 
         expect:
-        GrailsHibernateUtil.unwrapIfProxy(proxy).is(implementation)
+        GrailsHibernateUtil.isMappedWithHibernate(hibernateEntity)
+        !GrailsHibernateUtil.isMappedWithHibernate(otherEntity)
+    }
+
+    def "test ensureCorrectGroovyMetaClass"() {
+        given:
+        def book = new GHUBook()
+        def originalMc = book.getMetaClass()
+        def newMc = GroovySystem.getMetaClassRegistry().getMetaClass(GHUNonDomain)
+
+        when:
+        GrailsHibernateUtil.ensureCorrectGroovyMetaClass(book, GHUNonDomain)
+
+        then:
+        book.getMetaClass().getTheClass() == GHUNonDomain
+
+        cleanup:
+        book.setMetaClass(originalMc)
     }
 }
 
@@ -104,6 +162,13 @@ class GHUBook {
     String title
 }
 
+@Entity
+class GHUAuthor {
+    Long id
+    String name
+    static hasMany = [books: GHUBook]
+}
+
 class GHUNonDomain {
     String name
 }


(grails-core) 08/08: hibernate 7: * Fix HQL Queries

Posted by bo...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

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

commit 9620b0b50101011fed4ba1f70712cee40892d5b0
Author: Walter Duque de Estrada <wb...@mac.com>
AuthorDate: Sun Mar 22 20:52:51 2026 -0500

    hibernate 7:
      * Fix HQL Queries
---
 .../orm/hibernate/query/HibernateHqlQuery.java     |  52 +++---
 .../hibernate/query/HibernateQueryArgument.java    |  19 +++
 .../orm/hibernate/query/HqlListQueryBuilder.java   |  26 +--
 .../orm/hibernate/query/HqlQueryContext.java       | 105 +++++++-----
 .../hibernate/query/HqlListQueryBuilderSpec.groovy | 177 +++++++++++++++++++++
 .../orm/hibernate/query/HqlQueryContextSpec.groovy |  20 ++-
 6 files changed, 321 insertions(+), 78 deletions(-)

diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/HibernateHqlQuery.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/HibernateHqlQuery.java
index ce121fb447..3683801770 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/HibernateHqlQuery.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/HibernateHqlQuery.java
@@ -101,6 +101,7 @@ public class HibernateHqlQuery extends Query {
     /**
      * Session-bound step — creates the appropriate Hibernate query from an open {@link
      * org.hibernate.Session} and wraps it in a {@link HibernateHqlQuery}.
+     * Note: The HqlQueryContext has a sanitized sql string
      */
     protected static HibernateHqlQuery buildQuery(
             org.hibernate.Session session,
@@ -109,31 +110,26 @@ public class HibernateHqlQuery extends Query {
             PersistentEntity entity,
             HqlQueryContext ctx) {
         HibernateSession hibernateSession = new HibernateSession(dataStore, sessionFactory);
-        if (StringUtils.isEmpty(ctx.hql())) {
+        String hql = ctx.hql();
+        if (StringUtils.isEmpty(hql)) {
             var q = session.createQuery("from " + ctx.targetClass().getName(), ctx.targetClass());
             return new HibernateHqlQuery(hibernateSession, entity, q);
         } else if (ctx.isUpdate()) {
-            var mq = session.createMutationQuery(ctx.hql());
+            var mq = session.createMutationQuery(hql);
             var result = new HibernateHqlQuery(hibernateSession, entity, mq);
             result.setFlushMode(session.getHibernateFlushMode());
             return result;
         } else {
-            var q = ctx.isNative() ?
-                    session.createNativeQuery(ctx.hql(), ctx.targetClass()) :
-                    isScalarSelect(ctx.hql()) ?
-                            session.createQuery(ctx.hql()) :
-                            session.createQuery(ctx.hql(), ctx.targetClass());
+            var q = ctx.isNative()
+                    ? session.createNativeQuery(hql, ctx.targetClass())
+                    : session.createQuery(hql, ctx.targetClass());
             var result = new HibernateHqlQuery(hibernateSession, entity, q);
             result.setFlushMode(session.getHibernateFlushMode());
             return result;
         }
     }
 
-    /** Returns true if the HQL starts with a {@code select} clause that doesn't project the entity. */
-    private static boolean isScalarSelect(String hql) {
-        String trimmed = hql.stripLeading().toLowerCase();
-        return trimmed.startsWith("select") && !trimmed.startsWith("select e ") && !trimmed.startsWith("select e,");
-    }
+
 
     /**
      * Full factory — opens a session via the {@link GrailsHibernateTemplate}, builds the query from
@@ -184,9 +180,9 @@ public class HibernateHqlQuery extends Query {
 
     protected void setFlushMode(FlushMode flushMode) {
         session.setFlushMode(
-                flushMode == FlushMode.AUTO || flushMode == FlushMode.ALWAYS ?
-                        FlushModeType.AUTO :
-                        FlushModeType.COMMIT);
+                flushMode == FlushMode.AUTO || flushMode == FlushMode.ALWAYS
+                        ? FlushModeType.AUTO
+                        : FlushModeType.COMMIT);
     }
 
     protected void populateQuerySettings(Map<?, ?> args, ConversionService conversionService) {
@@ -209,7 +205,8 @@ public class HibernateHqlQuery extends Query {
             delegate.setCacheable(false);
         } else {
             if (!args.containsKey(HibernateQueryArgument.CACHE.value())) {
-                org.grails.orm.hibernate.cfg.Mapping m = ((org.grails.orm.hibernate.cfg.HibernateMappingContext) getEntity().getMappingContext())
+                org.grails.orm.hibernate.cfg.Mapping m = ((org.grails.orm.hibernate.cfg.HibernateMappingContext)
+                                getEntity().getMappingContext())
                         .getMappingCacheHolder()
                         .getMapping(getEntity().getJavaClass());
                 if (m != null && m.getCache() != null && m.getCache().getEnabled()) {
@@ -246,14 +243,14 @@ public class HibernateHqlQuery extends Query {
                 throw new GrailsQueryException("Named parameter's name must be a String: " + namedArgs);
             }
             String name = key.toString();
-            if (HibernateQueryArgument.MAX.value().equals(name) ||
-                HibernateQueryArgument.OFFSET.value().equals(name) ||
-                HibernateQueryArgument.CACHE.value().equals(name) ||
-                HibernateQueryArgument.FETCH_SIZE.value().equals(name) ||
-                HibernateQueryArgument.TIMEOUT.value().equals(name) ||
-                HibernateQueryArgument.READ_ONLY.value().equals(name) ||
-                HibernateQueryArgument.FLUSH_MODE.value().equals(name) ||
-                HibernateQueryArgument.LOCK.value().equals(name)) {
+            if (HibernateQueryArgument.MAX.value().equals(name)
+                    || HibernateQueryArgument.OFFSET.value().equals(name)
+                    || HibernateQueryArgument.CACHE.value().equals(name)
+                    || HibernateQueryArgument.FETCH_SIZE.value().equals(name)
+                    || HibernateQueryArgument.TIMEOUT.value().equals(name)
+                    || HibernateQueryArgument.READ_ONLY.value().equals(name)
+                    || HibernateQueryArgument.FLUSH_MODE.value().equals(name)
+                    || HibernateQueryArgument.LOCK.value().equals(name)) {
                 return;
             }
             if (value == null) {
@@ -302,8 +299,11 @@ public class HibernateHqlQuery extends Query {
     // ─── Private utilities ────────────────────────────────────────────────────
 
     private static int toInt(Object v, ConversionService cs) {
-        if (v instanceof Integer i) return i;
-        return cs.convert(v, Integer.class);
+        if (v instanceof Integer i) {
+            return i;
+        }
+        Integer i = cs.convert(v, Integer.class);
+        return i != null ? i : 0;
     }
 
     private static boolean toBool(Object v) {
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/HibernateQueryArgument.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/HibernateQueryArgument.java
index 1e22059ea2..eab49d4ba2 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/HibernateQueryArgument.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/HibernateQueryArgument.java
@@ -52,6 +52,25 @@ public enum HibernateQueryArgument {
     IGNORE_CASE(DynamicFinder.ARGUMENT_IGNORE_CASE),
     ORDER_DESC(DynamicFinder.ORDER_DESC),
     ORDER_ASC(DynamicFinder.ORDER_ASC),
+    EAGER("eager"),
+    JOIN("join"),
+
+    // ── HQL keywords ──────────────────────────────────────────────────────────
+    HQL_SELECT("select"),
+    HQL_FROM("from"),
+    HQL_WHERE("where"),
+    HQL_JOIN("join"),
+    HQL_LEFT("left"),
+    HQL_RIGHT("right"),
+    HQL_INNER("inner"),
+    HQL_OUTER("outer"),
+    HQL_GROUP("group"),
+    HQL_ORDER("order"),
+    HQL_HAVING("having"),
+    HQL_DISTINCT("distinct"),
+    HQL_ALL("all"),
+    HQL_AS("as"),
+    HQL_NEW("new"),
 
     // ── Hibernate config properties ───────────────────────────────────────────
     CONFIG_CACHE_QUERIES("grails.hibernate.cache.queries"),
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/HqlListQueryBuilder.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/HqlListQueryBuilder.java
index 8bd46c7a3c..cf0b133926 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/HqlListQueryBuilder.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/HqlListQueryBuilder.java
@@ -22,7 +22,6 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 
-import org.grails.datastore.gorm.finders.DynamicFinder;
 import org.grails.datastore.mapping.model.PersistentEntity;
 import org.grails.datastore.mapping.model.PersistentProperty;
 import org.grails.datastore.mapping.model.types.Association;
@@ -81,7 +80,8 @@ public class HqlListQueryBuilder {
     private static boolean isJoinFetch(Object mode) {
         if (mode == null) return false;
         String s = mode.toString();
-        return s.equalsIgnoreCase("join") || s.equalsIgnoreCase("eager");
+        return s.equalsIgnoreCase(HibernateQueryArgument.JOIN.value())
+                || s.equalsIgnoreCase(HibernateQueryArgument.EAGER.value());
     }
 
     // ─── ORDER BY ────────────────────────────────────────────────────────────
@@ -102,13 +102,13 @@ public class HqlListQueryBuilder {
             clauses.add(orderClause(alias, sort, dir, ignoreCase && isStringProp(sort)));
         } else {
             // fall back to default mapping sort
-            MappingCacheHolder cacheHolder = ((HibernateMappingContext) entity.getMappingContext()).getMappingCacheHolder();
-            Mapping m = cacheHolder.getMapping(entity.getJavaClass());
-            if (m != null) {
-                m.getSort()
-                        .getNamesAndDirections()
-                        .forEach((prop, dir) -> clauses.add(orderClause(
-                                alias, (String) prop, direction((String) dir), isStringProp((String) prop))));
+            if (entity.getMappingContext() instanceof HibernateMappingContext hmc) {
+                Mapping m = hmc.getMappingCacheHolder().getMapping(entity.getJavaClass());
+                if (m != null) {
+                    ((Map<?, ?>) m.getSort().getNamesAndDirections())
+                            .forEach((prop, dir) -> clauses.add(orderClause(
+                                    alias, (String) prop, direction((String) dir), isStringProp((String) prop))));
+                }
             }
         }
 
@@ -123,9 +123,9 @@ public class HqlListQueryBuilder {
     }
 
     private static String direction(String raw) {
-        return HibernateQueryArgument.ORDER_DESC.value().equalsIgnoreCase(raw) ?
-                HibernateQueryArgument.ORDER_DESC.value() :
-                HibernateQueryArgument.ORDER_ASC.value();
+        return HibernateQueryArgument.ORDER_DESC.value().equalsIgnoreCase(raw)
+                ? HibernateQueryArgument.ORDER_DESC.value()
+                : HibernateQueryArgument.ORDER_ASC.value();
     }
 
     private boolean isIgnoreCase() {
@@ -155,6 +155,6 @@ public class HqlListQueryBuilder {
     /** Returns true when the params indicate a paged query (i.e. {@code max} is set). */
     @SuppressWarnings("rawtypes")
     static boolean isPaged(Map params) {
-        return params.containsKey(DynamicFinder.ARGUMENT_MAX);
+        return params.containsKey(HibernateQueryArgument.MAX.value());
     }
 }
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/HqlQueryContext.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/HqlQueryContext.java
index e50a5c35f7..5fbf29c98f 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/HqlQueryContext.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/query/HqlQueryContext.java
@@ -27,6 +27,7 @@ import java.util.Set;
 
 import groovy.lang.GString;
 
+import org.checkerframework.checker.nullness.qual.NonNull;
 import org.checkerframework.checker.nullness.qual.Nullable;
 
 import org.grails.datastore.mapping.model.PersistentEntity;
@@ -37,6 +38,10 @@ import org.grails.datastore.mapping.model.PersistentEntity;
  * (including those expanded from a {@link GString}), and flags for whether the query is an update
  * or native SQL.
  *
+ * <p><strong>Security Note:</strong> The {@code hql} string must be trust-verified or
+ * properly parameterized (e.g. via {@link GString} expansion in {@link #prepare}) before
+ * being passed to execution engines to prevent injection vulnerabilities.
+ *
  * <p>Use {@link #prepare} to build an instance from raw inputs.
  */
 @SuppressWarnings({
@@ -120,11 +125,38 @@ public record HqlQueryContext(
         String normalized = normalizeNonAliasedSelect(hql == null ? null : hql.toString());
         return switch (countHqlProjections(normalized)) {
             case 0 -> clazz;
-            case 1 -> isPropertyProjection(normalized) ? Object.class : clazz;
+            case 1 -> isAggregateProjection(normalized) ? Long.class : (isPropertyProjection(normalized) ? Object.class : clazz);
             default -> Object[].class;
         };
     }
 
+    private static boolean isAggregateProjection(CharSequence hql) {
+        String clause = getSingleProjectionClause(hql);
+        if (clause == null) return false;
+
+        return clause.startsWith("count(") || clause.startsWith("sum(") || clause.startsWith("avg(") || clause.startsWith("min(") || clause.startsWith("max(");
+    }
+
+    private static @Nullable String getSingleProjectionClause(CharSequence hql) {
+        if (hql == null) return null;
+        String s = hql.toString().toLowerCase(Locale.ROOT).trim();
+        int selectIdx = s.indexOf(HibernateQueryArgument.HQL_SELECT.value() + " ");
+        if (selectIdx < 0) return null;
+        int fromIdx = s.indexOf(" " + HibernateQueryArgument.HQL_FROM.value() + " ", selectIdx);
+        return extractSelectClause(s, selectIdx, fromIdx);
+    }
+
+    private static @NonNull String extractSelectClause(String s, int selectIdx, int fromIdx) {
+        String clause = s.substring(selectIdx + HibernateQueryArgument.HQL_SELECT.value().length(), fromIdx < 0 ? s.length() : fromIdx)
+                .trim();
+        if (clause.startsWith(HibernateQueryArgument.HQL_DISTINCT.value() + " ")) {
+            clause = clause.substring(HibernateQueryArgument.HQL_DISTINCT.value().length() + 1).trim();
+        } else if (clause.startsWith(HibernateQueryArgument.HQL_ALL.value() + " ")) {
+            clause = clause.substring(HibernateQueryArgument.HQL_ALL.value().length() + 1).trim();
+        }
+        return clause;
+    }
+
     /**
      * Returns the number of top-level projections in the SELECT clause: 0 if no explicit SELECT, 1
      * for a single projection (including DISTINCT x or NEW map(…)), 2 for two or more comma-separated
@@ -136,20 +168,20 @@ public record HqlQueryContext(
         if (hql == null || hql.isEmpty()) return 0;
         String s = hql.toString().trim();
         String lower = s.toLowerCase(Locale.ROOT);
-        int selectIdx = lower.indexOf("select ");
+        int selectIdx = lower.indexOf(HibernateQueryArgument.HQL_SELECT.value() + " ");
         if (selectIdx < 0) return 0;
 
-        int fromIdx = lower.indexOf(" from ", selectIdx);
-        String sel = s.substring(selectIdx + "select".length(), fromIdx < 0 ? s.length() : fromIdx)
+        int fromIdx = lower.indexOf(" " + HibernateQueryArgument.HQL_FROM.value() + " ", selectIdx);
+        String sel = s.substring(selectIdx + HibernateQueryArgument.HQL_SELECT.value().length(), fromIdx < 0 ? s.length() : fromIdx)
                 .trim();
         if (sel.isEmpty()) return 0;
 
         // Strip leading DISTINCT/ALL
         String selLower = sel.toLowerCase(Locale.ROOT);
-        if (selLower.startsWith("distinct "))
-            sel = sel.substring("distinct ".length()).trim();
-        else if (selLower.startsWith("all "))
-            sel = sel.substring("all ".length()).trim();
+        if (selLower.startsWith(HibernateQueryArgument.HQL_DISTINCT.value() + " "))
+            sel = sel.substring(HibernateQueryArgument.HQL_DISTINCT.value().length() + 1).trim();
+        else if (selLower.startsWith(HibernateQueryArgument.HQL_ALL.value() + " "))
+            sel = sel.substring(HibernateQueryArgument.HQL_ALL.value().length() + 1).trim();
 
         // Count top-level commas, ignoring those inside parens or string literals
         int commas = getCommas(sel);
@@ -193,18 +225,18 @@ public record HqlQueryContext(
         if (s.isEmpty()) return s;
 
         String lower = s.toLowerCase();
-        int selectIdx = lower.indexOf("select ");
+        int selectIdx = lower.indexOf(HibernateQueryArgument.HQL_SELECT.value() + " ");
         if (selectIdx < 0) return s; // no SELECT clause — nothing to normalize
 
-        int fromIdx = lower.indexOf(" from ", selectIdx);
+        int fromIdx = lower.indexOf(" " + HibernateQueryArgument.HQL_FROM.value() + " ", selectIdx);
         if (fromIdx < 0) return s; // malformed — leave as-is
 
-        int selectStart = selectIdx + "select ".length();
+        int selectStart = selectIdx + HibernateQueryArgument.HQL_SELECT.value().length() + 1;
         String selectClauseOrig = s.substring(selectStart, fromIdx).trim();
         String selectClauseLower = lower.substring(selectStart, fromIdx).trim();
 
         // Parse entity name from the FROM head
-        int afterFrom = fromIdx + " from ".length();
+        int afterFrom = fromIdx + HibernateQueryArgument.HQL_FROM.value().length() + 2;
         int entityEnd = afterFrom;
         while (entityEnd < s.length() && !Character.isWhitespace(s.charAt(entityEnd))) entityEnd++;
         String entityName = s.substring(afterFrom, entityEnd);
@@ -213,8 +245,8 @@ public record HqlQueryContext(
         // Skip whitespace, then optional "as" keyword
         int cur = entityEnd;
         while (cur < s.length() && Character.isWhitespace(s.charAt(cur))) cur++;
-        if (cur + 2 <= s.length() && s.substring(cur, cur + 2).equalsIgnoreCase("as")) {
-            cur += 2;
+        if (cur + 2 <= s.length() && s.substring(cur, cur + 2).equalsIgnoreCase(HibernateQueryArgument.HQL_AS.value())) {
+            cur += HibernateQueryArgument.HQL_AS.value().length();
             while (cur < s.length() && Character.isWhitespace(s.charAt(cur))) cur++;
         }
 
@@ -223,50 +255,49 @@ public record HqlQueryContext(
         while (tokenEnd < s.length() && !Character.isWhitespace(s.charAt(tokenEnd))) tokenEnd++;
         String token = s.substring(cur, tokenEnd).toLowerCase(Locale.ROOT);
         boolean hasAlias = !token.isEmpty()
-                && !Set.of("where", "join", "left", "right", "inner", "outer", "group", "order", "having")
+                && !Set.of(
+                        HibernateQueryArgument.HQL_WHERE.value(),
+                        HibernateQueryArgument.HQL_JOIN.value(),
+                        HibernateQueryArgument.HQL_LEFT.value(),
+                        HibernateQueryArgument.HQL_RIGHT.value(),
+                        HibernateQueryArgument.HQL_INNER.value(),
+                        HibernateQueryArgument.HQL_OUTER.value(),
+                        HibernateQueryArgument.HQL_GROUP.value(),
+                        HibernateQueryArgument.HQL_ORDER.value(),
+                        HibernateQueryArgument.HQL_HAVING.value())
                         .contains(token);
         if (hasAlias) return s;
 
         // Strip DISTINCT/ALL prefix before adjusting the projection
         String prefix = "", projOrig = selectClauseOrig, projLower = selectClauseLower;
-        if (projLower.startsWith("distinct ")) {
-            prefix = "distinct ";
-            projOrig = selectClauseOrig.substring("distinct ".length()).trim();
-            projLower = projLower.substring("distinct ".length()).trim();
-        } else if (projLower.startsWith("all ")) {
-            prefix = "all ";
-            projOrig = selectClauseOrig.substring("all ".length()).trim();
-            projLower = projLower.substring("all ".length()).trim();
+        if (projLower.startsWith(HibernateQueryArgument.HQL_DISTINCT.value() + " ")) {
+            prefix = HibernateQueryArgument.HQL_DISTINCT.value() + " ";
+            projOrig = selectClauseOrig.substring(HibernateQueryArgument.HQL_DISTINCT.value().length() + 1).trim();
+            projLower = projLower.substring(HibernateQueryArgument.HQL_DISTINCT.value().length() + 1).trim();
+        } else if (projLower.startsWith(HibernateQueryArgument.HQL_ALL.value() + " ")) {
+            prefix = HibernateQueryArgument.HQL_ALL.value() + " ";
+            projOrig = selectClauseOrig.substring(HibernateQueryArgument.HQL_ALL.value().length() + 1).trim();
+            projLower = projLower.substring(HibernateQueryArgument.HQL_ALL.value().length() + 1).trim();
         }
 
         // Qualify the projection with the synthetic alias
         String adjusted;
         if (projLower.equalsIgnoreCase(entityName)) {
             adjusted = "e"; // "select Person from Person" → "select e"
-        } else if (!projLower.contains("(") && !projLower.contains(".") && !projLower.startsWith("new ")) {
+        } else if (!projLower.contains("(") && !projLower.contains(".") && !projLower.startsWith(HibernateQueryArgument.HQL_NEW.value() + " ")) {
             adjusted = "e." + projOrig; // "select name from Person"   → "select e.name"
         } else {
             adjusted = projOrig; // functions / constructor expr / already qualified
         }
 
-        return "select " + prefix + adjusted + " from " + entityName + " e" + s.substring(entityEnd);
+        return HibernateQueryArgument.HQL_SELECT.value() + " " + prefix + adjusted + " " + HibernateQueryArgument.HQL_FROM.value() + " " + entityName + " e" + s.substring(entityEnd);
     }
 
     // ─── Private helpers ─────────────────────────────────────────────────────
 
     private static boolean isPropertyProjection(CharSequence hql) {
-        if (hql == null) return false;
-        String s = hql.toString().toLowerCase().trim();
-        int selectIdx = s.indexOf("select ");
-        if (selectIdx < 0) return false;
-        int fromIdx = s.indexOf(" from ", selectIdx);
-        String clause = s.substring(selectIdx + "select ".length(), fromIdx < 0 ? s.length() : fromIdx)
-                .trim();
-        if (clause.startsWith("distinct "))
-            clause = clause.substring("distinct ".length()).trim();
-        else if (clause.startsWith("all "))
-            clause = clause.substring("all ".length()).trim();
-        return clause.contains(".");
+        String clause = getSingleProjectionClause(hql);
+        return clause != null && clause.contains(".");
     }
 
     private static String normalizeMultiLineQueryString(String query) {
diff --git a/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/query/HqlListQueryBuilderSpec.groovy b/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/query/HqlListQueryBuilderSpec.groovy
new file mode 100644
index 0000000000..dab8c09c79
--- /dev/null
+++ b/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/query/HqlListQueryBuilderSpec.groovy
@@ -0,0 +1,177 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you under the Apache License, Version 2.0 (the
+ *  "License"); you may not use this file except in compliance
+ *  with the License.  You may obtain a copy of the License at
+ *
+ *    https://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing,
+ *  software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ *  specific language governing permissions and limitations
+ *  under the License.
+ */
+package org.grails.orm.hibernate.query
+
+import org.grails.datastore.mapping.model.PersistentEntity
+import org.grails.datastore.mapping.model.PersistentProperty
+import org.grails.datastore.mapping.model.types.Association
+import org.grails.orm.hibernate.cfg.HibernateMappingContext
+import org.grails.orm.hibernate.cfg.Mapping
+import org.grails.orm.hibernate.cfg.MappingCacheHolder
+import org.grails.orm.hibernate.cfg.SortConfig
+import spock.lang.Specification
+import spock.lang.Unroll
+
+class HqlListQueryBuilderSpec extends Specification {
+
+    PersistentEntity entity = Mock(PersistentEntity)
+    HibernateMappingContext mappingContext = Mock(HibernateMappingContext)
+    MappingCacheHolder cacheHolder = Mock(MappingCacheHolder)
+
+    def setup() {
+        entity.getName() >> "Person"
+        entity.getJavaClass() >> Object
+        entity.getMappingContext() >> mappingContext
+        mappingContext.getMappingCacheHolder() >> cacheHolder
+    }
+
+    void "test buildCountHql"() {
+        given:
+        def builder = new HqlListQueryBuilder(entity, [:])
+
+        expect:
+        builder.buildCountHql() == "select count(distinct e) from Person e"
+    }
+
+    void "test buildListHql with no arguments"() {
+        given:
+        def builder = new HqlListQueryBuilder(entity, [:])
+
+        expect:
+        builder.buildListHql() == "from Person e"
+    }
+
+    void "test buildListHql with simple sort"() {
+        given:
+        entity.getPropertyByName("name") >> Mock(PersistentProperty) {
+            getType() >> String
+        }
+        def builder = new HqlListQueryBuilder(entity, [
+                (HibernateQueryArgument.SORT.value()) : "name",
+                (HibernateQueryArgument.ORDER.value()): HibernateQueryArgument.ORDER_DESC.value()
+        ])
+
+        expect:
+        builder.buildListHql() == "from Person e order by upper(e.name) desc"
+    }
+
+    void "test buildListHql with numeric sort"() {
+        given:
+        entity.getPropertyByName("age") >> Mock(PersistentProperty) {
+            getType() >> Integer
+        }
+        def builder = new HqlListQueryBuilder(entity, [
+                (HibernateQueryArgument.SORT.value()) : "age",
+                (HibernateQueryArgument.ORDER.value()): HibernateQueryArgument.ORDER_ASC.value()
+        ])
+
+        expect:
+        builder.buildListHql() == "from Person e order by e.age asc"
+    }
+
+    void "test buildListHql with ignoreCase false"() {
+        given:
+        entity.getPropertyByName("name") >> Mock(PersistentProperty) {
+            getType() >> String
+        }
+        def builder = new HqlListQueryBuilder(entity, [
+                (HibernateQueryArgument.SORT.value())       : "name",
+                (HibernateQueryArgument.IGNORE_CASE.value()): false
+        ])
+
+        expect:
+        builder.buildListHql() == "from Person e order by e.name asc"
+    }
+
+    void "test buildListHql with multiple sorts"() {
+        given:
+        entity.getPropertyByName("name") >> Mock(PersistentProperty) { getType() >> String }
+        entity.getPropertyByName("age") >> Mock(PersistentProperty) { getType() >> Integer }
+        // Use LinkedHashMap to ensure deterministic order in HQL generation
+        def builder = new HqlListQueryBuilder(entity, [
+                (HibernateQueryArgument.SORT.value()): [
+                        name: HibernateQueryArgument.ORDER_ASC.value(),
+                        age : HibernateQueryArgument.ORDER_DESC.value()
+                ]
+        ])
+
+        expect:
+        builder.buildListHql() == "from Person e order by upper(e.name) asc, e.age desc"
+    }
+
+    void "test buildListHql with nested property sort"() {
+        given:
+        def authorAssociation = Mock(Association)
+        def authorEntity = Mock(PersistentEntity)
+        entity.getPropertyByName("author") >> authorAssociation
+        authorAssociation.getAssociatedEntity() >> authorEntity
+        authorEntity.getPropertyByName("name") >> Mock(PersistentProperty) { getType() >> String }
+
+        def builder = new HqlListQueryBuilder(entity, [(HibernateQueryArgument.SORT.value()): "author.name"])
+
+        expect:
+        builder.buildListHql() == "from Person e order by upper(e.author.name) asc"
+    }
+
+    void "test buildListHql with join fetch"() {
+        given:
+        def builder = new HqlListQueryBuilder(entity, [
+                (HibernateQueryArgument.FETCH.value()): [
+                        books: HibernateQueryArgument.JOIN.value(),
+                        profile: HibernateQueryArgument.EAGER.value()
+                ]
+        ])
+
+        when:
+        String hql = builder.buildListHql()
+
+        then:
+        hql.startsWith("from Person e")
+        hql.contains(" join fetch e.books")
+        hql.contains(" join fetch e.profile")
+    }
+
+    void "test buildListHql with default sort from mapping"() {
+        given:
+        def mapping = Mock(Mapping)
+        def sortConfig = new SortConfig(name: "lastName", direction: "asc")
+
+        cacheHolder.getMapping(_) >> mapping
+        mapping.getSort() >> sortConfig
+        entity.getPropertyByName("lastName") >> Mock(PersistentProperty) { getType() >> String }
+
+        def builder = new HqlListQueryBuilder(entity, [:])
+
+        expect:
+        builder.buildListHql() == "from Person e order by upper(e.lastName) asc"
+    }
+
+    @Unroll
+    void "test isPaged for params: #params"() {
+        expect:
+        HqlListQueryBuilder.isPaged(params) == expected
+
+        where:
+        params               | expected
+        [:]                  | false
+        [max: 10]            | true
+        [offset: 5]          | false
+        [max: 10, offset: 5] | true
+    }
+}
diff --git a/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/query/HqlQueryContextSpec.groovy b/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/query/HqlQueryContextSpec.groovy
index 5c13d2334a..3a13b21148 100644
--- a/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/query/HqlQueryContextSpec.groovy
+++ b/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/query/HqlQueryContextSpec.groovy
@@ -176,7 +176,7 @@ class HqlQueryContextSpec extends Specification {
         def params = [:]
 
         when:
-        String result = HqlQueryContext.resolveHql(gq, false, params)
+        String result = HqlQueryContext.resolveHql(gq, false, params as Map<String, Object>)
 
         then:
         result     == "from Foo where x = :p0"
@@ -191,7 +191,7 @@ class HqlQueryContextSpec extends Specification {
         def params = [:]
 
         when:
-        String result = HqlQueryContext.resolveHql(gq, false, params)
+        String result = HqlQueryContext.resolveHql(gq, false, params as Map<String, Object>)
 
         then:
         result     == "from Foo where x = :p0 and y = :p1"
@@ -238,6 +238,22 @@ class HqlQueryContextSpec extends Specification {
         HqlQueryContext.getTarget("select p.name, p.age from Person p", String) == Object[].class
     }
 
+    @Unroll
+    void "getTarget returns Long for aggregate projection: #hql"() {
+        expect:
+        HqlQueryContext.getTarget(hql, String) == Long
+        where:
+        hql << [
+            "select count(p) from Person p",
+            "select sum(p.age) from Person p",
+            "select avg(p.age) from Person p",
+            "select min(p.age) from Person p",
+            "select max(p.age) from Person p",
+            "select count(*) from Person",
+            "select distinct count(p.id) from Person p"
+        ]
+    }
+
     // ─── countHqlProjections ─────────────────────────────────────────────────
 
     void "countHqlProjections returns 0 for null"() {


(grails-core) 06/08: hibernate 7: more linting

Posted by bo...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

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

commit d78d73c37b92acf71e8cd6417a942f4f4db83d4a
Author: Walter Duque de Estrada <wb...@mac.com>
AuthorDate: Sun Mar 22 14:56:14 2026 -0500

    hibernate 7: more linting
---
 .../grails/orm/HibernateCriteriaBuilder.java       | 30 ++++++++--------------
 .../RootPersistentClassCommonValuesBinder.java     |  1 +
 .../generator/GrailsSequenceGeneratorEnum.groovy   |  2 +-
 .../generator/GrailsTableGenerator.java            |  4 ++-
 .../HibernateDatastoreIntegrationSpec.groovy       |  3 ++-
 5 files changed, 17 insertions(+), 23 deletions(-)

diff --git a/grails-data-hibernate7/core/src/main/groovy/grails/orm/HibernateCriteriaBuilder.java b/grails-data-hibernate7/core/src/main/groovy/grails/orm/HibernateCriteriaBuilder.java
index fd07b327d2..ceba4af686 100644
--- a/grails-data-hibernate7/core/src/main/groovy/grails/orm/HibernateCriteriaBuilder.java
+++ b/grails-data-hibernate7/core/src/main/groovy/grails/orm/HibernateCriteriaBuilder.java
@@ -142,7 +142,7 @@ public class HibernateCriteriaBuilder extends GroovyObjectSupport implements Bui
     @SuppressWarnings("PMD.AvoidFieldNameMatchingMethodName")
     private boolean distinct = false;
 
-    @SuppressWarnings("rawtypes")
+    @SuppressWarnings({"rawtypes", "PMD.CloseResource"})
     public HibernateCriteriaBuilder(Class targetClass, SessionFactory sessionFactory, HibernateDatastore datastore) {
         this.targetClass = targetClass;
         setDatastore(datastore);
@@ -162,23 +162,13 @@ public class HibernateCriteriaBuilder extends GroovyObjectSupport implements Bui
     }
 
     public final void setDatastore(HibernateDatastore datastore) {
-        if (MultiTenant.class.isAssignableFrom(targetClass) &&
-                datastore.getMultiTenancyMode() == MultiTenancySettings.MultiTenancyMode.DISCRIMINATOR) {
+        if (MultiTenant.class.isAssignableFrom(targetClass)
+                && datastore.getMultiTenancyMode() == MultiTenancySettings.MultiTenancyMode.DISCRIMINATOR) {
             datastore.enableMultiTenancyFilter();
         }
     }
 
-    public org.grails.datastore.mapping.query.api.Criteria createAlias(String associationPath, String alias) {
-        var prop = hibernateQuery.getEntity().getPropertyByName(associationPath);
-        if (prop instanceof org.grails.datastore.mapping.model.types.Basic) {
-            hibernateQuery.addAlias(new org.grails.orm.hibernate.query.HibernateAlias(associationPath, alias));
-            return this;
-        }
-        hibernateQuery.getDetachedCriteria().createAlias(associationPath, alias);
-        return this;
-    }
-
-    public org.grails.datastore.mapping.query.api.Criteria createAlias(String associationPath, String alias, int joinType) {
+    public Criteria createAlias(String associationPath, String alias) {
         var prop = hibernateQuery.getEntity().getPropertyByName(associationPath);
         if (prop instanceof org.grails.datastore.mapping.model.types.Basic) {
             hibernateQuery.addAlias(new org.grails.orm.hibernate.query.HibernateAlias(associationPath, alias));
@@ -1016,9 +1006,9 @@ public class HibernateCriteriaBuilder extends GroovyObjectSupport implements Bui
      */
     @Override
     public Criteria order(String propertyName, String directionString) {
-        Query.Order.Direction direction = Query.Order.Direction.DESC.name().equalsIgnoreCase(directionString) ?
-                Query.Order.Direction.DESC :
-                Query.Order.Direction.ASC;
+        Query.Order.Direction direction = Query.Order.Direction.DESC.name().equalsIgnoreCase(directionString)
+                ? Query.Order.Direction.DESC
+                : Query.Order.Direction.ASC;
         hibernateQuery.order(new Query.Order(propertyName, direction));
         return this;
     }
@@ -1195,9 +1185,9 @@ public class HibernateCriteriaBuilder extends GroovyObjectSupport implements Bui
     @SuppressWarnings("rawtypes")
     @Override
     public Object invokeMethod(String name, Object obj) {
-        Object[] args = obj.getClass().isArray() ?
-                (Object[]) obj :
-                (obj instanceof Collection ? ((Collection) obj).toArray() : new Object[] {obj});
+        Object[] args = obj.getClass().isArray()
+                ? (Object[]) obj
+                : (obj instanceof Collection ? ((Collection) obj).toArray() : new Object[] {obj});
         return new CriteriaMethodInvoker(this).invokeMethod(name, args);
     }
 
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/RootPersistentClassCommonValuesBinder.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/RootPersistentClassCommonValuesBinder.java
index 241897b1cf..3303068b88 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/RootPersistentClassCommonValuesBinder.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/binder/RootPersistentClassCommonValuesBinder.java
@@ -98,6 +98,7 @@ public class RootPersistentClassCommonValuesBinder {
                     + root.getTable().getName());
         }
 
+
         identityBinder.bindIdentity(hibernatePersistentEntity, root);
         versionBinder.bindVersion(hibernatePersistentEntity.getVersion(), root);
         root.createPrimaryKey();
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/generator/GrailsSequenceGeneratorEnum.groovy b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/generator/GrailsSequenceGeneratorEnum.groovy
index 5ade00b97d..7ef4971c7f 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/generator/GrailsSequenceGeneratorEnum.groovy
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/generator/GrailsSequenceGeneratorEnum.groovy
@@ -67,7 +67,7 @@ enum GrailsSequenceGeneratorEnum {
         return Optional.ofNullable(values().find { it.name == name })
     }
 
-    static Generator getGenerator(
+    protected static Generator getGenerator(
             String name,
             GeneratorCreationContext context,
             Identity mappedId,
diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/generator/GrailsTableGenerator.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/generator/GrailsTableGenerator.java
index 42069c0c02..b7544d7abf 100644
--- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/generator/GrailsTableGenerator.java
+++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/cfg/domainbinding/generator/GrailsTableGenerator.java
@@ -35,6 +35,8 @@ public class GrailsTableGenerator extends TableGenerator {
     @Serial
     private static final long serialVersionUID = 1L;
 
+    private static final String DEFAULT_ENTITY_NAME = "default";
+
     public GrailsTableGenerator(GeneratorCreationContext context, Identity mappedId, JdbcEnvironment jdbcEnvironment) {
         Properties generatorProps =
                 Optional.ofNullable(mappedId).map(Identity::getProperties).orElse(new Properties());
@@ -43,7 +45,7 @@ public class GrailsTableGenerator extends TableGenerator {
             String propertyName = context.getProperty().getName();
 
             // Use the name we just ensured exists in BasicValueIdCreator
-            String entityName = (mappedId != null && mappedId.getName() != null) ? mappedId.getName() : "default";
+            String entityName = (mappedId != null && mappedId.getName() != null) ? mappedId.getName() : DEFAULT_ENTITY_NAME;
 
             generatorProps.put(SEGMENT_VALUE_PARAM, entityName + "." + propertyName);
         }
diff --git a/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/HibernateDatastoreIntegrationSpec.groovy b/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/HibernateDatastoreIntegrationSpec.groovy
index f46c53971a..6455d36e5e 100644
--- a/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/HibernateDatastoreIntegrationSpec.groovy
+++ b/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/HibernateDatastoreIntegrationSpec.groovy
@@ -29,6 +29,7 @@ import org.testcontainers.containers.PostgreSQLContainer
 import org.testcontainers.spock.Testcontainers
 import spock.lang.Requires
 import spock.lang.Shared
+import org.grails.datastore.mapping.core.connections.ConnectionSource
 
 @Testcontainers
 @Requires({ isDockerAvailable() })
@@ -109,7 +110,7 @@ class HibernateDatastoreIntegrationSpec extends HibernateGormDatastoreSpec {
 
     void "dataSourceName defaults to DEFAULT"() {
         expect:
-        datastore.dataSourceName == 'DEFAULT'
+        datastore.dataSourceName == ConnectionSource.DEFAULT
     }
 
     void "isAutoFlush is false when grails.gorm.autoFlush is not set"() {