Refactor and rename LinkableEntity* classes to AggregateEntity*

Author: nakamura-to

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

@@ -57,23 +57,23 @@ public AggregateCommand(
 
   @Override
   public RESULT execute() {
-    Set<EntityCacheKey> rootEntityKeys = new LinkedHashSet<>();
-    Map<EntityCacheKey, Object> entityCache = new HashMap<>();
-    SelectCommand<List<LinkableEntityPool>> command =
+    Set<AggregateEntityCacheKey> rootEntityKeys = new LinkedHashSet<>();
+    Map<AggregateEntityCacheKey, Object> entityCache = new HashMap<>();
+    SelectCommand<List<AggregateEntityPool>> command =
         new SelectCommand<>(
             query,
-            new LinkableEntityPoolIterationHandler(
+            new AggregateEntityPoolIterationHandler(
                 entityType,
                 aggregateStrategyType,
                 query.isResultMappingEnsured(),
                 rootEntityKeys,
                 entityCache));
-    List<LinkableEntityPool> entityPools = command.execute();
+    List<AggregateEntityPool> entityPools = command.execute();
 
-    Combinations<LinkableEntityKey> combinations = new Combinations<>();
-    for (LinkableEntityPool entityPool : entityPools) {
-      Map<PathKey, LinkableEntityPoolEntry> associationCandidate = new HashMap<>();
-      for (LinkableEntityPoolEntry entry : entityPool) {
+    Combinations<AggregateEntityKey> combinations = new Combinations<>();
+    for (AggregateEntityPool entityPool : entityPools) {
+      Map<AggregatePathKey, AggregateEntityPoolEntry> associationCandidate = new HashMap<>();
+      for (AggregateEntityPoolEntry entry : entityPool) {
         associationCandidate.put(entry.entityKey().pathKey(), entry);
       }
       associate(entityCache, combinations, associationCandidate);
@@ -95,19 +95,19 @@ public RESULT execute() {
    * of linkage rules and updates the cache with newly associated entities.
    */
   private void associate(
-      Map<EntityCacheKey, Object> entityCache,
-      Combinations<LinkableEntityKey> combinations,
-      Map<PathKey, LinkableEntityPoolEntry> associationCandidate) {
+      Map<AggregateEntityCacheKey, Object> entityCache,
+      Combinations<AggregateEntityKey> combinations,
+      Map<AggregatePathKey, AggregateEntityPoolEntry> associationCandidate) {
 
     for (AssociationLinkerType<?, ?> linkerType :
         aggregateStrategyType.getAssociationLinkerTypes()) {
-      LinkableEntityPoolEntry source = associationCandidate.get(linkerType.getSourcePathKey());
-      LinkableEntityPoolEntry target = associationCandidate.get(linkerType.getTargetPathKey());
+      AggregateEntityPoolEntry source = associationCandidate.get(linkerType.getSourcePathKey());
+      AggregateEntityPoolEntry target = associationCandidate.get(linkerType.getTargetPathKey());
       if (source == null || target == null) {
         continue;
       }
 
-      Pair<LinkableEntityKey, LinkableEntityKey> keyPair =
+      Pair<AggregateEntityKey, AggregateEntityKey> keyPair =
           new Pair<>(source.entityKey(), target.entityKey());
       if (combinations.contains(keyPair)) {
         continue;
@@ -119,10 +119,10 @@ private void associate(
           (BiFunction<Object, Object, Object>) linkerType.getLinker();
       Object entity = linker.apply(source.entity(), target.entity());
       if (entity != null) {
-        EntityCacheKey cacheKey = EntityCacheKey.of(source.entityKey());
+        AggregateEntityCacheKey cacheKey = AggregateEntityCacheKey.of(source.entityKey());
         entityCache.replace(cacheKey, entity);
         associationCandidate.replace(
-            source.pathKey(), new LinkableEntityPoolEntry(source.entityKey(), entity));
+            source.pathKey(), new AggregateEntityPoolEntry(source.entityKey(), entity));
       }
     }
   }

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

@@ -18,8 +18,8 @@
 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());
+public record AggregateEntityCacheKey(EntityType<?> entityType, List<?> items) {
+  public static AggregateEntityCacheKey of(AggregateEntityKey entityKey) {
+    return new AggregateEntityCacheKey(entityKey.entityType(), entityKey.items());
   }
 }

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

@@ -19,8 +19,8 @@
 import java.util.Objects;
 import org.seasar.doma.jdbc.entity.EntityType;
 
-public record LinkableEntityKey(PathKey pathKey, List<?> items) {
-  public LinkableEntityKey {
+public record AggregateEntityKey(AggregatePathKey pathKey, List<?> items) {
+  public AggregateEntityKey {
     Objects.requireNonNull(pathKey);
     Objects.requireNonNull(items);
   }

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

@@ -20,17 +20,17 @@
 import java.util.List;
 import java.util.Objects;
 
-public class LinkableEntityPool implements Iterable<LinkableEntityPoolEntry> {
-  private final List<LinkableEntityPoolEntry> entities = new ArrayList<>();
+public class AggregateEntityPool implements Iterable<AggregateEntityPoolEntry> {
+  private final List<AggregateEntityPoolEntry> entities = new ArrayList<>();
 
-  public void add(LinkableEntityPoolEntry entry) {
+  public void add(AggregateEntityPoolEntry entry) {
     Objects.requireNonNull(entry);
     entities.add(entry);
   }
 
   @SuppressWarnings("NullableProblems")
   @Override
-  public Iterator<LinkableEntityPoolEntry> iterator() {
+  public Iterator<AggregateEntityPoolEntry> iterator() {
     return entities.iterator();
   }
 }

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

@@ -17,13 +17,13 @@
 
 import java.util.Objects;
 
-public record LinkableEntityPoolEntry(LinkableEntityKey entityKey, Object entity) {
-  public LinkableEntityPoolEntry {
+public record AggregateEntityPoolEntry(AggregateEntityKey entityKey, Object entity) {
+  public AggregateEntityPoolEntry {
     Objects.requireNonNull(entityKey);
     Objects.requireNonNull(entity);
   }
 
-  public PathKey pathKey() {
+  public AggregatePathKey pathKey() {
     return entityKey.pathKey();
   }
 }

doma-core/src/main/java/org/seasar/doma/jdbc/aggregate/LinkableEntityPoolIterationHandler.java renamed to doma-core/src/main/java/org/seasar/doma/jdbc/aggregate/AggregateEntityPoolIterationHandler.java

@@ -26,24 +26,24 @@
 import org.seasar.doma.jdbc.query.SelectQuery;
 
 /**
- * Handles the iteration of {@link LinkableEntityPool} results from a query execution and manages
+ * Handles the iteration of {@link AggregateEntityPool} results from a query execution and manages
  * the creation and configuration of object providers used to process the results.
  */
-public class LinkableEntityPoolIterationHandler
-    extends AbstractIterationHandler<LinkableEntityPool, List<LinkableEntityPool>> {
+public class AggregateEntityPoolIterationHandler
+    extends AbstractIterationHandler<AggregateEntityPool, List<AggregateEntityPool>> {
 
   private final EntityType<?> entityType;
   private final AggregateStrategyType aggregateStrategyType;
   private final boolean resultMappingEnsured;
-  private final Set<EntityCacheKey> rootEntityKeys;
-  private final Map<EntityCacheKey, Object> entityCache;
+  private final Set<AggregateEntityCacheKey> rootEntityKeys;
+  private final Map<AggregateEntityCacheKey, Object> entityCache;
 
-  public LinkableEntityPoolIterationHandler(
+  public AggregateEntityPoolIterationHandler(
       EntityType<?> entityType,
       AggregateStrategyType aggregateStrategyType,
       boolean resultMappingEnsured,
-      Set<EntityCacheKey> rootEntityKeys,
-      Map<EntityCacheKey, Object> entityCache) {
+      Set<AggregateEntityCacheKey> rootEntityKeys,
+      Map<AggregateEntityCacheKey, Object> entityCache) {
     super(new ResultListCallback<>());
     this.entityType = Objects.requireNonNull(entityType);
     this.aggregateStrategyType = Objects.requireNonNull(aggregateStrategyType);
@@ -53,8 +53,8 @@ public LinkableEntityPoolIterationHandler(
   }
 
   @Override
-  protected ObjectProvider<LinkableEntityPool> createObjectProvider(SelectQuery query) {
-    return new LinkableEntityPoolProvider(
+  protected ObjectProvider<AggregateEntityPool> createObjectProvider(SelectQuery query) {
+    return new AggregateEntityPoolProvider(
         entityType,
         aggregateStrategyType,
         query,

doma-core/src/main/java/org/seasar/doma/jdbc/aggregate/LinkableEntityPoolProvider.java renamed to doma-core/src/main/java/org/seasar/doma/jdbc/aggregate/AggregateEntityPoolProvider.java

@@ -37,25 +37,25 @@
 import org.seasar.doma.jdbc.entity.Property;
 import org.seasar.doma.jdbc.query.Query;
 
-public class LinkableEntityPoolProvider extends AbstractObjectProvider<LinkableEntityPool> {
+public class AggregateEntityPoolProvider extends AbstractObjectProvider<AggregateEntityPool> {
 
   private final EntityType<?> entityType;
   private final Query query;
-  private final Set<EntityCacheKey> rootEntityKeys;
-  private final Map<EntityCacheKey, Object> entityCache;
+  private final Set<AggregateEntityCacheKey> rootEntityKeys;
+  private final Map<AggregateEntityCacheKey, Object> entityCache;
   private Map<Integer, MappingSupport.PropType> indexMap;
   private final MappingSupport mappingSupport;
   private final FetchSupport fetchSupport;
   private final AggregateStrategyType aggregateStrategyType;
   private final Map<String, AssociationLinkerType<?, ?>> associationLinkerTypeMap;
 
-  public LinkableEntityPoolProvider(
+  public AggregateEntityPoolProvider(
       EntityType<?> entityType,
       AggregateStrategyType aggregateStrategyType,
       Query query,
       boolean resultMappingEnsured,
-      Set<EntityCacheKey> rootEntityKeys,
-      Map<EntityCacheKey, Object> entityCache) {
+      Set<AggregateEntityCacheKey> rootEntityKeys,
+      Map<AggregateEntityCacheKey, Object> entityCache) {
     assertNotNull(entityType, aggregateStrategyType, query, rootEntityKeys, entityCache);
     this.entityType = entityType;
     this.query = query;
@@ -76,9 +76,9 @@ public LinkableEntityPoolProvider(
   }
 
   @Override
-  public LinkableEntityPool get(ResultSet resultSet) throws SQLException {
+  public AggregateEntityPool get(ResultSet resultSet) throws SQLException {
     List<MappingSupport.Prop> props = createProps(resultSet);
-    Map<PathKey, List<MappingSupport.Prop>> propGroup = groupPropsByPathKey(props);
+    Map<AggregatePathKey, List<MappingSupport.Prop>> propGroup = groupPropsByPathKey(props);
     return createEntityPool(propGroup);
   }
 
@@ -143,29 +143,31 @@ private void collectColumnNames(
     }
   }
 
-  private Map<PathKey, List<MappingSupport.Prop>> groupPropsByPathKey(
+  private Map<AggregatePathKey, List<MappingSupport.Prop>> groupPropsByPathKey(
       List<MappingSupport.Prop> props) {
     return props.stream()
-        .collect(Collectors.groupingBy(it -> new PathKey(it.propertyPath(), it.entityType())));
+        .collect(
+            Collectors.groupingBy(it -> new AggregatePathKey(it.propertyPath(), it.entityType())));
   }
 
   /**
-   * Creates and populates a {@link LinkableEntityPool} based on the provided group of properties
-   * organized by their {@link PathKey}.
+   * Creates and populates a {@link AggregateEntityPool} based on the provided group of properties
+   * organized by their {@link AggregatePathKey}.
    */
-  private LinkableEntityPool createEntityPool(Map<PathKey, List<MappingSupport.Prop>> propGroup) {
-    LinkableEntityPool entityPool = new LinkableEntityPool();
+  private AggregateEntityPool createEntityPool(
+      Map<AggregatePathKey, List<MappingSupport.Prop>> propGroup) {
+    AggregateEntityPool entityPool = new AggregateEntityPool();
 
-    for (Map.Entry<PathKey, List<MappingSupport.Prop>> entry : propGroup.entrySet()) {
-      PathKey pathKey = entry.getKey();
+    for (Map.Entry<AggregatePathKey, List<MappingSupport.Prop>> entry : propGroup.entrySet()) {
+      AggregatePathKey pathKey = entry.getKey();
       List<MappingSupport.Prop> props = entry.getValue();
       if (props.stream().allMatch(p -> p.rawValue() == null)) {
         continue;
       }
-      LinkableEntityKey entityKey = createLinkableEntityKey(pathKey, props);
-      EntityCacheKey cacheKey = EntityCacheKey.of(entityKey);
+      AggregateEntityKey entityKey = createEntityKey(pathKey, props);
+      AggregateEntityCacheKey cacheKey = AggregateEntityCacheKey.of(entityKey);
       Object entity = entityCache.computeIfAbsent(cacheKey, k -> createEntity(k, props));
-      entityPool.add(new LinkableEntityPoolEntry(entityKey, entity));
+      entityPool.add(new AggregateEntityPoolEntry(entityKey, entity));
       if (pathKey.isRoot()) {
         rootEntityKeys.add(cacheKey);
       }
@@ -174,20 +176,21 @@ private LinkableEntityPool createEntityPool(Map<PathKey, List<MappingSupport.Pro
     return entityPool;
   }
 
-  private static LinkableEntityKey createLinkableEntityKey(
-      PathKey pathKey, List<MappingSupport.Prop> props) {
-    LinkableEntityKey entityKey;
+  private static AggregateEntityKey createEntityKey(
+      AggregatePathKey pathKey, List<MappingSupport.Prop> props) {
+    AggregateEntityKey entityKey;
     if (pathKey.entityType().getIdPropertyTypes().isEmpty()) {
-      entityKey = new LinkableEntityKey(pathKey, Collections.singletonList(new Object()));
+      entityKey = new AggregateEntityKey(pathKey, Collections.singletonList(new Object()));
     } else {
       List<?> items =
           props.stream().filter(MappingSupport.Prop::isId).map(it -> it.wrapper().get()).toList();
-      entityKey = new LinkableEntityKey(pathKey, items);
+      entityKey = new AggregateEntityKey(pathKey, items);
     }
     return entityKey;
   }
 
-  private static Object createEntity(EntityCacheKey cacheKey, List<MappingSupport.Prop> props) {
+  private static Object createEntity(
+      AggregateEntityCacheKey cacheKey, List<MappingSupport.Prop> props) {
     @SuppressWarnings("unchecked")
     EntityType<Object> entityType = (EntityType<Object>) cacheKey.entityType();
     Map<String, Property<Object, ?>> states =

doma-core/src/main/java/org/seasar/doma/jdbc/aggregate/PathKey.java renamed to doma-core/src/main/java/org/seasar/doma/jdbc/aggregate/AggregatePathKey.java

@@ -18,8 +18,8 @@
 import java.util.Objects;
 import org.seasar.doma.jdbc.entity.EntityType;
 
-public record PathKey(String propertyPath, EntityType<?> entityType) {
-  public PathKey {
+public record AggregatePathKey(String propertyPath, EntityType<?> entityType) {
+  public AggregatePathKey {
     Objects.requireNonNull(propertyPath);
     Objects.requireNonNull(entityType);
   }

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

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