From e70ea18c396690099265cc2a9141944aac8fe0af Mon Sep 17 00:00:00 2001 From: Jeff Butler Date: Tue, 15 Sep 2020 14:23:07 -0400 Subject: [PATCH 1/7] Polishing the Array example --- src/test/java/examples/array/NamesTableDynamicSqlSupport.java | 3 ++- src/test/java/examples/array/StringArrayTypeHandler.java | 2 +- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/src/test/java/examples/array/NamesTableDynamicSqlSupport.java b/src/test/java/examples/array/NamesTableDynamicSqlSupport.java index 04deabd17..747a3645b 100644 --- a/src/test/java/examples/array/NamesTableDynamicSqlSupport.java +++ b/src/test/java/examples/array/NamesTableDynamicSqlSupport.java @@ -30,6 +30,7 @@ public NamesTable() { super("NamesTable"); } public final SqlColumn id = column("id", JDBCType.INTEGER); - public final SqlColumn names = column("names", JDBCType.ARRAY); + public final SqlColumn names = column("names", JDBCType.ARRAY, + "examples.array.StringArrayTypeHandler"); } } diff --git a/src/test/java/examples/array/StringArrayTypeHandler.java b/src/test/java/examples/array/StringArrayTypeHandler.java index db9a8e6b1..0b85fcc23 100644 --- a/src/test/java/examples/array/StringArrayTypeHandler.java +++ b/src/test/java/examples/array/StringArrayTypeHandler.java @@ -30,7 +30,7 @@ public class StringArrayTypeHandler extends BaseTypeHandler { @Override public void setNonNullParameter(PreparedStatement ps, int i, String[] parameter, JdbcType jdbcType) throws SQLException { - Array array = ps.getConnection().createArrayOf("CHAR", parameter); + Array array = ps.getConnection().createArrayOf("VARCHAR", parameter); ps.setArray(i, array); array.free(); } From 0f5f5472c7c9d1cd13f004dab4e2b5e037f95e88 Mon Sep 17 00:00:00 2001 From: Jeff Butler Date: Tue, 15 Sep 2020 16:18:31 -0400 Subject: [PATCH 2/7] Initial conversion of aggregates to functions --- .../org/mybatis/dynamic/sql/SqlBuilder.java | 8 +++---- .../dynamic/sql/select/aggregate/Avg.java | 22 ++++++++++--------- .../dynamic/sql/select/aggregate/Max.java | 22 ++++++++++--------- .../dynamic/sql/select/aggregate/Min.java | 22 ++++++++++--------- .../dynamic/sql/select/aggregate/Sum.java | 22 ++++++++++--------- 5 files changed, 52 insertions(+), 44 deletions(-) diff --git a/src/main/java/org/mybatis/dynamic/sql/SqlBuilder.java b/src/main/java/org/mybatis/dynamic/sql/SqlBuilder.java index 5bccd05eb..8152e6c93 100644 --- a/src/main/java/org/mybatis/dynamic/sql/SqlBuilder.java +++ b/src/main/java/org/mybatis/dynamic/sql/SqlBuilder.java @@ -331,19 +331,19 @@ static CountDistinct countDistinct(BasicColumn column) { return CountDistinct.of(column); } - static Max max(BasicColumn column) { + static Max max(BindableColumn column) { return Max.of(column); } - static Min min(BasicColumn column) { + static Min min(BindableColumn column) { return Min.of(column); } - static Avg avg(BasicColumn column) { + static Avg avg(BindableColumn column) { return Avg.of(column); } - static Sum sum(BasicColumn column) { + static Sum sum(BindableColumn column) { return Sum.of(column); } diff --git a/src/main/java/org/mybatis/dynamic/sql/select/aggregate/Avg.java b/src/main/java/org/mybatis/dynamic/sql/select/aggregate/Avg.java index 6c5fa85a8..4da9a100a 100644 --- a/src/main/java/org/mybatis/dynamic/sql/select/aggregate/Avg.java +++ b/src/main/java/org/mybatis/dynamic/sql/select/aggregate/Avg.java @@ -15,25 +15,27 @@ */ package org.mybatis.dynamic.sql.select.aggregate; -import org.mybatis.dynamic.sql.BasicColumn; +import org.mybatis.dynamic.sql.BindableColumn; +import org.mybatis.dynamic.sql.render.TableAliasCalculator; +import org.mybatis.dynamic.sql.select.function.AbstractUniTypeFunction; -public class Avg extends AbstractAggregate { +public class Avg extends AbstractUniTypeFunction> { - private Avg(BasicColumn column) { + private Avg(BindableColumn column) { super(column); } - + @Override - protected String render(String columnName) { - return "avg(" + columnName + ")"; //$NON-NLS-1$ //$NON-NLS-2$ + public String renderWithTableAlias(TableAliasCalculator tableAliasCalculator) { + return "avg(" + column.renderWithTableAlias(tableAliasCalculator) + ")"; //$NON-NLS-1$ //$NON-NLS-2$ } @Override - protected Avg copy() { - return new Avg(column); + protected Avg copy() { + return new Avg<>(column); } - public static Avg of(BasicColumn column) { - return new Avg(column); + public static Avg of(BindableColumn column) { + return new Avg<>(column); } } diff --git a/src/main/java/org/mybatis/dynamic/sql/select/aggregate/Max.java b/src/main/java/org/mybatis/dynamic/sql/select/aggregate/Max.java index 86bbce1de..0f6e4382c 100644 --- a/src/main/java/org/mybatis/dynamic/sql/select/aggregate/Max.java +++ b/src/main/java/org/mybatis/dynamic/sql/select/aggregate/Max.java @@ -15,25 +15,27 @@ */ package org.mybatis.dynamic.sql.select.aggregate; -import org.mybatis.dynamic.sql.BasicColumn; +import org.mybatis.dynamic.sql.BindableColumn; +import org.mybatis.dynamic.sql.render.TableAliasCalculator; +import org.mybatis.dynamic.sql.select.function.AbstractUniTypeFunction; -public class Max extends AbstractAggregate { +public class Max extends AbstractUniTypeFunction> { - private Max(BasicColumn column) { + private Max(BindableColumn column) { super(column); } - + @Override - protected String render(String columnName) { - return "max(" + columnName + ")"; //$NON-NLS-1$ //$NON-NLS-2$ + public String renderWithTableAlias(TableAliasCalculator tableAliasCalculator) { + return "max(" + column.renderWithTableAlias(tableAliasCalculator) + ")"; //$NON-NLS-1$ //$NON-NLS-2$; } @Override - protected Max copy() { - return new Max(column); + protected Max copy() { + return new Max(column); } - public static Max of(BasicColumn column) { - return new Max(column); + public static Max of(BindableColumn column) { + return new Max<>(column); } } diff --git a/src/main/java/org/mybatis/dynamic/sql/select/aggregate/Min.java b/src/main/java/org/mybatis/dynamic/sql/select/aggregate/Min.java index 97b2c6390..5e217e799 100644 --- a/src/main/java/org/mybatis/dynamic/sql/select/aggregate/Min.java +++ b/src/main/java/org/mybatis/dynamic/sql/select/aggregate/Min.java @@ -15,25 +15,27 @@ */ package org.mybatis.dynamic.sql.select.aggregate; -import org.mybatis.dynamic.sql.BasicColumn; +import org.mybatis.dynamic.sql.BindableColumn; +import org.mybatis.dynamic.sql.render.TableAliasCalculator; +import org.mybatis.dynamic.sql.select.function.AbstractUniTypeFunction; -public class Min extends AbstractAggregate { +public class Min extends AbstractUniTypeFunction> { - private Min(BasicColumn column) { + private Min(BindableColumn column) { super(column); } - + @Override - protected String render(String columnName) { - return "min(" + columnName + ")"; //$NON-NLS-1$ //$NON-NLS-2$ + public String renderWithTableAlias(TableAliasCalculator tableAliasCalculator) { + return "min(" + column.renderWithTableAlias(tableAliasCalculator) + ")"; //$NON-NLS-1$ //$NON-NLS-2$; } @Override - protected Min copy() { - return new Min(column); + protected Min copy() { + return new Min<>(column); } - public static Min of(BasicColumn column) { - return new Min(column); + public static Min of(BindableColumn column) { + return new Min<>(column); } } diff --git a/src/main/java/org/mybatis/dynamic/sql/select/aggregate/Sum.java b/src/main/java/org/mybatis/dynamic/sql/select/aggregate/Sum.java index c499c9832..2f651f591 100644 --- a/src/main/java/org/mybatis/dynamic/sql/select/aggregate/Sum.java +++ b/src/main/java/org/mybatis/dynamic/sql/select/aggregate/Sum.java @@ -15,25 +15,27 @@ */ package org.mybatis.dynamic.sql.select.aggregate; -import org.mybatis.dynamic.sql.BasicColumn; +import org.mybatis.dynamic.sql.BindableColumn; +import org.mybatis.dynamic.sql.render.TableAliasCalculator; +import org.mybatis.dynamic.sql.select.function.AbstractUniTypeFunction; -public class Sum extends AbstractAggregate { +public class Sum extends AbstractUniTypeFunction> { - private Sum(BasicColumn column) { + private Sum(BindableColumn column) { super(column); } - + @Override - protected String render(String columnName) { - return "sum(" + columnName + ")"; //$NON-NLS-1$ //$NON-NLS-2$ + public String renderWithTableAlias(TableAliasCalculator tableAliasCalculator) { + return "sum(" + column.renderWithTableAlias(tableAliasCalculator) + ")"; //$NON-NLS-1$ //$NON-NLS-2$; } @Override - protected Sum copy() { - return new Sum(column); + protected Sum copy() { + return new Sum<>(column); } - public static Sum of(BasicColumn column) { - return new Sum(column); + public static Sum of(BindableColumn column) { + return new Sum<>(column); } } From ff80a4f3cb92def6f03a2c2fe4694e608cf69d06 Mon Sep 17 00:00:00 2001 From: Jeff Butler Date: Tue, 15 Sep 2020 17:00:20 -0400 Subject: [PATCH 3/7] Count functions implement BindableColumn directly --- .../dynamic/sql/select/aggregate/Count.java | 43 +++++++++++++++---- .../sql/select/aggregate/CountAll.java | 24 +++++++---- .../sql/select/aggregate/CountDistinct.java | 43 +++++++++++++++---- 3 files changed, 84 insertions(+), 26 deletions(-) diff --git a/src/main/java/org/mybatis/dynamic/sql/select/aggregate/Count.java b/src/main/java/org/mybatis/dynamic/sql/select/aggregate/Count.java index 915ff31ab..f6704cfd2 100644 --- a/src/main/java/org/mybatis/dynamic/sql/select/aggregate/Count.java +++ b/src/main/java/org/mybatis/dynamic/sql/select/aggregate/Count.java @@ -15,24 +15,49 @@ */ package org.mybatis.dynamic.sql.select.aggregate; +import java.sql.JDBCType; +import java.util.Objects; +import java.util.Optional; + import org.mybatis.dynamic.sql.BasicColumn; +import org.mybatis.dynamic.sql.BindableColumn; +import org.mybatis.dynamic.sql.render.TableAliasCalculator; + +public class Count implements BindableColumn { + + private final BasicColumn column; + private final String alias; -public class Count extends AbstractAggregate { - private Count(BasicColumn column) { - super(column); + this.column = Objects.requireNonNull(column); + alias = null; } - + + private Count(BasicColumn column, String alias) { + this.column = Objects.requireNonNull(column); + this.alias = alias; + } + @Override - protected String render(String columnName) { - return "count(" + columnName + ")"; //$NON-NLS-1$ //$NON-NLS-2$ + public String renderWithTableAlias(TableAliasCalculator tableAliasCalculator) { + return "count(" + column.renderWithTableAlias(tableAliasCalculator) + ")"; //$NON-NLS-1$ //$NON-NLS-2$ } @Override - protected Count copy() { - return new Count(column); + public Optional alias() { + return Optional.ofNullable(alias); } - + + @Override + public Count as(String alias) { + return new Count(column, alias); + } + + @Override + public Optional jdbcType() { + return Optional.of(JDBCType.BIGINT); + } + public static Count of(BasicColumn column) { return new Count(column); } diff --git a/src/main/java/org/mybatis/dynamic/sql/select/aggregate/CountAll.java b/src/main/java/org/mybatis/dynamic/sql/select/aggregate/CountAll.java index 25a15310f..c192f09b1 100644 --- a/src/main/java/org/mybatis/dynamic/sql/select/aggregate/CountAll.java +++ b/src/main/java/org/mybatis/dynamic/sql/select/aggregate/CountAll.java @@ -15,24 +15,29 @@ */ package org.mybatis.dynamic.sql.select.aggregate; +import java.sql.JDBCType; import java.util.Optional; -import org.mybatis.dynamic.sql.BasicColumn; +import org.mybatis.dynamic.sql.BindableColumn; import org.mybatis.dynamic.sql.render.TableAliasCalculator; /** * CountAll seems like the other aggregates, but it is special because there is no column. * Rather than dealing with a useless and confusing abstraction, we simply implement - * BasicColumn directly. + * BindableColumn directly. * * @author Jeff Butler */ -public class CountAll implements BasicColumn { +public class CountAll implements BindableColumn { - private String alias; + private final String alias; public CountAll() { - super(); + alias = null; + } + + private CountAll(String alias) { + this.alias = alias; } @Override @@ -47,8 +52,11 @@ public Optional alias() { @Override public CountAll as(String alias) { - CountAll copy = new CountAll(); - copy.alias = alias; - return copy; + return new CountAll(alias); + } + + @Override + public Optional jdbcType() { + return Optional.of(JDBCType.BIGINT); } } diff --git a/src/main/java/org/mybatis/dynamic/sql/select/aggregate/CountDistinct.java b/src/main/java/org/mybatis/dynamic/sql/select/aggregate/CountDistinct.java index f689811f6..4d5e6f3a5 100644 --- a/src/main/java/org/mybatis/dynamic/sql/select/aggregate/CountDistinct.java +++ b/src/main/java/org/mybatis/dynamic/sql/select/aggregate/CountDistinct.java @@ -15,24 +15,49 @@ */ package org.mybatis.dynamic.sql.select.aggregate; +import java.sql.JDBCType; +import java.util.Objects; +import java.util.Optional; + import org.mybatis.dynamic.sql.BasicColumn; +import org.mybatis.dynamic.sql.BindableColumn; +import org.mybatis.dynamic.sql.render.TableAliasCalculator; + +public class CountDistinct implements BindableColumn { + + private final BasicColumn column; + private final String alias; -public class CountDistinct extends AbstractAggregate { - private CountDistinct(BasicColumn column) { - super(column); + this.column = Objects.requireNonNull(column); + alias = null; } - + + private CountDistinct(BasicColumn column, String alias) { + this.column = Objects.requireNonNull(column); + this.alias = alias; + } + @Override - protected String render(String columnName) { - return "count(distinct " + columnName + ")"; //$NON-NLS-1$ //$NON-NLS-2$ + public String renderWithTableAlias(TableAliasCalculator tableAliasCalculator) { + return "count(distinct " + column.renderWithTableAlias(tableAliasCalculator) + ")"; //$NON-NLS-1$ //$NON-NLS-2$ } @Override - protected CountDistinct copy() { - return new CountDistinct(column); + public Optional alias() { + return Optional.ofNullable(alias); } - + + @Override + public CountDistinct as(String alias) { + return new CountDistinct(column, alias); + } + + @Override + public Optional jdbcType() { + return Optional.of(JDBCType.BIGINT); + } + public static CountDistinct of(BasicColumn column) { return new CountDistinct(column); } From a43c946054bb113547fb9a99fc83419bf43d628d Mon Sep 17 00:00:00 2001 From: Jeff Butler Date: Tue, 15 Sep 2020 17:56:29 -0400 Subject: [PATCH 4/7] Some abstraction for the count functions --- .../sql/select/aggregate/AbstractCount.java | 46 +++++++++++++++++++ .../dynamic/sql/select/aggregate/Count.java | 27 ++--------- .../sql/select/aggregate/CountAll.java | 31 ++----------- .../sql/select/aggregate/CountDistinct.java | 27 ++--------- 4 files changed, 58 insertions(+), 73 deletions(-) create mode 100644 src/main/java/org/mybatis/dynamic/sql/select/aggregate/AbstractCount.java diff --git a/src/main/java/org/mybatis/dynamic/sql/select/aggregate/AbstractCount.java b/src/main/java/org/mybatis/dynamic/sql/select/aggregate/AbstractCount.java new file mode 100644 index 000000000..9c0c11a3e --- /dev/null +++ b/src/main/java/org/mybatis/dynamic/sql/select/aggregate/AbstractCount.java @@ -0,0 +1,46 @@ +/* + * Copyright 2016-2020 the original author or 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 + * + * http://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.mybatis.dynamic.sql.select.aggregate; + +import java.util.Optional; +import org.mybatis.dynamic.sql.BindableColumn; + +/** + * Count functions are implemented differently than the other aggregates. This is primarily to preserve + * backwards compatibility. Count functions are configured as BindableColumns of type Long + * as it is assumed that the count functions always return a number. + * + * @param the subtype of this class + */ +public abstract class AbstractCount> implements BindableColumn { + private final String alias; + + protected AbstractCount(String alias) { + this.alias = alias; + } + + @Override + public Optional alias() { + return Optional.ofNullable(alias); + } + + @Override + public T as(String alias) { + return copyWithAlias(alias); + } + + protected abstract T copyWithAlias(String alias); +} diff --git a/src/main/java/org/mybatis/dynamic/sql/select/aggregate/Count.java b/src/main/java/org/mybatis/dynamic/sql/select/aggregate/Count.java index f6704cfd2..7c752d530 100644 --- a/src/main/java/org/mybatis/dynamic/sql/select/aggregate/Count.java +++ b/src/main/java/org/mybatis/dynamic/sql/select/aggregate/Count.java @@ -15,27 +15,18 @@ */ package org.mybatis.dynamic.sql.select.aggregate; -import java.sql.JDBCType; import java.util.Objects; -import java.util.Optional; import org.mybatis.dynamic.sql.BasicColumn; -import org.mybatis.dynamic.sql.BindableColumn; import org.mybatis.dynamic.sql.render.TableAliasCalculator; -public class Count implements BindableColumn { +public class Count extends AbstractCount { private final BasicColumn column; - private final String alias; - - private Count(BasicColumn column) { - this.column = Objects.requireNonNull(column); - alias = null; - } private Count(BasicColumn column, String alias) { + super(alias); this.column = Objects.requireNonNull(column); - this.alias = alias; } @Override @@ -44,21 +35,11 @@ public String renderWithTableAlias(TableAliasCalculator tableAliasCalculator) { } @Override - public Optional alias() { - return Optional.ofNullable(alias); - } - - @Override - public Count as(String alias) { + protected Count copyWithAlias(String alias) { return new Count(column, alias); } - @Override - public Optional jdbcType() { - return Optional.of(JDBCType.BIGINT); - } - public static Count of(BasicColumn column) { - return new Count(column); + return new Count(column, null); } } diff --git a/src/main/java/org/mybatis/dynamic/sql/select/aggregate/CountAll.java b/src/main/java/org/mybatis/dynamic/sql/select/aggregate/CountAll.java index c192f09b1..cc9bf1d1f 100644 --- a/src/main/java/org/mybatis/dynamic/sql/select/aggregate/CountAll.java +++ b/src/main/java/org/mybatis/dynamic/sql/select/aggregate/CountAll.java @@ -15,29 +15,16 @@ */ package org.mybatis.dynamic.sql.select.aggregate; -import java.sql.JDBCType; -import java.util.Optional; - -import org.mybatis.dynamic.sql.BindableColumn; import org.mybatis.dynamic.sql.render.TableAliasCalculator; -/** - * CountAll seems like the other aggregates, but it is special because there is no column. - * Rather than dealing with a useless and confusing abstraction, we simply implement - * BindableColumn directly. - * - * @author Jeff Butler - */ -public class CountAll implements BindableColumn { - - private final String alias; +public class CountAll extends AbstractCount { public CountAll() { - alias = null; + super(null); } private CountAll(String alias) { - this.alias = alias; + super(alias); } @Override @@ -46,17 +33,7 @@ public String renderWithTableAlias(TableAliasCalculator tableAliasCalculator) { } @Override - public Optional alias() { - return Optional.ofNullable(alias); - } - - @Override - public CountAll as(String alias) { + protected CountAll copyWithAlias(String alias) { return new CountAll(alias); } - - @Override - public Optional jdbcType() { - return Optional.of(JDBCType.BIGINT); - } } diff --git a/src/main/java/org/mybatis/dynamic/sql/select/aggregate/CountDistinct.java b/src/main/java/org/mybatis/dynamic/sql/select/aggregate/CountDistinct.java index 4d5e6f3a5..f9527ab6b 100644 --- a/src/main/java/org/mybatis/dynamic/sql/select/aggregate/CountDistinct.java +++ b/src/main/java/org/mybatis/dynamic/sql/select/aggregate/CountDistinct.java @@ -15,27 +15,18 @@ */ package org.mybatis.dynamic.sql.select.aggregate; -import java.sql.JDBCType; import java.util.Objects; -import java.util.Optional; import org.mybatis.dynamic.sql.BasicColumn; -import org.mybatis.dynamic.sql.BindableColumn; import org.mybatis.dynamic.sql.render.TableAliasCalculator; -public class CountDistinct implements BindableColumn { +public class CountDistinct extends AbstractCount { private final BasicColumn column; - private final String alias; - - private CountDistinct(BasicColumn column) { - this.column = Objects.requireNonNull(column); - alias = null; - } private CountDistinct(BasicColumn column, String alias) { + super(alias); this.column = Objects.requireNonNull(column); - this.alias = alias; } @Override @@ -44,21 +35,11 @@ public String renderWithTableAlias(TableAliasCalculator tableAliasCalculator) { } @Override - public Optional alias() { - return Optional.ofNullable(alias); - } - - @Override - public CountDistinct as(String alias) { + public CountDistinct copyWithAlias(String alias) { return new CountDistinct(column, alias); } - @Override - public Optional jdbcType() { - return Optional.of(JDBCType.BIGINT); - } - public static CountDistinct of(BasicColumn column) { - return new CountDistinct(column); + return new CountDistinct(column, null); } } From e60480f3510268a5eec466dfb9bfdd3e227ec3e2 Mon Sep 17 00:00:00 2001 From: Jeff Butler Date: Tue, 15 Sep 2020 17:56:48 -0400 Subject: [PATCH 5/7] Polishing --- .../java/org/mybatis/dynamic/sql/select/aggregate/Max.java | 4 ++-- .../java/org/mybatis/dynamic/sql/select/aggregate/Min.java | 2 +- .../java/org/mybatis/dynamic/sql/select/aggregate/Sum.java | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/src/main/java/org/mybatis/dynamic/sql/select/aggregate/Max.java b/src/main/java/org/mybatis/dynamic/sql/select/aggregate/Max.java index 0f6e4382c..dfaa8df6d 100644 --- a/src/main/java/org/mybatis/dynamic/sql/select/aggregate/Max.java +++ b/src/main/java/org/mybatis/dynamic/sql/select/aggregate/Max.java @@ -27,12 +27,12 @@ private Max(BindableColumn column) { @Override public String renderWithTableAlias(TableAliasCalculator tableAliasCalculator) { - return "max(" + column.renderWithTableAlias(tableAliasCalculator) + ")"; //$NON-NLS-1$ //$NON-NLS-2$; + return "max(" + column.renderWithTableAlias(tableAliasCalculator) + ")"; //$NON-NLS-1$ //$NON-NLS-2$ } @Override protected Max copy() { - return new Max(column); + return new Max<>(column); } public static Max of(BindableColumn column) { diff --git a/src/main/java/org/mybatis/dynamic/sql/select/aggregate/Min.java b/src/main/java/org/mybatis/dynamic/sql/select/aggregate/Min.java index 5e217e799..25bf6e6cb 100644 --- a/src/main/java/org/mybatis/dynamic/sql/select/aggregate/Min.java +++ b/src/main/java/org/mybatis/dynamic/sql/select/aggregate/Min.java @@ -27,7 +27,7 @@ private Min(BindableColumn column) { @Override public String renderWithTableAlias(TableAliasCalculator tableAliasCalculator) { - return "min(" + column.renderWithTableAlias(tableAliasCalculator) + ")"; //$NON-NLS-1$ //$NON-NLS-2$; + return "min(" + column.renderWithTableAlias(tableAliasCalculator) + ")"; //$NON-NLS-1$ //$NON-NLS-2$ } @Override diff --git a/src/main/java/org/mybatis/dynamic/sql/select/aggregate/Sum.java b/src/main/java/org/mybatis/dynamic/sql/select/aggregate/Sum.java index 2f651f591..ac2636afd 100644 --- a/src/main/java/org/mybatis/dynamic/sql/select/aggregate/Sum.java +++ b/src/main/java/org/mybatis/dynamic/sql/select/aggregate/Sum.java @@ -27,7 +27,7 @@ private Sum(BindableColumn column) { @Override public String renderWithTableAlias(TableAliasCalculator tableAliasCalculator) { - return "sum(" + column.renderWithTableAlias(tableAliasCalculator) + ")"; //$NON-NLS-1$ //$NON-NLS-2$; + return "sum(" + column.renderWithTableAlias(tableAliasCalculator) + ")"; //$NON-NLS-1$ //$NON-NLS-2$ } @Override From 2e42ae301cb604c8c58ac6cbb408334b26b58e78 Mon Sep 17 00:00:00 2001 From: Jeff Butler Date: Tue, 15 Sep 2020 17:57:25 -0400 Subject: [PATCH 6/7] Deprecate AbstractAggregate in favor or AbstractUniTypeFunction --- .../dynamic/sql/select/aggregate/AbstractAggregate.java | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/src/main/java/org/mybatis/dynamic/sql/select/aggregate/AbstractAggregate.java b/src/main/java/org/mybatis/dynamic/sql/select/aggregate/AbstractAggregate.java index fb3832a49..b966c95e3 100644 --- a/src/main/java/org/mybatis/dynamic/sql/select/aggregate/AbstractAggregate.java +++ b/src/main/java/org/mybatis/dynamic/sql/select/aggregate/AbstractAggregate.java @@ -23,11 +23,15 @@ /** * This class is the base class for aggregate functions. - * + * + * @deprecated in favor of {@link org.mybatis.dynamic.sql.select.function.AbstractUniTypeFunction} as there is + * virtually no difference between an aggregate and a function + * * @author Jeff Butler * * @param the subclass type */ +@Deprecated public abstract class AbstractAggregate> implements BasicColumn { protected final BasicColumn column; protected String alias; From 2a681dca4f9470158e2047899598c949a6a97b49 Mon Sep 17 00:00:00 2001 From: Jeff Butler Date: Tue, 15 Sep 2020 18:23:24 -0400 Subject: [PATCH 7/7] Coverage --- .../examples/animal/data/AnimalDataTest.java | 19 +++++++++ .../animal/data/DeprecatedAverage.java | 39 +++++++++++++++++++ 2 files changed, 58 insertions(+) create mode 100644 src/test/java/examples/animal/data/DeprecatedAverage.java diff --git a/src/test/java/examples/animal/data/AnimalDataTest.java b/src/test/java/examples/animal/data/AnimalDataTest.java index bbcd74e4a..3e074622b 100644 --- a/src/test/java/examples/animal/data/AnimalDataTest.java +++ b/src/test/java/examples/animal/data/AnimalDataTest.java @@ -1825,6 +1825,25 @@ void testAvg() { } } + @Test + void testDeprecatedAvg() { + try (SqlSession sqlSession = sqlSessionFactory.openSession()) { + GeneralMapper mapper = sqlSession.getMapper(GeneralMapper.class); + + SelectStatementProvider selectStatement = select(DeprecatedAverage.of(brainWeight).as("average")) + .from(animalData, "a") + .build() + .render(RenderingStrategies.MYBATIS3); + + Double average = mapper.selectOneDouble(selectStatement); + + assertAll( + () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select avg(a.brain_weight) as average from AnimalData a"), + () -> assertThat(average).isEqualTo(1852.69, within(.01)) + ); + } + } + @Test void testSum() { try (SqlSession sqlSession = sqlSessionFactory.openSession()) { diff --git a/src/test/java/examples/animal/data/DeprecatedAverage.java b/src/test/java/examples/animal/data/DeprecatedAverage.java new file mode 100644 index 000000000..f9487a8fc --- /dev/null +++ b/src/test/java/examples/animal/data/DeprecatedAverage.java @@ -0,0 +1,39 @@ +/* + * Copyright 2016-2020 the original author or 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 + * + * http://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 examples.animal.data; + +import org.mybatis.dynamic.sql.BasicColumn; +import org.mybatis.dynamic.sql.select.aggregate.AbstractAggregate; + +public class DeprecatedAverage extends AbstractAggregate { + private DeprecatedAverage(BasicColumn column) { + super(column); + } + + @Override + protected String render(String columnName) { + return "avg(" + columnName + ")"; //$NON-NLS-1$ //$NON-NLS-2$ + } + + @Override + protected DeprecatedAverage copy() { + return new DeprecatedAverage(column); + } + + public static DeprecatedAverage of(BasicColumn column) { + return new DeprecatedAverage(column); + } +}