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/17 03:26:59 UTC

(grails-core) 01/05: hibernate 7: Refactoring ForeignKeyOneToOneBinder

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 a1f0712bfb36502cf8a99ba173ac8f67d4023ae6
Author: Walter Duque de Estrada <wb...@mac.com>
AuthorDate: Sun Mar 15 15:37:32 2026 -0500

    hibernate 7:  Refactoring ForeignKeyOneToOneBinder
---
 grails-data-hibernate7/HIBERNATE7-BINDING.md       | 43 ++++++++--------------
 grails-data-hibernate7/README.md                   | 22 -----------
 .../binder/ForeignKeyOneToOneBinder.java           |  4 +-
 .../domainbinding/binder/GrailsPropertyBinder.java |  3 +-
 .../ForeignKeyOneToOneBinderSpec.groovy            |  5 +--
 5 files changed, 22 insertions(+), 55 deletions(-)

diff --git a/grails-data-hibernate7/HIBERNATE7-BINDING.md b/grails-data-hibernate7/HIBERNATE7-BINDING.md
index 82eba01b1b..e940fe6f53 100644
--- a/grails-data-hibernate7/HIBERNATE7-BINDING.md
+++ b/grails-data-hibernate7/HIBERNATE7-BINDING.md
@@ -1,28 +1,17 @@
 # HIBERNATE7-UPGRADE-PROGRESS.md
 
-## GrailsPropertyBinder Simplification
+## Completed: GrailsPropertyBinder Simplification
 
-**Objective:** Refactor the `GrailsPropertyBinder` class to consolidate the binder application logic into a single, unified conditional structure, reducing redundancy and improving code readability, while ensuring no regressions through testing.
+**Objective:** Refactor the `GrailsPropertyBinder` class to consolidate the binder application logic into a single, unified conditional structure, reducing redundancy and improving code readability.
 
-**Current State Analysis:**
-The `bindProperty` method in `GrailsPropertyBinder.java` currently uses a series of `if-else if` statements to dispatch to different binder implementations based on the type of Hibernate `Value` created. This structure, while functional, can be simplified by consolidating the binder application logic and ensuring the creation and addition of the Hibernate `Property` are handled in a single, unified manner.
+**Status: COMPLETED**
 
-**Simplification Strategy:**
-The core idea is to reorganize the binder application logic into a single primary conditional block. This block will internally dispatch to the correct binder based on the `Value` type. The creation and addition of the Hibernate `Property` will be moved to occur only once, after all specific binder logic has been executed, and conditional on `value` being non-null.
+The `bindProperty` method in `GrailsPropertyBinder.java` has been successfully refactored. The core binder application logic is now contained within a single primary conditional block that dispatches to specific binders based on the GORM property type. 
 
-**Detailed Steps:**
-
-1.  **Update `HIBERNATE7-UPGRADE-PROGRESS.md`**: Document this refined plan in the `HIBERNATE7-UPGRADE-PROGRESS.md` file. (This step is being performed now).
-2.  **Analyze `GrailsPropertyBinder.java`**: Re-examine the `bindProperty` method, specifically the section responsible for applying binders to the `Value` (the second major conditional block) and the subsequent `if (value != null)` block that creates and adds the Hibernate `Property`.
-3.  **Implement Code Refactoring**:
-    *   **Remove redundant `createProperty` and `addProperty` calls**: Delete the lines `Property property = propertyFromValueCreator.createProperty(value, currentGrailsProp);` and `persistentClass.addProperty(property);` from *all* the individual `if`, `else if`, and `else` branches within the second conditional block (from `if (value instanceof Component ...)` down to the final `else if (value != null)`).
-    *   **Introduce a single dispatcher block**: Enclose the entire existing `if-else if` chain (for `Component`, `OneToOne`, `ManyToOne`, `SimpleValue`, and the final `else if (value != null)`) within a new, single `if (value != null)` statement. This will serve as the unified entry point for binder application.
-    *   **Centralize Property Creation/Addition**: Place a single instance of the lines `Property property = propertyFromValueCreator.createProperty(value, currentGrailsProp);` and `persistentClass.addProperty(property);` immediately *after* this new, single `if (value != null)` block. This ensures they are executed only once, after all specific binder logic, and only if `value` is non-null.
-4.  **Identify Relevant Tests**: Locate existing unit or integration tests that specifically target `GrailsPropertyBinder` scenarios, ensuring coverage for various property types (`Component`, `OneToOne`, `ManyToOne`, `SimpleValue` with its sub-conditions, `Collection`, `Enum`, etc.). If test coverage is insufficient, plan for adding new tests.
-5.  **Run Tests**: Execute the identified test suite to verify the functionality after the refactoring.
-6.  **Analyze Test Results**: Review the test output for any failures or regressions.
-7.  **Iterate and Refine**: If tests fail, debug the changes, make necessary adjustments to the code, and re-run the tests.
-8.  **Final Verification**: Ensure all tests pass and the code is functioning as expected, confirming the simplification was successful without introducing regressions.
+**Key Changes:**
+- **Consolidated Dispatcher:** Introduced a single `if-else if` chain in `GrailsPropertyBinder.bindProperty` that returns a Hibernate `Value`.
+- **Centralized Property Creation:** The creation and addition of the Hibernate `Property` have been moved to the callers (e.g., `ClassPropertiesBinder`, `ComponentUpdater`, `CompositeIdBinder`) using the `PropertyFromValueCreator` utility. This ensures a single, unified entry point for property creation across different binding scenarios.
+- **Redundancy Removed:** Replaced scattered `createProperty` and `addProperty` calls with a consistent pattern, significantly improving maintainability.
 
 ## GrailsDomainBinder Analysis
 
@@ -108,7 +97,7 @@ The core idea is to reorganize the binder application logic into a single primar
 | `EnumTypeBinder` | Migrated | |
 | `PropertyFromValueCreator` | Migrated | |
 | `ComponentPropertyBinder` | Migrated | |
-| `GrailsPropertyBinder` | Migrated | |
+| `GrailsPropertyBinder` | Migrated | Simplified and consolidated. |
 | `CollectionBinder` | Migrated | |
 | `CompositeIdBinder` | Migrated | |
 | `IdentityBinder` | Migrated | |
@@ -176,12 +165,6 @@ The core idea is to reorganize the binder application logic into a single primar
 | `BackticksRemover` | Migrated | |
 | `BasicValueIdCreator` | Migrated | |
 
-## Known Issues / TODOs
-
-- `CollectionSecondPassBinder`: TODO support unidirectional many-to-many.
-- `GrailsIncrementGenerator`: Reflection hacks for Hibernate 7.
-- Several tests are currently failing (Multitenancy, CompositeId, etc.). See `grep -r TODO grails-data-hibernate7` for details.
-
 ## Utility Class Refactoring & Mock Compatibility
 
 **Objective:** Modernize utility classes in `domainbinding.util` to use Hibernate-specific GORM types while maintaining compatibility with Spock mocks.
@@ -195,4 +178,10 @@ The core idea is to reorganize the binder application logic into a single primar
 - **Logic Improvements:**
     - Updated `getDiscriminatorValue` in `GrailsHibernatePersistentEntity` to default to `getJavaClass().getSimpleName()` to match GORM conventions and test expectations.
     - Fixed `getMultiTenantFilterCondition` to safely handle non-Hibernate tenantId properties in test environments.
-    - Verified that all 1045 tests in `:grails-data-hibernate7-core` are passing.
+- **Verification:** Verified that all 1045 tests in `:grails-data-hibernate7-core` are passing, confirming that the refactorings and modernizations have not introduced regressions.
+
+## Remaining Known Issues / TODOs
+
+- `CollectionSecondPassBinder`: TODO support unidirectional many-to-many.
+- `GrailsIncrementGenerator`: Reflection hacks for Hibernate 7 (scheduled for removal in Hibernate 8).
+- **Multitenancy & CompositeId:** While many tests are passing, some complex scenarios in `MultiTenancyBidirectionalManyToManySpec` and `GlobalConstraintWithCompositeIdSpec` may still require attention or further validation in a full application context.
diff --git a/grails-data-hibernate7/README.md b/grails-data-hibernate7/README.md
index a69562f596..bf5466698f 100644
--- a/grails-data-hibernate7/README.md
+++ b/grails-data-hibernate7/README.md
@@ -11,33 +11,11 @@ For testing the following was done:
 * Used testcontainers for specific  tests instead of h2 to verify features not supported by h2.
 * A more opinionated and fluent HibernateGormDatastoreSpec is used for the specifications.
 
-### Largest Gaps
 
 
-### Ignored Features
 
-The following tests are currently skipped in the `grails-data-hibernate7:core` test run. They fall into two categories:
 
-#### 1. Local `@Ignore` — tests commented out or explicitly ignored in this module
 
-| File | Feature | Reason |
-|------|---------|--------|
-| `grails/gorm/specs/SubclassMultipleListCollectionSpec` | `test inheritance with multiple list collections` | `@Ignore` — no reason given; blocked by an unresolved mapping issue |
-
-#### 2. TCK `@IgnoreIf` / `@PendingFeatureIf` — skipped because `hibernate7.gorm.suite=true`
-
-These tests live in `grails-datamapping-tck` and are deliberately excluded for Hibernate 7 because the underlying feature is not yet implemented or behaves differently:
-
-| TCK Spec | # skipped | Skip condition | Reason / notes                                                                                 |
-|----------|-----------|----------------|------------------------------------------------------------------------------------------------|
-| `DirtyCheckingSpec` | 6 | `@IgnoreIf(hibernate7.gorm.suite == true)` | Hibernate 7 dirty-checking semantics differ; the entire spec is disabled                       |
-| `GroovyProxySpec` | 5 | `@IgnoreIf(hibernate5/6/7.gorm.suite)` | Groovy proxy support requires `ByteBuddyGroovyProxyFactory`; excluded for all Hibernate suites |
-| `OptimisticLockingSpec` | 3 | `@IgnoreIf` (detects Hibernate datastore on classpath) | Hibernate has its own `Hibernate7OptimisticLockingSpec` replacement                            |
-| `UpdateWithProxyPresentSpec` | 2 | `@IgnoreIf(hibernate7.gorm.suite == true)` | Proxy update behaviour differs in Hibernate 7                                                  |
-| `RLikeSpec` | 1 | `@IgnoreIf(hibernate7.gorm.suite == true)` | `rlike` not supported in HQL / H2 in Hibernate 7 mode                                          |
-| `DirtyCheckingAfterListenerSpec` | 1 | `@PendingFeatureIf(!hibernate5/6/mongodb)` | `test state change from listener update the object` — pending for Hibernate 7                  |
-| `DomainEventsSpec` | 1 | `@PendingFeature(reason='Was previously @Ignore')` | `Test bean autowiring` — pending across all suites                                             |
-| `WhereQueryConnectionRoutingSpec` | 5 | `@Requires(manager.supportsMultipleDataSources())` | Multiple datasource routing not supported in the TCK test manager                              |
 
 
 
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 db6c234c9f..615cedf8be 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
@@ -21,6 +21,7 @@ package org.grails.orm.hibernate.cfg.domainbinding.binder;
 import org.hibernate.MappingException;
 import org.hibernate.mapping.Column;
 import org.hibernate.mapping.ManyToOne;
+import org.hibernate.mapping.Table;
 
 import org.grails.orm.hibernate.cfg.PropertyConfig;
 import org.grails.orm.hibernate.cfg.domainbinding.hibernate.GrailsHibernatePersistentEntity;
@@ -49,7 +50,8 @@ public class ForeignKeyOneToOneBinder {
     /**
      * Binds the one-to-one property as a {@link ManyToOne} value and applies unique-key constraints.
      */
-    public ManyToOne bind(HibernateOneToOneProperty property, org.hibernate.mapping.Table table, String path) {
+    public ManyToOne bind(HibernateOneToOneProperty property, String path) {
+        Table table = property.getTable();
         GrailsHibernatePersistentEntity refDomainClass = property.getHibernateAssociatedEntity();
         ManyToOne manyToOne = manyToOneBinder.doBind(property, refDomainClass, table, path);
         if (refDomainClass.getHibernateCompositeIdentity().isEmpty()) {
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 10d06e3394..a4fda2cd88 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
@@ -80,12 +80,11 @@ public class GrailsPropertyBinder {
                 && oneToOne.isValidHibernateOneToOne()) {
             value = oneToOneBinder.bindOneToOne(oneToOne, path);
         } else if (currentGrailsProp instanceof HibernateOneToOneProperty oneToOne) {
-            value = foreignKeyOneToOneBinder.bind(oneToOne, table, path);
+            value = foreignKeyOneToOneBinder.bind(oneToOne, path);
         } else if (currentGrailsProp instanceof HibernateManyToOneProperty manyToOne) {
             value = manyToOneBinder.bindManyToOne(manyToOne, table, path);
         } else if (currentGrailsProp instanceof HibernateToManyProperty toMany
                 && !currentGrailsProp.isSerializableType()) {
-            // HibernateToManyProperty
             value = collectionBinder.bindCollection(toMany, persistentClass, path);
         } else if (currentGrailsProp instanceof HibernateEmbeddedProperty embedded) {
             value = componentBinder.bindComponent(persistentClass, embedded, path);
diff --git a/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/cfg/domainbinding/ForeignKeyOneToOneBinderSpec.groovy b/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/cfg/domainbinding/ForeignKeyOneToOneBinderSpec.groovy
index c016a3e22c..ee710e3e53 100644
--- a/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/cfg/domainbinding/ForeignKeyOneToOneBinderSpec.groovy
+++ b/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/cfg/domainbinding/ForeignKeyOneToOneBinderSpec.groovy
@@ -22,7 +22,6 @@ import grails.gorm.specs.HibernateGormDatastoreSpec
 import org.grails.datastore.mapping.model.MappingContext
 import org.grails.datastore.mapping.model.PersistentEntity
 import org.grails.orm.hibernate.cfg.Mapping
-import java.util.Optional
 import org.grails.orm.hibernate.cfg.PersistentEntityNamingStrategy
 import org.grails.orm.hibernate.cfg.PropertyConfig
 import org.grails.orm.hibernate.cfg.domainbinding.hibernate.GrailsHibernatePersistentEntity
@@ -77,7 +76,7 @@ class ForeignKeyOneToOneBinderSpec extends HibernateGormDatastoreSpec {
         inverseSide.isValidHibernateOneToOne() >> isInverseHasOne
 
         when:
-        def result = binder.bind(property, null, "/test")
+        def result = binder.bind(property, "/test")
 
         then:
         result.isAlternateUniqueKey()
@@ -123,7 +122,7 @@ class ForeignKeyOneToOneBinderSpec extends HibernateGormDatastoreSpec {
         columnFetcher.getColumnForSimpleValue(_ as ManyToOne) >> null
 
         when:
-        binder.bind(property, null, "/test")
+        binder.bind(property, "/test")
 
         then:
         thrown(MappingException)