Support creating aggregate objects using arbitrary SQL (#1274)

Author: nakamura-to

doma-core/src/main/java/module-info.java

@@ -57,6 +57,7 @@
   exports org.seasar.doma.internal.expr.node;
   exports org.seasar.doma.internal.jdbc.sql.node;
   exports org.seasar.doma.internal.jdbc.util;
+  exports org.seasar.doma.jdbc.aggregate;
 
   // Requires
   requires transitive java.sql;

doma-core/src/main/java/org/seasar/doma/AggregateStrategy.java

@@ -0,0 +1,64 @@
+/*
+ * 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;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Indicates a strategy for aggregating database records.
+ *
+ * <p>The element annotated with {@linkplain AggregateStrategy} must be an interface.
+ *
+ * <pre>
+ * &#064;AggregateStrategy(root = Department.class, tableAlias = "d")
+ * interface DepartmentStrategy {
+ *
+ *     &#064;AssociationLinker(propertyPath = "employeeList", tableAlias = "e")
+ *     BiFunction&lt;Department, Employee, Department&gt; employeeList = (d, e) -> {
+ *         d.getEmployeeList().add(e);
+ *         e.setDepartment(d);
+ *         return d;
+ *     };
+ *
+ *     &#064;AssociationLinker(propertyPath = "employeeList.address", tableAlias = "a")
+ *     BiFunction&lt;Employee, Address, Employee&gt; employeeListAddress = (e, a) -> {
+ *         e.setAddress(a);
+ *         return e;
+ *     };
+ * }
+ * </pre>
+ */
+@Target({ElementType.TYPE})
+@Retention(RetentionPolicy.RUNTIME)
+public @interface AggregateStrategy {
+
+  /**
+   * Specifies the root entity class associated with the aggregation strategy.
+   *
+   * @return the root class
+   */
+  Class<?> root();
+
+  /**
+   * Specifies the root table alias.
+   *
+   * @return the alias name for a root table
+   */
+  String tableAlias();
+}

doma-core/src/main/java/org/seasar/doma/Association.java

@@ -0,0 +1,45 @@
+/*
+ * 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;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Indicates an association between entities.
+ *
+ * <pre>
+ * &#064;Entity
+ * class Department {
+ *     &#064;Association
+ *     List&lt;Employee&gt; employeeList;
+ * }
+ *
+ * &#064;Entity
+ * class Employee {
+ *     &#064;Association
+ *     Department department;
+ * }
+ * </pre>
+ *
+ * <p>This annotation is applied to fields that represent a relationship between entities.
+ */
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+@EntityField
+public @interface Association {}

doma-core/src/main/java/org/seasar/doma/AssociationLinker.java

@@ -0,0 +1,82 @@
+/*
+ * 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;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.util.function.BiFunction;
+
+/**
+ * Indicates the execution of associations between entities.
+ *
+ * <p>{@linkplain AssociationLinker} can be annotated on a field of {@link BiFunction}.
+ *
+ * <p>For the {@linkplain BiFunction}, specify the entity class represented by the {@link
+ * #propertyPath()} as the second type parameter. For the first and third type parameters, specify
+ * the source entity class associated with the entity class given in the second type parameter.
+ *
+ * <pre>
+ * &#064;AggregateStrategy(root = Department.class, tableAlias = "d")
+ * interface DepartmentStrategy {
+ *
+ *     &#064;AssociationLinker(propertyPath = "employeeList", tableAlias = "e")
+ *     BiFunction&lt;Department, Employee, Department&gt; employeeList = (d, e) -> {
+ *         d.getEmployeeList().add(e);
+ *         e.setDepartment(d);
+ *         return d;
+ *     };
+ *
+ *     &#064;AssociationLinker(propertyPath = "employeeList.address", tableAlias = "a")
+ *     BiFunction&lt;Employee, Address, Employee&gt; employeeListAddress = (e, a) -> {
+ *         e.setAddress(a);
+ *         return e;
+ *     };
+ * }
+ * </pre>
+ */
+@Target(java.lang.annotation.ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface AssociationLinker {
+  /**
+   * Specifies the property path from the root entity using dot notation.
+   *
+   * <p>For example, suppose the root {@code Department} class has a property {@code List<Employee>
+   * employeeList}, and {@code Employee} has a property {@code Address address}. In this case, the
+   * property path representing {@code address} would be {@code employeeList.address}.
+   *
+   * @return the property path as a string
+   */
+  String propertyPath();
+
+  /**
+   * Specifies the table alias for the entity class represented by the {@link #propertyPath()}.
+   *
+   * <p>For example, consider the following SQL:
+   *
+   * <pre>
+   * SELECT * FROM DEPARTMENT d INNER JOIN EMPLOYEE e ON d.DEPARTMENT_ID = e.DEPARTMENT_ID
+   * </pre>
+   *
+   * In this case, the {@code Employee} class corresponds to the {@code EMPLOYEE} table, and its
+   * table alias is {@code e}.
+   *
+   * <p>The table alias concatenated with an underscore serves as the prefix for column aliases.
+   *
+   * @return the table alias as a string
+   */
+  String tableAlias();
+}

doma-core/src/main/java/org/seasar/doma/Select.java

@@ -163,4 +163,13 @@
    * @return the output format of SQL logs.
    */
   SqlLogType sqlLog() default SqlLogType.FORMATTED;
+
+  /**
+   * Defines how an aggregate is constructed.
+   *
+   * <p>Specifies the interface annotated with {@link AggregateStrategy}.
+   *
+   * @return the class representing the aggregation strategy, or {@code Void.class} if not specified
+   */
+  Class<?> aggregateStrategy() default Void.class;
 }

doma-core/src/main/java/org/seasar/doma/internal/ClassNames.java

@@ -64,6 +64,12 @@ public static ClassName newEntityMetamodelClassNameBuilder(
     return new MetamodelClassNameBuilder(entityClassName, metamodelPrefix, metamodelSuffix).build();
   }
 
+  public static ClassName newAggregateStrategyTypeClassName(
+      CharSequence aggregateStrategyClassName) {
+    assertNotNull(aggregateStrategyClassName);
+    return new ClassNameBuilder(aggregateStrategyClassName).build();
+  }
+
   private static class ClassNameBuilder {
 
     final String binaryName;

doma-core/src/main/java/org/seasar/doma/internal/jdbc/command/ColumnNameMapFormatter.java

@@ -0,0 +1,44 @@
+/*
+ * 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.internal.jdbc.command;
+
+import java.util.Map;
+import java.util.Objects;
+import java.util.TreeMap;
+
+class ColumnNameMapFormatter {
+  static String format(Map<String, MappingSupport.PropType> columnNameMap) {
+    Objects.requireNonNull(columnNameMap);
+
+    StringBuilder buf = new StringBuilder();
+    buf.append("------------------------------------------------------\n");
+    buf.append("Lowercase Column Name -> Property Name (Entity Name)\n");
+    buf.append("------------------------------------------------------\n");
+    TreeMap<String, MappingSupport.PropType> sortedMap = new TreeMap<>(columnNameMap);
+    for (Map.Entry<String, MappingSupport.PropType> entry : sortedMap.entrySet()) {
+      String columnName = entry.getKey();
+      MappingSupport.PropType propType = entry.getValue();
+      buf.append(columnName);
+      buf.append(" -> ");
+      buf.append(propType.name());
+      buf.append(" (");
+      buf.append(propType.entityType().getName());
+      buf.append(")\n");
+    }
+    buf.append("------------------------------------------------------");
+    return buf.toString();
+  }
+}

doma-core/src/main/java/org/seasar/doma/internal/jdbc/command/EntityProvider.java

@@ -27,6 +27,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.stream.Collectors;
 import org.seasar.doma.jdbc.DuplicateColumnHandler;
 import org.seasar.doma.jdbc.JdbcMappingVisitor;
 import org.seasar.doma.jdbc.Naming;
@@ -52,6 +53,8 @@ public class EntityProvider<ENTITY> extends AbstractObjectProvider<ENTITY> {
 
   protected final DuplicateColumnHandler duplicateColumnHandler;
 
+  private final MappingSupport mappingSupport;
+
   protected Map<Integer, EntityPropertyType<ENTITY, ?>> indexMap;
 
   public EntityProvider(EntityType<ENTITY> entityType, Query query, boolean resultMappingEnsured) {
@@ -62,6 +65,9 @@ public EntityProvider(EntityType<ENTITY> entityType, Query query, boolean result
     this.jdbcMappingVisitor = query.getConfig().getDialect().getJdbcMappingVisitor();
     this.unknownColumnHandler = query.getConfig().getUnknownColumnHandler();
     this.duplicateColumnHandler = query.getConfig().getDuplicateColumnHandler();
+    this.mappingSupport =
+        new MappingSupport(
+            entityType, query, resultMappingEnsured, unknownColumnHandler, duplicateColumnHandler);
   }
 
   @Override
@@ -72,7 +78,7 @@ public ENTITY get(ResultSet resultSet) throws SQLException {
   protected ENTITY build(ResultSet resultSet) throws SQLException {
     assertNotNull(resultSet);
     if (indexMap == null) {
-      indexMap = createIndexMap(resultSet.getMetaData(), entityType);
+      indexMap = createIndexMap(resultSet.getMetaData());
     }
     Map<String, Property<ENTITY, ?>> states = new HashMap<>(indexMap.size());
     for (Map.Entry<Integer, EntityPropertyType<ENTITY, ?>> entry : indexMap.entrySet()) {
@@ -89,6 +95,8 @@ protected ENTITY build(ResultSet resultSet) throws SQLException {
     return entity;
   }
 
+  @SuppressWarnings("removal")
+  @Deprecated(forRemoval = true)
   protected HashMap<Integer, EntityPropertyType<ENTITY, ?>> createIndexMap(
       ResultSetMetaData resultSetMeta, EntityType<ENTITY> entityType) throws SQLException {
     HashMap<Integer, EntityPropertyType<ENTITY, ?>> indexMap = new HashMap<>();
@@ -120,6 +128,19 @@ protected ENTITY build(ResultSet resultSet) throws SQLException {
     return indexMap;
   }
 
+  @SuppressWarnings("unchecked")
+  private Map<Integer, EntityPropertyType<ENTITY, ?>> createIndexMap(
+      ResultSetMetaData resultSetMeta) throws SQLException {
+    Map<String, MappingSupport.PropType> columnNameMap = createColumnNameMap();
+    return indexMap =
+        mappingSupport.createIndexMap(resultSetMeta, columnNameMap).entrySet().stream()
+            .collect(
+                Collectors.toMap(
+                    Map.Entry::getKey,
+                    e -> (EntityPropertyType<ENTITY, ?>) e.getValue().propertyType()));
+  }
+
+  @Deprecated
   protected HashMap<String, EntityPropertyType<ENTITY, ?>> createColumnNameMap(
       EntityType<ENTITY> entityType) {
     Naming naming = query.getConfig().getNaming();
@@ -132,6 +153,19 @@ protected ENTITY build(ResultSet resultSet) throws SQLException {
     return result;
   }
 
+  private HashMap<String, MappingSupport.PropType> createColumnNameMap() {
+    Naming naming = query.getConfig().getNaming();
+    List<EntityPropertyType<ENTITY, ?>> propertyTypes = entityType.getEntityPropertyTypes();
+    HashMap<String, MappingSupport.PropType> result = new HashMap<>(propertyTypes.size());
+    for (EntityPropertyType<ENTITY, ?> propertyType : propertyTypes) {
+      String columnName = propertyType.getColumnName(naming::apply);
+      result.put(
+          columnName.toLowerCase(), new MappingSupport.PropType(entityType, propertyType, ""));
+    }
+    return result;
+  }
+
+  @Deprecated(forRemoval = true)
   protected void throwResultMappingException(
       Set<EntityPropertyType<ENTITY, ?>> unmappedPropertySet) {
     Naming naming = query.getConfig().getNaming();