Add the "avgAsDouble" aggregate function (#605)

Author: nakamura-to

docs/criteria-api.rst

@@ -824,6 +824,7 @@ Aggregate Functions (NativeSql)
 We support the following aggregate functions:
 
 * avg(property)
+* avgAsDouble(property)
 * count()
 * count(property)
 * countDistinct(property)

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

@@ -69,6 +69,31 @@ public void accept(PropertyMetamodel.Visitor visitor) {
     }
   }
 
+  class AvgAsDouble extends AbstractFunction<Double> {
+
+    public AvgAsDouble(PropertyMetamodel<?> argument) {
+      super("avg", argument);
+    }
+
+    @Override
+    public Class<?> asClass() {
+      return Double.class;
+    }
+
+    @Override
+    public EntityPropertyType<?, Double> asType() {
+      return new DoublePropertyType(null);
+    }
+
+    @Override
+    public void accept(PropertyMetamodel.Visitor visitor) {
+      if (visitor instanceof AggregateFunction.Visitor) {
+        AggregateFunction.Visitor v = (AggregateFunction.Visitor) visitor;
+        v.visit(this);
+      }
+    }
+  }
+
   class Count extends AbstractFunction<Long> {
 
     public final boolean distinct;
@@ -176,6 +201,8 @@ public void accept(Visitor visitor) {
   interface Visitor {
     void visit(AggregateFunction.Avg<?> avg);
 
+    void visit(AggregateFunction.AvgAsDouble avg);
+
     void visit(AggregateFunction.Count count);
 
     void visit(AggregateFunction.Max<?> max);

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

@@ -239,6 +239,11 @@ public static <PROPERTY> AggregateFunction.Avg<PROPERTY> avg(
     return new AggregateFunction.Avg<>(propertyMetamodel);
   }
 
+  public static AggregateFunction.AvgAsDouble avgAsDouble(PropertyMetamodel<?> propertyMetamodel) {
+    Objects.requireNonNull(propertyMetamodel);
+    return new AggregateFunction.AvgAsDouble(propertyMetamodel);
+  }
+
   public static AggregateFunction.Count count() {
     return new AggregateFunction.Count(AggregateFunction.Asterisk);
   }

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

@@ -562,6 +562,11 @@ public void visit(AggregateFunction.Avg<?> avg) {
       oneArgumentFunction(avg.getName(), avg.argument());
     }
 
+    @Override
+    public void visit(AggregateFunction.AvgAsDouble avg) {
+      oneArgumentFunction(avg.getName(), avg.argument());
+    }
+
     @Override
     public void visit(AggregateFunction.Count count) {
       buf.appendSql(count.getName());

doma-core/src/test/java/org/seasar/doma/jdbc/criteria/NativeSqlSelectTest.java

@@ -3,6 +3,7 @@
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.seasar.doma.jdbc.criteria.expression.Expressions.avg;
+import static org.seasar.doma.jdbc.criteria.expression.Expressions.avgAsDouble;
 import static org.seasar.doma.jdbc.criteria.expression.Expressions.concat;
 import static org.seasar.doma.jdbc.criteria.expression.Expressions.count;
 import static org.seasar.doma.jdbc.criteria.expression.Expressions.countDistinct;
@@ -1384,4 +1385,20 @@ void expression_select() {
     Sql<?> sql = stmt.asSql();
     assertEquals("select (select t1_.ID from EMP t1_) from EMP t0_", sql.getRawSql());
   }
+
+  @Test
+  void expression_avg() {
+    Emp_ e = new Emp_();
+    Buildable<?> stmt = nativeSql.from(e).select(avg(e.salary));
+    Sql<?> sql = stmt.asSql();
+    assertEquals("select avg(t0_.SALARY) from EMP t0_", sql.getFormattedSql());
+  }
+
+  @Test
+  void expression_avgAsDouble() {
+    Emp_ e = new Emp_();
+    Buildable<?> stmt = nativeSql.from(e).select(avgAsDouble(e.salary));
+    Sql<?> sql = stmt.asSql();
+    assertEquals("select avg(t0_.SALARY) from EMP t0_", sql.getFormattedSql());
+  }
 }

doma-core/src/test/java/org/seasar/doma/jdbc/criteria/expression/ExpressionsTest.java

@@ -5,6 +5,7 @@
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.seasar.doma.jdbc.criteria.expression.Expressions.add;
 import static org.seasar.doma.jdbc.criteria.expression.Expressions.avg;
+import static org.seasar.doma.jdbc.criteria.expression.Expressions.avgAsDouble;
 import static org.seasar.doma.jdbc.criteria.expression.Expressions.concat;
 import static org.seasar.doma.jdbc.criteria.expression.Expressions.count;
 import static org.seasar.doma.jdbc.criteria.expression.Expressions.div;
@@ -161,7 +162,18 @@ void testAvg() {
     assertNotEquals(avg(e.id), max(e.id));
 
     assertEquals("avg", avg(e.id).getName());
-    assertEquals(e.id, count(e.id).argument());
+    assertEquals(e.id, avg(e.id).argument());
+  }
+
+  @SuppressWarnings("AssertBetweenInconvertibleTypes")
+  @Test
+  void testAvgAsDouble() {
+    assertEquals(avgAsDouble(e.id), avgAsDouble(e.id));
+    assertNotEquals(avgAsDouble(e.id), avgAsDouble(e.name));
+    assertNotEquals(avgAsDouble(e.id), max(e.id));
+
+    assertEquals("avg", avgAsDouble(e.id).getName());
+    assertEquals(e.id, avgAsDouble(e.id).argument());
   }
 
   @SuppressWarnings("AssertBetweenInconvertibleTypes")

doma-kotlin/src/main/kotlin/org/seasar/doma/jdbc/criteria/expression/KExpressions.kt

@@ -2,6 +2,7 @@ package org.seasar.doma.jdbc.criteria.expression
 
 import org.seasar.doma.jdbc.criteria.context.SubSelectContext
 import org.seasar.doma.jdbc.criteria.expression.AggregateFunction.Avg
+import org.seasar.doma.jdbc.criteria.expression.AggregateFunction.AvgAsDouble
 import org.seasar.doma.jdbc.criteria.expression.AggregateFunction.Max
 import org.seasar.doma.jdbc.criteria.expression.AggregateFunction.Min
 import org.seasar.doma.jdbc.criteria.expression.AggregateFunction.Sum
@@ -235,6 +236,12 @@ object KExpressions {
         return Expressions.avg(propertyMetamodel)
     }
 
+    fun avgAsDouble(
+        propertyMetamodel: PropertyMetamodel<*>
+    ): AvgAsDouble {
+        return Expressions.avgAsDouble(propertyMetamodel)
+    }
+
     fun count(): AggregateFunction.Count {
         return Expressions.count()
     }