Add the select and the selectTo methods to the Entityql and NativeSql DSLs

Author: nakamura-to

doma-core/src/main/java/org/seasar/doma/jdbc/criteria/Entityql.java

@@ -18,7 +18,7 @@
 import org.seasar.doma.jdbc.criteria.statement.EntityqlBatchUpdateStatement;
 import org.seasar.doma.jdbc.criteria.statement.EntityqlDeleteStatement;
 import org.seasar.doma.jdbc.criteria.statement.EntityqlInsertStatement;
-import org.seasar.doma.jdbc.criteria.statement.EntityqlSelectStatement;
+import org.seasar.doma.jdbc.criteria.statement.EntityqlSelectStarting;
 import org.seasar.doma.jdbc.criteria.statement.EntityqlUpdateStatement;
 import org.seasar.doma.jdbc.criteria.statement.Statement;
 
@@ -30,19 +30,19 @@ public Entityql(Config config) {
     this.config = Objects.requireNonNull(config);
   }
 
-  public <ENTITY> EntityqlSelectStatement<ENTITY> from(EntityMetamodel<ENTITY> entityMetamodel) {
+  public <ENTITY> EntityqlSelectStarting<ENTITY> from(EntityMetamodel<ENTITY> entityMetamodel) {
     Objects.requireNonNull(entityMetamodel);
     return from(entityMetamodel, settings -> {});
   }
 
-  public <ENTITY> EntityqlSelectStatement<ENTITY> from(
+  public <ENTITY> EntityqlSelectStarting<ENTITY> from(
       EntityMetamodel<ENTITY> entityMetamodel, Consumer<SelectSettings> settingsConsumer) {
     Objects.requireNonNull(entityMetamodel);
     Objects.requireNonNull(settingsConsumer);
     SelectContext context = new SelectContext(entityMetamodel);
     settingsConsumer.accept(context.getSettings());
     SelectFromDeclaration declaration = new SelectFromDeclaration(context);
-    return new EntityqlSelectStatement<>(config, declaration);
+    return new EntityqlSelectStarting<>(config, declaration, entityMetamodel);
   }
 
   public <ENTITY> Statement<Result<ENTITY>> update(

doma-core/src/main/java/org/seasar/doma/jdbc/criteria/command/AssociateCommand.java

@@ -19,19 +19,22 @@
 public class AssociateCommand<ENTITY> implements Command<List<ENTITY>> {
   private final SelectContext context;
   private final SelectQuery query;
+  private final EntityMetamodel<ENTITY> entityMetamodel;
 
-  public AssociateCommand(SelectContext context, SelectQuery query) {
+  public AssociateCommand(
+      SelectContext context, SelectQuery query, EntityMetamodel<ENTITY> entityMetamodel) {
     this.context = Objects.requireNonNull(context);
     this.query = Objects.requireNonNull(query);
+    this.entityMetamodel = Objects.requireNonNull(entityMetamodel);
   }
 
   @Override
   @SuppressWarnings("unchecked")
   public List<ENTITY> execute() {
     Map<EntityKey, Object> cache = new LinkedHashMap<>();
-    List<EntityMetamodel<?>> entityMetamodels = context.allEntityDefs();
     SelectCommand<List<EntityPool>> command =
-        new SelectCommand<>(query, new EntityPoolIterationHandler(entityMetamodels));
+        new SelectCommand<>(
+            query, new EntityPoolIterationHandler(context.getProjectionEntityMetamodels()));
     List<EntityPool> entityPools = command.execute();
     for (EntityPool entityPool : entityPools) {
       Map<EntityMetamodel<?>, Object> associationCandidate = new LinkedHashMap<>();
@@ -56,7 +59,7 @@ public List<ENTITY> execute() {
     }
     return (List<ENTITY>)
         cache.entrySet().stream()
-            .filter(e -> e.getKey().getEntityMetamodel() == context.entityMetamodel)
+            .filter(e -> e.getKey().getEntityMetamodel() == entityMetamodel)
             .map(Map.Entry::getValue)
             .collect(toList());
   }

doma-core/src/main/java/org/seasar/doma/jdbc/criteria/command/DataRow.java

@@ -1,11 +1,15 @@
 package org.seasar.doma.jdbc.criteria.command;
 
+import java.util.List;
 import org.seasar.doma.jdbc.criteria.metamodel.EntityMetamodel;
 import org.seasar.doma.jdbc.criteria.metamodel.PropertyMetamodel;
 
 public interface DataRow {
 
   <ENTITY> ENTITY get(EntityMetamodel<ENTITY> entityEntityMetamodel);
 
+  <ENTITY> ENTITY get(
+      EntityMetamodel<ENTITY> entityEntityMetamodel, List<PropertyMetamodel<?>> propertyMetamodels);
+
   <PROPERTY> PROPERTY get(PropertyMetamodel<PROPERTY> propertyMetamodel);
 }

doma-core/src/main/java/org/seasar/doma/jdbc/criteria/command/EntityPoolIterationHandler.java

@@ -1,24 +1,27 @@
 package org.seasar.doma.jdbc.criteria.command;
 
 import java.util.List;
+import java.util.Map;
 import java.util.Objects;
 import org.seasar.doma.internal.jdbc.command.AbstractIterationHandler;
 import org.seasar.doma.internal.jdbc.command.ResultListCallback;
 import org.seasar.doma.jdbc.ObjectProvider;
 import org.seasar.doma.jdbc.criteria.metamodel.EntityMetamodel;
+import org.seasar.doma.jdbc.criteria.metamodel.PropertyMetamodel;
 import org.seasar.doma.jdbc.query.SelectQuery;
 
 public class EntityPoolIterationHandler
     extends AbstractIterationHandler<EntityPool, List<EntityPool>> {
-  private final List<EntityMetamodel<?>> entityMetamodels;
+  private final Map<EntityMetamodel<?>, List<PropertyMetamodel<?>>> projectionEntityMetamodels;
 
-  public EntityPoolIterationHandler(List<EntityMetamodel<?>> entityMetamodels) {
+  public EntityPoolIterationHandler(
+      Map<EntityMetamodel<?>, List<PropertyMetamodel<?>>> projectionEntityMetamodels) {
     super(new ResultListCallback<>());
-    this.entityMetamodels = Objects.requireNonNull(entityMetamodels);
+    this.projectionEntityMetamodels = Objects.requireNonNull(projectionEntityMetamodels);
   }
 
   @Override
   protected ObjectProvider<EntityPool> createObjectProvider(SelectQuery query) {
-    return new EntityPoolProvider(entityMetamodels, query);
+    return new EntityPoolProvider(projectionEntityMetamodels, query);
   }
 }

doma-core/src/main/java/org/seasar/doma/jdbc/criteria/command/EntityPoolProvider.java

@@ -12,17 +12,19 @@
 import java.util.stream.Collectors;
 import org.seasar.doma.jdbc.ObjectProvider;
 import org.seasar.doma.jdbc.criteria.metamodel.EntityMetamodel;
+import org.seasar.doma.jdbc.criteria.metamodel.PropertyMetamodel;
 import org.seasar.doma.jdbc.entity.EntityPropertyType;
 import org.seasar.doma.jdbc.entity.EntityType;
 import org.seasar.doma.jdbc.entity.Property;
 import org.seasar.doma.jdbc.query.Query;
 
 public class EntityPoolProvider implements ObjectProvider<EntityPool> {
-  private final List<EntityMetamodel<?>> entityMetamodels;
+  private final Map<EntityMetamodel<?>, List<PropertyMetamodel<?>>> projectionEntityMetamodels;
   private final FetchSupport fetchSupport;
 
-  public EntityPoolProvider(List<EntityMetamodel<?>> entityMetamodels, Query query) {
-    this.entityMetamodels = Objects.requireNonNull(entityMetamodels);
+  public EntityPoolProvider(
+      Map<EntityMetamodel<?>, List<PropertyMetamodel<?>>> projectionEntityMetamodels, Query query) {
+    this.projectionEntityMetamodels = Objects.requireNonNull(projectionEntityMetamodels);
     Objects.requireNonNull(query);
     this.fetchSupport = new FetchSupport(query);
   }
@@ -33,9 +35,13 @@ public EntityPool get(ResultSet resultSet) throws SQLException {
     Objects.requireNonNull(resultSet);
     EntityPool entityPool = new EntityPool();
     int index = 1;
-    for (EntityMetamodel<?> entityMetamodel : entityMetamodels) {
+    for (Map.Entry<EntityMetamodel<?>, List<PropertyMetamodel<?>>> entry :
+        projectionEntityMetamodels.entrySet()) {
+      EntityMetamodel<?> entityMetamodel = entry.getKey();
+      List<PropertyMetamodel<?>> projectionTargets = entry.getValue();
       EntityType<?> entityType = entityMetamodel.asType();
-      List<? extends EntityPropertyType<?, ?>> propertyTypes = entityType.getEntityPropertyTypes();
+      List<? extends EntityPropertyType<?, ?>> propertyTypes =
+          projectionTargets.stream().map(PropertyMetamodel::asType).collect(toList());
       List<Prop> props = new ArrayList<>(propertyTypes.size());
       for (EntityPropertyType<?, ?> propertyType : propertyTypes) {
         Property<Object, ?> property = (Property<Object, ?>) propertyType.createProperty();

doma-core/src/main/java/org/seasar/doma/jdbc/criteria/command/MappedResultProvider.java

@@ -35,7 +35,13 @@ public RESULT get(ResultSet resultSet) throws SQLException {
 
           @Override
           public <ENTITY> ENTITY get(EntityMetamodel<ENTITY> entityMetamodel) {
-            List<PropertyMetamodel<?>> propertyMetamodels = entityMetamodel.allPropertyMetamodels();
+            return get(entityMetamodel, entityMetamodel.allPropertyMetamodels());
+          }
+
+          @Override
+          public <ENTITY> ENTITY get(
+              EntityMetamodel<ENTITY> entityMetamodel,
+              List<PropertyMetamodel<?>> propertyMetamodels) {
             Map<String, Property<ENTITY, ?>> states = new HashMap<>(propertyMetamodels.size());
             List<Object> rawValues = new ArrayList<>(propertyMetamodels.size());
             for (PropertyMetamodel<?> propertyMetamodel : propertyMetamodels) {

doma-core/src/main/java/org/seasar/doma/jdbc/criteria/context/Projection.java

@@ -2,31 +2,47 @@
 
 import java.util.Arrays;
 import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
 import java.util.Objects;
+import org.seasar.doma.jdbc.criteria.metamodel.EntityMetamodel;
 import org.seasar.doma.jdbc.criteria.metamodel.PropertyMetamodel;
 
 public interface Projection {
-  All All = new All() {};
 
   <R> R accept(Visitor<R> visitor);
 
-  class All implements Projection {
-    private All() {}
+  class EntityMetamodels implements Projection {
+    public final Map<EntityMetamodel<?>, java.util.List<PropertyMetamodel<?>>> map =
+        new LinkedHashMap<>();
+
+    public EntityMetamodels(EntityMetamodel<?> entityMetamodel) {
+      Objects.requireNonNull(entityMetamodel);
+      map.put(entityMetamodel, entityMetamodel.allPropertyMetamodels());
+    }
+
+    public EntityMetamodels(
+        EntityMetamodel<?> entityMetamodel,
+        java.util.List<PropertyMetamodel<?>> propertyMetamodels) {
+      Objects.requireNonNull(entityMetamodel);
+      Objects.requireNonNull(propertyMetamodels);
+      map.put(entityMetamodel, Collections.unmodifiableList(propertyMetamodels));
+    }
 
     @Override
     public <R> R accept(Visitor<R> visitor) {
       return visitor.visit(this);
     }
   }
 
-  class List implements Projection {
+  class PropertyMetamodels implements Projection {
     public final java.util.List<PropertyMetamodel<?>> propertyMetamodels;
 
-    public List(PropertyMetamodel<?>... propertyMetamodels) {
+    public PropertyMetamodels(PropertyMetamodel<?>... propertyMetamodels) {
       this(Arrays.asList(propertyMetamodels));
     }
 
-    public List(java.util.List<PropertyMetamodel<?>> propertyMetamodels) {
+    public PropertyMetamodels(java.util.List<PropertyMetamodel<?>> propertyMetamodels) {
       Objects.requireNonNull(propertyMetamodels);
       this.propertyMetamodels = Collections.unmodifiableList(propertyMetamodels);
     }
@@ -38,8 +54,8 @@ public <R> R accept(Visitor<R> visitor) {
   }
 
   interface Visitor<R> {
-    R visit(All all);
+    R visit(EntityMetamodels entityMetamodels);
 
-    R visit(List list);
+    R visit(PropertyMetamodels propertyMetamodels);
   }
 }

doma-core/src/main/java/org/seasar/doma/jdbc/criteria/context/SelectContext.java

@@ -3,6 +3,7 @@
 import static java.util.stream.Collectors.toList;
 
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
@@ -17,7 +18,7 @@
 
 public class SelectContext implements Context {
   public final EntityMetamodel<?> entityMetamodel;
-  public Projection projection = Projection.All;
+  public Projection projection;
   public DistinctOption distinct = DistinctOption.none();
   public final List<Join> joins = new ArrayList<>();
   public List<Criterion> where = new ArrayList<>();
@@ -33,6 +34,7 @@ public class SelectContext implements Context {
 
   public SelectContext(EntityMetamodel<?> entityMetamodel) {
     this.entityMetamodel = Objects.requireNonNull(entityMetamodel);
+    this.projection = new Projection.EntityMetamodels(entityMetamodel);
   }
 
   @Override
@@ -50,29 +52,48 @@ public SelectSettings getSettings() {
     return settings;
   }
 
-  public List<EntityMetamodel<?>> allEntityDefs() {
-    Stream<EntityMetamodel<?>> a = Stream.of(entityMetamodel);
-    Stream<EntityMetamodel<?>> b =
-        associations.keySet().stream().flatMap(pair -> Stream.of(pair.fst, pair.snd));
-    return Stream.concat(a, b).distinct().collect(toList());
+  public Map<EntityMetamodel<?>, List<PropertyMetamodel<?>>> getProjectionEntityMetamodels() {
+    return projection.accept(
+        new Projection.Visitor<Map<EntityMetamodel<?>, List<PropertyMetamodel<?>>>>() {
+          @Override
+          public Map<EntityMetamodel<?>, List<PropertyMetamodel<?>>> visit(
+              Projection.EntityMetamodels entityMetamodels) {
+            Map<EntityMetamodel<?>, List<PropertyMetamodel<?>>> map =
+                new LinkedHashMap<>(entityMetamodels.map);
+            associations.keySet().stream()
+                .flatMap(pair -> Stream.of(pair.fst, pair.snd))
+                .forEach(
+                    it -> {
+                      if (!map.containsKey(it)) {
+                        map.put(it, it.allPropertyMetamodels());
+                      }
+                    });
+            return map;
+          }
+
+          @Override
+          public Map<EntityMetamodel<?>, List<PropertyMetamodel<?>>> visit(
+              Projection.PropertyMetamodels propertyMetamodels) {
+            throw new IllegalStateException();
+          }
+        });
   }
 
-  public List<PropertyMetamodel<?>> allPropertyMetamodels() {
+  public List<PropertyMetamodel<?>> getProjectionPropertyMetamodels() {
     return projection.accept(
         new Projection.Visitor<List<PropertyMetamodel<?>>>() {
+
           @Override
-          public List<PropertyMetamodel<?>> visit(Projection.All all) {
-            return allEntityDefs().stream()
-                .flatMap(it -> it.allPropertyMetamodels().stream())
+          public List<PropertyMetamodel<?>> visit(Projection.EntityMetamodels entityMetamodels) {
+            return getProjectionEntityMetamodels().values().stream()
+                .flatMap(Collection::stream)
                 .collect(toList());
           }
 
           @Override
-          public List<PropertyMetamodel<?>> visit(Projection.List list) {
-            if (list.propertyMetamodels.isEmpty()) {
-              return visit(Projection.All);
-            }
-            return list.propertyMetamodels;
+          public List<PropertyMetamodel<?>> visit(
+              Projection.PropertyMetamodels propertyMetamodels) {
+            return propertyMetamodels.propertyMetamodels;
           }
         });
   }

doma-core/src/main/java/org/seasar/doma/jdbc/criteria/declaration/SelectFromDeclaration.java

@@ -1,8 +1,11 @@
 package org.seasar.doma.jdbc.criteria.declaration;
 
+import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Objects;
+import java.util.Set;
 import java.util.function.BiConsumer;
 import java.util.function.Consumer;
 import org.seasar.doma.DomaException;
@@ -17,6 +20,8 @@
 import org.seasar.doma.jdbc.criteria.option.AssociationOption;
 import org.seasar.doma.jdbc.criteria.option.DistinctOption;
 import org.seasar.doma.jdbc.criteria.option.ForUpdateOption;
+import org.seasar.doma.jdbc.entity.EntityPropertyType;
+import org.seasar.doma.jdbc.entity.EntityType;
 import org.seasar.doma.message.Message;
 
 public class SelectFromDeclaration {
@@ -99,9 +104,41 @@ public void select(List<PropertyMetamodel<?>> propertyMetamodels) {
     Objects.requireNonNull(propertyMetamodels);
     int i = 0;
     for (PropertyMetamodel<?> propertyMetamodel : propertyMetamodels) {
-      Objects.requireNonNull(propertyMetamodels, "propertyMetamodels: " + i);
+      Objects.requireNonNull(propertyMetamodel, "propertyMetamodels: " + i);
     }
-    context.projection = new Projection.List(propertyMetamodels);
+    context.projection = new Projection.PropertyMetamodels(propertyMetamodels);
+  }
+
+  public void select(EntityMetamodel<?> entityMetamodel) {
+    Objects.requireNonNull(entityMetamodel);
+    if (!context.getEntityMetamodels().contains(entityMetamodel)) {
+      throw new DomaException(Message.DOMA6009, "entityMetamodel");
+    }
+    context.projection = new Projection.EntityMetamodels(entityMetamodel);
+  }
+
+  public void selectTo(
+      EntityMetamodel<?> entityMetamodel, List<PropertyMetamodel<?>> propertyMetamodels) {
+    Objects.requireNonNull(propertyMetamodels);
+    if (!context.getEntityMetamodels().contains(entityMetamodel)) {
+      throw new DomaException(Message.DOMA6007, "entityMetamodel");
+    }
+    int i = 0;
+    for (PropertyMetamodel<?> propertyMetamodel : propertyMetamodels) {
+      Objects.requireNonNull(propertyMetamodel, "propertyMetamodels: " + i);
+      if (!entityMetamodel.allPropertyMetamodels().contains(propertyMetamodel)) {
+        throw new DomaException(Message.DOMA6008, i);
+      }
+    }
+    Set<PropertyMetamodel<?>> projectionTargets = new LinkedHashSet<>();
+    EntityType<?> entityType = entityMetamodel.asType();
+    List<? extends EntityPropertyType<?, ?>> idPropertyTypes = entityType.getIdPropertyTypes();
+    entityMetamodel.allPropertyMetamodels().stream()
+        .filter(it -> idPropertyTypes.contains(it.asType()))
+        .forEach(projectionTargets::add);
+    projectionTargets.addAll(propertyMetamodels);
+    context.projection =
+        new Projection.EntityMetamodels(entityMetamodel, new ArrayList<>(projectionTargets));
   }
 
   @SuppressWarnings("unchecked")