Support for self-joins

Author: nakamura-to

doma-core/src/main/java/org/seasar/doma/jdbc/aggregate/AggregateCommand.java

@@ -15,10 +15,12 @@
  */
 package org.seasar.doma.jdbc.aggregate;
 
-import java.util.LinkedHashMap;
+import java.util.HashMap;
+import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
+import java.util.Set;
 import java.util.function.BiFunction;
 import java.util.stream.Stream;
 import org.seasar.doma.internal.util.Combinations;
@@ -55,28 +57,36 @@ public AggregateCommand(
 
   @Override
   public RESULT execute() {
-    Map<LinkableEntityKey, Object> cache = new LinkedHashMap<>();
-    Combinations<LinkableEntityKey> combinations = new Combinations<>();
+    Set<EntityCacheKey> rootEntityKeys = new LinkedHashSet<>();
+    Map<EntityCacheKey, Object> entityCache = new HashMap<>();
     SelectCommand<List<LinkableEntityPool>> command =
         new SelectCommand<>(
             query,
             new LinkableEntityPoolIterationHandler(
-                entityType, aggregateStrategyType, query.isResultMappingEnsured(), cache));
+                entityType,
+                aggregateStrategyType,
+                query.isResultMappingEnsured(),
+                rootEntityKeys,
+                entityCache));
     List<LinkableEntityPool> entityPools = command.execute();
+
+    Combinations<LinkableEntityKey> combinations = new Combinations<>();
     for (LinkableEntityPool entityPool : entityPools) {
-      Map<String, LinkableEntity> associationCandidate = new LinkedHashMap<>();
-      for (LinkableEntity entry : entityPool) {
-        associationCandidate.put(entry.key().propertyPath(), entry);
+      Map<PathKey, LinkableEntityPoolEntry> associationCandidate = new HashMap<>();
+      for (LinkableEntityPoolEntry entry : entityPool) {
+        associationCandidate.put(entry.entityKey().pathKey(), entry);
       }
-      associate(cache, combinations, associationCandidate);
+      associate(entityCache, combinations, associationCandidate);
     }
+
     @SuppressWarnings("unchecked")
     Stream<ENTITY> stream =
         (Stream<ENTITY>)
-            cache.entrySet().stream()
-                .filter(e -> e.getKey().isRootEntityKey())
-                .map(Map.Entry::getValue)
+            rootEntityKeys.stream()
+                .map(entityCache::get)
+                .filter(Objects::nonNull)
                 .filter(entityType.getEntityClass()::isInstance);
+
     return streamReducer.reduce(stream);
   }
 
@@ -85,30 +95,35 @@ public RESULT execute() {
    * of linkage rules and updates the cache with newly associated entities.
    */
   private void associate(
-      Map<LinkableEntityKey, Object> cache,
+      Map<EntityCacheKey, Object> entityCache,
       Combinations<LinkableEntityKey> combinations,
-      Map<String, LinkableEntity> associationCandidate) {
+      Map<PathKey, LinkableEntityPoolEntry> associationCandidate) {
+
     for (AssociationLinkerType<?, ?> linkerType :
         aggregateStrategyType.getAssociationLinkerTypes()) {
-      LinkableEntity source = associationCandidate.get(linkerType.getAncestorPath());
-      LinkableEntity target = associationCandidate.get(linkerType.getPropertyPath());
+      LinkableEntityPoolEntry source = associationCandidate.get(linkerType.getSourcePathKey());
+      LinkableEntityPoolEntry target = associationCandidate.get(linkerType.getTargetPathKey());
       if (source == null || target == null) {
         continue;
       }
-      Pair<LinkableEntityKey, LinkableEntityKey> keyPair = new Pair<>(source.key(), target.key());
+
+      Pair<LinkableEntityKey, LinkableEntityKey> keyPair =
+          new Pair<>(source.entityKey(), target.entityKey());
       if (combinations.contains(keyPair)) {
         continue;
       }
+      combinations.add(keyPair);
+
       @SuppressWarnings("unchecked")
       BiFunction<Object, Object, Object> linker =
           (BiFunction<Object, Object, Object>) linkerType.getLinker();
-      Object newEntity = linker.apply(source.entity(), target.entity());
-      if (newEntity != null) {
-        cache.replace(source.key(), newEntity);
+      Object entity = linker.apply(source.entity(), target.entity());
+      if (entity != null) {
+        EntityCacheKey cacheKey = EntityCacheKey.of(source.entityKey());
+        entityCache.replace(cacheKey, entity);
         associationCandidate.replace(
-            linkerType.getAncestorPath(), new LinkableEntity(source.key(), newEntity));
+            source.pathKey(), new LinkableEntityPoolEntry(source.entityKey(), entity));
       }
-      combinations.add(keyPair);
     }
   }
 

doma-core/src/main/java/org/seasar/doma/jdbc/aggregate/AssociationLinkerType.java

@@ -80,6 +80,14 @@ public BiFunction<S, T, S> getLinker() {
     return linker;
   }
 
+  public PathKey getSourcePathKey() {
+    return new PathKey(ancestorPath, source);
+  }
+
+  public PathKey getTargetPathKey() {
+    return new PathKey(propertyPath, target);
+  }
+
   public static <S, T> AssociationLinkerType<S, T> of(
       String ancestorPath,
       String propertyPath,

doma-core/src/main/java/org/seasar/doma/jdbc/aggregate/EntityCacheKey.java

@@ -0,0 +1,25 @@
+/*
+ * Copyright Doma Authors
+ *
+ * Licensed 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.seasar.doma.jdbc.aggregate;
+
+import java.util.List;
+import org.seasar.doma.jdbc.entity.EntityType;
+
+public record EntityCacheKey(EntityType<?> entityType, List<?> items) {
+  public static EntityCacheKey of(LinkableEntityKey entityKey) {
+    return new EntityCacheKey(entityKey.entityType(), entityKey.items());
+  }
+}

doma-core/src/main/java/org/seasar/doma/jdbc/aggregate/LinkableEntity.java

@@ -19,28 +19,17 @@
 import java.util.Objects;
 import org.seasar.doma.jdbc.entity.EntityType;
 
-/**
- * Represents a key for an entity that can be linked or associated within a domain model. This key
- * is characterized by its association identifier and a list of associated items.
- *
- * @param associationIdentifier the identifier for the association, must not be {@code null}
- * @param items the items involved in the association, must not be {@code null}
- */
-public record LinkableEntityKey(AssociationIdentifier associationIdentifier, List<?> items) {
+public record LinkableEntityKey(PathKey pathKey, List<?> items) {
   public LinkableEntityKey {
-    Objects.requireNonNull(associationIdentifier);
+    Objects.requireNonNull(pathKey);
     Objects.requireNonNull(items);
   }
 
   public String propertyPath() {
-    return associationIdentifier.propertyPath();
+    return pathKey.propertyPath();
   }
 
   public EntityType<?> entityType() {
-    return associationIdentifier.entityType();
-  }
-
-  public boolean isRootEntityKey() {
-    return associationIdentifier.propertyPath().isEmpty();
+    return pathKey.entityType();
   }
 }

doma-core/src/main/java/org/seasar/doma/jdbc/aggregate/LinkableEntityKey.java

@@ -20,26 +20,17 @@
 import java.util.List;
 import java.util.Objects;
 
-/**
- * Represents a pool of {@link LinkableEntity} objects, providing functionality for adding entities
- * and iterating over the collection.
- *
- * <p>This class is designed to manage a collection of {@code LinkableEntity} instances and
- * guarantees that only non-null entities can be added, ensuring the integrity of the pool. It
- * implements {@link Iterable}, allowing the underlying collection to be used in enhanced for-loops
- * or with other iterable utilities.
- */
-public class LinkableEntityPool implements Iterable<LinkableEntity> {
-  private final List<LinkableEntity> entities = new ArrayList<>();
+public class LinkableEntityPool implements Iterable<LinkableEntityPoolEntry> {
+  private final List<LinkableEntityPoolEntry> entities = new ArrayList<>();
 
-  public void add(LinkableEntity entity) {
-    Objects.requireNonNull(entity);
-    entities.add(entity);
+  public void add(LinkableEntityPoolEntry entry) {
+    Objects.requireNonNull(entry);
+    entities.add(entry);
   }
 
   @SuppressWarnings("NullableProblems")
   @Override
-  public Iterator<LinkableEntity> iterator() {
+  public Iterator<LinkableEntityPoolEntry> iterator() {
     return entities.iterator();
   }
 }

doma-core/src/main/java/org/seasar/doma/jdbc/aggregate/LinkableEntityPool.java

@@ -0,0 +1,29 @@
+/*
+ * Copyright Doma Authors
+ *
+ * Licensed 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.seasar.doma.jdbc.aggregate;
+
+import java.util.Objects;
+
+public record LinkableEntityPoolEntry(LinkableEntityKey entityKey, Object entity) {
+  public LinkableEntityPoolEntry {
+    Objects.requireNonNull(entityKey);
+    Objects.requireNonNull(entity);
+  }
+
+  public PathKey pathKey() {
+    return entityKey.pathKey();
+  }
+}

doma-core/src/main/java/org/seasar/doma/jdbc/aggregate/LinkableEntityPoolEntry.java

@@ -18,6 +18,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
+import java.util.Set;
 import org.seasar.doma.internal.jdbc.command.AbstractIterationHandler;
 import org.seasar.doma.internal.jdbc.command.ResultListCallback;
 import org.seasar.doma.jdbc.ObjectProvider;
@@ -34,23 +35,31 @@ public class LinkableEntityPoolIterationHandler
   private final EntityType<?> entityType;
   private final AggregateStrategyType aggregateStrategyType;
   private final boolean resultMappingEnsured;
-  private final Map<LinkableEntityKey, Object> cache;
+  private final Set<EntityCacheKey> rootEntityKeys;
+  private final Map<EntityCacheKey, Object> entityCache;
 
   public LinkableEntityPoolIterationHandler(
       EntityType<?> entityType,
       AggregateStrategyType aggregateStrategyType,
       boolean resultMappingEnsured,
-      Map<LinkableEntityKey, Object> cache) {
+      Set<EntityCacheKey> rootEntityKeys,
+      Map<EntityCacheKey, Object> entityCache) {
     super(new ResultListCallback<>());
     this.entityType = Objects.requireNonNull(entityType);
     this.aggregateStrategyType = Objects.requireNonNull(aggregateStrategyType);
     this.resultMappingEnsured = resultMappingEnsured;
-    this.cache = Objects.requireNonNull(cache);
+    this.rootEntityKeys = Objects.requireNonNull(rootEntityKeys);
+    this.entityCache = Objects.requireNonNull(entityCache);
   }
 
   @Override
   protected ObjectProvider<LinkableEntityPool> createObjectProvider(SelectQuery query) {
     return new LinkableEntityPoolProvider(
-        entityType, aggregateStrategyType, query, resultMappingEnsured, cache);
+        entityType,
+        aggregateStrategyType,
+        query,
+        resultMappingEnsured,
+        rootEntityKeys,
+        entityCache);
   }
 }