From 047faf4891a9c7e33d851d6b2ff2846071497030 Mon Sep 17 00:00:00 2001 From: yulichang <570810310@qq.com> Date: Mon, 14 Oct 2024 21:35:15 +0800 Subject: [PATCH] feat: selectFunc support Object param --- .../extension/apt/AptQueryWrapper.java | 19 ++++-- .../extension/apt/JoinAbstractWrapper.java | 14 +++-- .../extension/apt/interfaces/Query.java | 53 ++++++++-------- .../extension/kt/KtLambdaWrapper.java | 16 +++++ .../extension/kt/interfaces/Query.java | 14 ++--- .../extension/kt/segments/FuncArgs.java | 20 +++++- .../wrapper/JoinAbstractWrapper.java | 28 +++++---- .../yulichang/wrapper/MPJLambdaWrapper.java | 14 +++++ .../yulichang/wrapper/UpdateJoinWrapper.java | 9 +-- .../yulichang/wrapper/interfaces/Query.java | 13 +--- .../yulichang/wrapper/interfaces/Update.java | 4 +- .../wrapper/segments/AptConsumer.java | 17 +++++- .../wrapper/segments/FuncConsumer.java | 61 ++++++++++++------- mybatis-plus-join-test/test-join/pom.xml | 9 ++- .../test/join/unit/SelectFuncTest.java | 50 +++++++++++++++ 15 files changed, 240 insertions(+), 101 deletions(-) create mode 100644 mybatis-plus-join-test/test-join/src/test/java/com/github/yulichang/test/join/unit/SelectFuncTest.java diff --git a/mybatis-plus-join-core/src/main/java/com/github/yulichang/extension/apt/AptQueryWrapper.java b/mybatis-plus-join-core/src/main/java/com/github/yulichang/extension/apt/AptQueryWrapper.java index 4aadff7..b0216c3 100644 --- a/mybatis-plus-join-core/src/main/java/com/github/yulichang/extension/apt/AptQueryWrapper.java +++ b/mybatis-plus-join-core/src/main/java/com/github/yulichang/extension/apt/AptQueryWrapper.java @@ -19,12 +19,10 @@ import com.github.yulichang.toolkit.support.ColumnCache; import com.github.yulichang.wrapper.enums.IfExistsSqlKeyWordEnum; import com.github.yulichang.wrapper.interfaces.Chain; import com.github.yulichang.wrapper.interfaces.MBiPredicate; +import com.github.yulichang.wrapper.interfaces.MFunction; import com.github.yulichang.wrapper.interfaces.SelectWrapper; import com.github.yulichang.wrapper.resultmap.Label; -import com.github.yulichang.wrapper.segments.Select; -import com.github.yulichang.wrapper.segments.SelectApt; -import com.github.yulichang.wrapper.segments.SelectCache; -import com.github.yulichang.wrapper.segments.SelectSub; +import com.github.yulichang.wrapper.segments.*; import lombok.Getter; import java.util.*; @@ -192,6 +190,19 @@ public class AptQueryWrapper extends AptAbstractWrapper return selectAll(getBaseColumn()); } + @Override + public AptQueryWrapper selectFunc(String sql, MFunction column, String alias) { + AptConsumer apply = column.apply(new AptConsumer()); + String formatSql; + if (ArrayUtils.isEmpty(apply.getValues())) { + formatSql = sql; + } else { + formatSql = formatSqlMaybeWithParam(sql, null, apply.getValues()); + } + getSelectColum().add(new SelectApt(apply.getColumns(), () -> formatSql, alias)); + return typedThis; + } + public AptQueryWrapper selectSub(BaseColumn baseColumn, Consumer> consumer, SFunction alias) { return selectSub(baseColumn, consumer, LambdaUtils.getName(alias)); } diff --git a/mybatis-plus-join-core/src/main/java/com/github/yulichang/extension/apt/JoinAbstractWrapper.java b/mybatis-plus-join-core/src/main/java/com/github/yulichang/extension/apt/JoinAbstractWrapper.java index c5c216c..46eaf9d 100644 --- a/mybatis-plus-join-core/src/main/java/com/github/yulichang/extension/apt/JoinAbstractWrapper.java +++ b/mybatis-plus-join-core/src/main/java/com/github/yulichang/extension/apt/JoinAbstractWrapper.java @@ -12,11 +12,11 @@ import com.baomidou.mybatisplus.core.toolkit.*; import com.baomidou.mybatisplus.core.toolkit.sql.SqlUtils; import com.baomidou.mybatisplus.core.toolkit.sql.StringEscape; import com.baomidou.mybatisplus.core.toolkit.support.SFunction; -import com.github.yulichang.extension.apt.matedata.Column; import com.github.yulichang.config.ConfigProperties; import com.github.yulichang.extension.apt.interfaces.CompareIfExists; import com.github.yulichang.extension.apt.interfaces.Func; import com.github.yulichang.extension.apt.interfaces.OnCompare; +import com.github.yulichang.extension.apt.matedata.Column; import com.github.yulichang.toolkit.LambdaUtils; import com.github.yulichang.toolkit.MPJSqlInjectionUtils; import com.github.yulichang.toolkit.Ref; @@ -283,15 +283,19 @@ public abstract class JoinAbstractWrapper formatSqlMaybeWithParam(applySql, null, values))); } - public Children applyFunc(String applySql, SFunction consumerFunction, Object... values) { + public Children applyFunc(String applySql, MFunction consumerFunction, Object... values) { return applyFunc(true, applySql, consumerFunction, values); } public Children applyFunc(boolean condition, String applySql, - SFunction consumerFunction, Object... values) { + MFunction consumerFunction, Object... values) { return maybeDo(condition, () -> appendSqlSegments(APPLY, - () -> formatSqlMaybeWithParam(String.format(applySql, - Arrays.stream(consumerFunction.apply(AptConsumer.func)).map(this::columnToString).toArray()), null, values))); + () -> { + AptConsumer apply = consumerFunction.apply(new AptConsumer()); + return formatSqlMaybeWithParam(String.format(applySql, + Arrays.stream(apply.getColumns()).map(this::columnToString).toArray()), null, + ArrayUtils.isNotEmpty(values) ? values : apply.getValues()); + })); } @Override diff --git a/mybatis-plus-join-core/src/main/java/com/github/yulichang/extension/apt/interfaces/Query.java b/mybatis-plus-join-core/src/main/java/com/github/yulichang/extension/apt/interfaces/Query.java index b66bed8..0ad3bc8 100644 --- a/mybatis-plus-join-core/src/main/java/com/github/yulichang/extension/apt/interfaces/Query.java +++ b/mybatis-plus-join-core/src/main/java/com/github/yulichang/extension/apt/interfaces/Query.java @@ -13,11 +13,11 @@ import com.github.yulichang.toolkit.support.ColumnCache; import com.github.yulichang.toolkit.support.FieldCache; import com.github.yulichang.wrapper.enums.BaseFuncEnum; import com.github.yulichang.wrapper.enums.DefaultFuncEnum; +import com.github.yulichang.wrapper.interfaces.MFunction; import com.github.yulichang.wrapper.segments.*; import java.io.Serializable; import java.util.*; -import java.util.function.Function; import java.util.function.Predicate; import java.util.stream.Collectors; @@ -115,7 +115,7 @@ public interface Query extends Serializable { /** * 别名查询 */ - default Children selectAs(Column column, String alias) { + default Children selectAs(Column column, String alias) { Map cacheMap = ColumnCache.getMapField(column.getClazz()); SelectCache cache = cacheMap.get(column.getProperty()); getSelectColum().add(new SelectApt(cache, column, alias)); @@ -165,27 +165,24 @@ public interface Query extends Serializable { * @param column 函数作用的字段 * @param alias 别名 */ - default Children selectFunc(BaseFuncEnum funcEnum, Column column, String alias) { + default Children selectFunc(BaseFuncEnum funcEnum, Column column, String alias) { Map cacheMap = ColumnCache.getMapField(column.getClazz()); getSelectColum().add(new SelectApt(cacheMap.get(column.getProperty()), column, funcEnum, alias)); return getChildren(); } - default Children selectFunc(BaseFuncEnum funcEnum, Column column, SFunction alias) { + default Children selectFunc(BaseFuncEnum funcEnum, Column column, SFunction alias) { return selectFunc(funcEnum, column, LambdaUtils.getName(alias)); } - default Children selectFunc(BaseFuncEnum funcEnum, Column column) { + default Children selectFunc(BaseFuncEnum funcEnum, Column column) { return selectFunc(funcEnum, column, column.getProperty()); } - default Children selectFunc(String sql, Function column, String alias) { - getSelectColum().add(new SelectApt(column.apply(AptConsumer.func), () -> sql, alias)); - return getChildren(); - } + Children selectFunc(String sql, MFunction column, String alias); - default Children selectFunc(String sql, Function column, SFunction alias) { + default Children selectFunc(String sql, MFunction column, SFunction alias) { return selectFunc(sql, column, LambdaUtils.getName(alias)); } @@ -194,90 +191,90 @@ public interface Query extends Serializable { /** * SUM() */ - default Children selectSum(Column column) { + default Children selectSum(Column column) { return selectFunc(DefaultFuncEnum.SUM, column); } - default Children selectSum(Column column, SFunction alias) { + default Children selectSum(Column column, SFunction alias) { return selectFunc(DefaultFuncEnum.SUM, column, alias); } - default Children selectSum(Column column, String alias) { + default Children selectSum(Column column, String alias) { return selectFunc(DefaultFuncEnum.SUM, column, alias); } /** * COUNT() */ - default Children selectCount(Column column) { + default Children selectCount(Column column) { return selectFunc(DefaultFuncEnum.COUNT, column); } - default Children selectCount(Column column, SFunction alias) { + default Children selectCount(Column column, SFunction alias) { return selectFunc(DefaultFuncEnum.COUNT, column, alias); } - default Children selectCount(Column column, String alias) { + default Children selectCount(Column column, String alias) { return selectFunc(DefaultFuncEnum.COUNT, column, alias); } /** * MAX() */ - default Children selectMax(Column column) { + default Children selectMax(Column column) { return selectFunc(DefaultFuncEnum.MAX, column); } - default Children selectMax(Column column, SFunction alias) { + default Children selectMax(Column column, SFunction alias) { return selectFunc(DefaultFuncEnum.MAX, column, alias); } - default Children selectMax(Column column, String alias) { + default Children selectMax(Column column, String alias) { return selectFunc(DefaultFuncEnum.MAX, column, alias); } /** * MIN() */ - default Children selectMin(Column column) { + default Children selectMin(Column column) { return selectFunc(DefaultFuncEnum.MIN, column); } - default Children selectMin(Column column, SFunction alias) { + default Children selectMin(Column column, SFunction alias) { return selectFunc(DefaultFuncEnum.MIN, column, alias); } - default Children selectMin(Column column, String alias) { + default Children selectMin(Column column, String alias) { return selectFunc(DefaultFuncEnum.MIN, column, alias); } /** * MIN() */ - default Children selectAvg(Column column) { + default Children selectAvg(Column column) { return selectFunc(DefaultFuncEnum.AVG, column); } - default Children selectAvg(Column column, SFunction alias) { + default Children selectAvg(Column column, SFunction alias) { return selectFunc(DefaultFuncEnum.AVG, column, alias); } - default Children selectAvg(Column column, String alias) { + default Children selectAvg(Column column, String alias) { return selectFunc(DefaultFuncEnum.AVG, column, alias); } /** * LEN() */ - default Children selectLen(Column column) { + default Children selectLen(Column column) { return selectFunc(DefaultFuncEnum.LEN, column); } - default Children selectLen(Column column, SFunction alias) { + default Children selectLen(Column column, SFunction alias) { return selectFunc(DefaultFuncEnum.LEN, column, alias); } - default Children selectLen(Column column, String alias) { + default Children selectLen(Column column, String alias) { return selectFunc(DefaultFuncEnum.LEN, column, alias); } } diff --git a/mybatis-plus-join-core/src/main/java/com/github/yulichang/extension/kt/KtLambdaWrapper.java b/mybatis-plus-join-core/src/main/java/com/github/yulichang/extension/kt/KtLambdaWrapper.java index 93b4347..ee04f68 100644 --- a/mybatis-plus-join-core/src/main/java/com/github/yulichang/extension/kt/KtLambdaWrapper.java +++ b/mybatis-plus-join-core/src/main/java/com/github/yulichang/extension/kt/KtLambdaWrapper.java @@ -7,6 +7,7 @@ import com.baomidou.mybatisplus.core.toolkit.*; import com.github.yulichang.config.ConfigProperties; import com.github.yulichang.extension.kt.interfaces.Query; import com.github.yulichang.extension.kt.interfaces.QueryLabel; +import com.github.yulichang.extension.kt.segments.FuncArgs; import com.github.yulichang.extension.kt.toolkit.KtWrapperUtils; import com.github.yulichang.extension.kt.toolkit.KtWrappers; import com.github.yulichang.toolkit.Constant; @@ -14,6 +15,7 @@ import com.github.yulichang.toolkit.KtUtils; import com.github.yulichang.toolkit.TableList; import com.github.yulichang.toolkit.support.ColumnCache; import com.github.yulichang.wrapper.interfaces.Chain; +import com.github.yulichang.wrapper.interfaces.MFunction; import com.github.yulichang.wrapper.interfaces.SelectWrapper; import com.github.yulichang.wrapper.resultmap.Label; import com.github.yulichang.wrapper.segments.*; @@ -233,6 +235,20 @@ public class KtLambdaWrapper extends KtAbstractLambdaWrapper selectFunc(String sql, MFunction column, String alias) { + FuncArgs apply = column.apply(new FuncArgs()); + String formatSql; + if (ArrayUtils.isEmpty(apply.getValues())) { + formatSql = sql; + } else { + formatSql = formatSqlMaybeWithParam(sql, null, apply.getValues()); + } + getSelectColum().add(new SelectFunc(alias, getIndex(), () -> formatSql, apply.getFuncArg(), + isHasAlias(), getAlias())); + return typedThis; + } + /** * union *

diff --git a/mybatis-plus-join-core/src/main/java/com/github/yulichang/extension/kt/interfaces/Query.java b/mybatis-plus-join-core/src/main/java/com/github/yulichang/extension/kt/interfaces/Query.java index bf02124..843b218 100644 --- a/mybatis-plus-join-core/src/main/java/com/github/yulichang/extension/kt/interfaces/Query.java +++ b/mybatis-plus-join-core/src/main/java/com/github/yulichang/extension/kt/interfaces/Query.java @@ -12,6 +12,7 @@ import com.github.yulichang.toolkit.support.ColumnCache; import com.github.yulichang.toolkit.support.FieldCache; import com.github.yulichang.wrapper.enums.BaseFuncEnum; import com.github.yulichang.wrapper.enums.DefaultFuncEnum; +import com.github.yulichang.wrapper.interfaces.MFunction; import com.github.yulichang.wrapper.segments.*; import kotlin.reflect.KProperty; @@ -19,7 +20,6 @@ import java.io.Serializable; import java.util.Arrays; import java.util.List; import java.util.Map; -import java.util.function.Function; import java.util.function.Predicate; import java.util.stream.Collectors; @@ -216,16 +216,10 @@ public interface Query extends Serializable { } - default Children selectFunc(String sql, Function column, String alias) { - getSelectColum().add(new SelectFunc(alias, getIndex(), () -> sql, column.apply(new FuncArgs()), - isHasAlias(), getAlias())); - return getChildren(); - } + Children selectFunc(String sql, MFunction column, String alias); - default Children selectFunc(String sql, Function column, KProperty alias) { - getSelectColum().add(new SelectFunc(alias.getName(), getIndex(), () -> sql, - column.apply(new FuncArgs()), isHasAlias(), getAlias())); - return getChildren(); + default Children selectFunc(String sql, MFunction column, KProperty alias) { + return selectFunc(sql, column, alias.getName()); } /* 默认聚合函数扩展 */ diff --git a/mybatis-plus-join-core/src/main/java/com/github/yulichang/extension/kt/segments/FuncArgs.java b/mybatis-plus-join-core/src/main/java/com/github/yulichang/extension/kt/segments/FuncArgs.java index e3eb05f..a1b5db4 100644 --- a/mybatis-plus-join-core/src/main/java/com/github/yulichang/extension/kt/segments/FuncArgs.java +++ b/mybatis-plus-join-core/src/main/java/com/github/yulichang/extension/kt/segments/FuncArgs.java @@ -3,6 +3,7 @@ package com.github.yulichang.extension.kt.segments; import com.github.yulichang.toolkit.KtUtils; import com.github.yulichang.wrapper.segments.SelectFunc; import kotlin.reflect.KProperty; +import lombok.Data; import java.util.Arrays; @@ -12,11 +13,26 @@ import java.util.Arrays; * @author yulichang * @since 1.4.6 */ +@Data @SuppressWarnings("unused") public class FuncArgs { - public SelectFunc.Arg[] accept(KProperty... kProperty) { - return Arrays.stream(kProperty).map(i -> + private KProperty[] args; + + private Object[] values; + + public FuncArgs accept(KProperty... kProperty) { + this.args = kProperty; + return this; + } + + public FuncArgs values(Object... values) { + this.values = values; + return this; + } + + public SelectFunc.Arg[] getFuncArg() { + return Arrays.stream(args).map(i -> new SelectFunc.Arg(KtUtils.ref(i), i.getName(), false, null, i)) .toArray(SelectFunc.Arg[]::new); } diff --git a/mybatis-plus-join-core/src/main/java/com/github/yulichang/wrapper/JoinAbstractWrapper.java b/mybatis-plus-join-core/src/main/java/com/github/yulichang/wrapper/JoinAbstractWrapper.java index 4d892d3..df8b747 100644 --- a/mybatis-plus-join-core/src/main/java/com/github/yulichang/wrapper/JoinAbstractWrapper.java +++ b/mybatis-plus-join-core/src/main/java/com/github/yulichang/wrapper/JoinAbstractWrapper.java @@ -27,7 +27,10 @@ import lombok.Getter; import java.util.*; import java.util.concurrent.atomic.AtomicInteger; -import java.util.function.*; +import java.util.function.BiPredicate; +import java.util.function.Consumer; +import java.util.function.Predicate; +import java.util.function.Supplier; import static com.baomidou.mybatisplus.core.enums.SqlKeyword.*; import static com.baomidou.mybatisplus.core.enums.WrapperKeyword.APPLY; @@ -329,21 +332,24 @@ public abstract class JoinAbstractWrapper formatSqlMaybeWithParam(applySql, null, values))); } - public Children applyFunc(String applySql, SFunction[]> consumerFunction, Object... values) { + public Children applyFunc(String applySql, MFunction consumerFunction, Object... values) { return applyFunc(true, applySql, consumerFunction, values); } public Children applyFunc(boolean condition, String applySql, - Function[]> consumerFunction, Object... values) { + MFunction consumerFunction, Object... values) { return maybeDo(condition, () -> appendSqlSegments(APPLY, - () -> formatSqlMaybeWithParam(String.format(applySql, - Arrays.stream(consumerFunction.apply(FuncConsumer.func)).map(func -> { - if (func instanceof Fun) { - Fun fun = (Fun) func; - return columnToString(index, fun.getAlias(), fun.getFunc(), false, PrefixEnum.CD_FIRST, false); - } - return columnToString(index, null, func, false, PrefixEnum.CD_FIRST, false); - }).toArray()), null, values))); + () -> { + FuncConsumer funcConsumer = consumerFunction.apply(new FuncConsumer()); + return formatSqlMaybeWithParam(String.format(applySql, + Arrays.stream(funcConsumer.getArgs()).map(func -> { + if (func instanceof Fun) { + Fun fun = (Fun) func; + return columnToString(index, fun.getAlias(), fun.getFunc(), false, PrefixEnum.CD_FIRST, false); + } + return columnToString(index, null, func, false, PrefixEnum.CD_FIRST, false); + }).toArray()), null, ArrayUtils.isEmpty(values) ? funcConsumer.getValues() : values); + })); } @Override diff --git a/mybatis-plus-join-core/src/main/java/com/github/yulichang/wrapper/MPJLambdaWrapper.java b/mybatis-plus-join-core/src/main/java/com/github/yulichang/wrapper/MPJLambdaWrapper.java index fb673e0..3c7b12e 100644 --- a/mybatis-plus-join-core/src/main/java/com/github/yulichang/wrapper/MPJLambdaWrapper.java +++ b/mybatis-plus-join-core/src/main/java/com/github/yulichang/wrapper/MPJLambdaWrapper.java @@ -234,6 +234,20 @@ public class MPJLambdaWrapper extends JoinAbstractLambdaWrapper selectFunc(String sql, MFunction column, String alias) { + FuncConsumer funcConsumer = column.apply(new FuncConsumer()); + String formatSql; + if (ArrayUtils.isEmpty(funcConsumer.getValues())) { + formatSql = sql; + } else { + formatSql = formatSqlMaybeWithParam(sql, null, funcConsumer.getValues()); + } + getSelectColum().add(new SelectFunc(alias, getIndex(), () -> formatSql, + funcConsumer.getArgs(), isHasAlias(), getAlias())); + return typedThis; + } + /** * 子查询 */ diff --git a/mybatis-plus-join-core/src/main/java/com/github/yulichang/wrapper/UpdateJoinWrapper.java b/mybatis-plus-join-core/src/main/java/com/github/yulichang/wrapper/UpdateJoinWrapper.java index 89822ea..82782b6 100644 --- a/mybatis-plus-join-core/src/main/java/com/github/yulichang/wrapper/UpdateJoinWrapper.java +++ b/mybatis-plus-join-core/src/main/java/com/github/yulichang/wrapper/UpdateJoinWrapper.java @@ -10,6 +10,7 @@ import com.github.yulichang.adapter.AdapterHelper; import com.github.yulichang.toolkit.LambdaUtils; import com.github.yulichang.toolkit.ReflectionKit; import com.github.yulichang.toolkit.*; +import com.github.yulichang.wrapper.interfaces.MFunction; import com.github.yulichang.wrapper.interfaces.Update; import com.github.yulichang.wrapper.interfaces.UpdateChain; import com.github.yulichang.wrapper.segments.FuncConsumer; @@ -127,14 +128,14 @@ public class UpdateJoinWrapper extends JoinAbstractLambdaWrapper setApply(boolean condition, String applySql, SFunction[]> consumerFunction, Object... values) { + public UpdateJoinWrapper setApply(boolean condition, String applySql, MFunction consumerFunction, Object... values) { if (condition && StringUtils.isNotBlank(applySql)) { - SFunction[] arg = consumerFunction.apply(FuncConsumer.func); + FuncConsumer funcConsumer = consumerFunction.apply(new FuncConsumer()); UpdateSet set = new UpdateSet(); set.setApply(true); set.setFormat(applySql); - set.setColumns(arg); - set.setArgs(values); + set.setColumns(funcConsumer.getArgs()); + set.setArgs(ArrayUtils.isNotEmpty(values) ? values : funcConsumer.getValues()); getUpdateSet().add(set); } return typedThis; diff --git a/mybatis-plus-join-core/src/main/java/com/github/yulichang/wrapper/interfaces/Query.java b/mybatis-plus-join-core/src/main/java/com/github/yulichang/wrapper/interfaces/Query.java index 20b7bc8..a336c56 100644 --- a/mybatis-plus-join-core/src/main/java/com/github/yulichang/wrapper/interfaces/Query.java +++ b/mybatis-plus-join-core/src/main/java/com/github/yulichang/wrapper/interfaces/Query.java @@ -17,7 +17,6 @@ import com.github.yulichang.wrapper.segments.*; import java.io.Serializable; import java.util.*; -import java.util.function.Function; import java.util.function.Predicate; import java.util.stream.Collectors; @@ -263,16 +262,10 @@ public interface Query extends Serializable { } - default Children selectFunc(String sql, Function[]> column, String alias) { - getSelectColum().add(new SelectFunc(alias, getIndex(), () -> sql, column.apply(FuncConsumer.func), - isHasAlias(), getAlias())); - return getChildren(); - } + Children selectFunc(String sql, MFunction column, String alias); - default Children selectFunc(String sql, Function[]> column, SFunction alias) { - getSelectColum().add(new SelectFunc(LambdaUtils.getName(alias), getIndex(), () -> sql, - column.apply(FuncConsumer.func), isHasAlias(), getAlias())); - return getChildren(); + default Children selectFunc(String sql, MFunction column, SFunction alias) { + return selectFunc(sql, column, LambdaUtils.getName(alias)); } /* 默认聚合函数扩展 */ diff --git a/mybatis-plus-join-core/src/main/java/com/github/yulichang/wrapper/interfaces/Update.java b/mybatis-plus-join-core/src/main/java/com/github/yulichang/wrapper/interfaces/Update.java index 4fab359..983ce61 100644 --- a/mybatis-plus-join-core/src/main/java/com/github/yulichang/wrapper/interfaces/Update.java +++ b/mybatis-plus-join-core/src/main/java/com/github/yulichang/wrapper/interfaces/Update.java @@ -80,11 +80,11 @@ public interface Update extends Serializable { Children setDecrBy(boolean condition, SFunction column, Number val); - default Children setApply(String applySql, SFunction[]> consumerFunction, Object... values) { + default Children setApply(String applySql, MFunction consumerFunction, Object... values) { return setApply(true, applySql, consumerFunction, values); } - Children setApply(boolean condition, String applySql, SFunction[]> consumerFunction, Object... values); + Children setApply(boolean condition, String applySql, MFunction consumerFunction, Object... values); /** * ignore diff --git a/mybatis-plus-join-core/src/main/java/com/github/yulichang/wrapper/segments/AptConsumer.java b/mybatis-plus-join-core/src/main/java/com/github/yulichang/wrapper/segments/AptConsumer.java index 748fe87..88eabb2 100644 --- a/mybatis-plus-join-core/src/main/java/com/github/yulichang/wrapper/segments/AptConsumer.java +++ b/mybatis-plus-join-core/src/main/java/com/github/yulichang/wrapper/segments/AptConsumer.java @@ -1,6 +1,7 @@ package com.github.yulichang.wrapper.segments; import com.github.yulichang.extension.apt.matedata.Column; +import lombok.Data; import java.io.Serializable; @@ -11,12 +12,22 @@ import java.io.Serializable; * @author yulichang * @since 1.4.13 */ +@Data public class AptConsumer implements Serializable { - public static final AptConsumer func = new AptConsumer(); + private Column[] columns; - public final Column[] accept(Column... a) { - return a; + private Object[] values; + + + public final AptConsumer accept(Column... a) { + this.columns = a; + return this; + } + + public final AptConsumer accept(Object... a) { + this.values = a; + return this; } } diff --git a/mybatis-plus-join-core/src/main/java/com/github/yulichang/wrapper/segments/FuncConsumer.java b/mybatis-plus-join-core/src/main/java/com/github/yulichang/wrapper/segments/FuncConsumer.java index 5872904..e7871ef 100644 --- a/mybatis-plus-join-core/src/main/java/com/github/yulichang/wrapper/segments/FuncConsumer.java +++ b/mybatis-plus-join-core/src/main/java/com/github/yulichang/wrapper/segments/FuncConsumer.java @@ -1,6 +1,7 @@ package com.github.yulichang.wrapper.segments; import com.baomidou.mybatisplus.core.toolkit.support.SFunction; +import lombok.Data; /** * 用于selectFunc 和 applyFunc中的参数填充 @@ -9,48 +10,66 @@ import com.baomidou.mybatisplus.core.toolkit.support.SFunction; * @author yulichang * @since 1.4.13 */ +@Data public class FuncConsumer { - public static final FuncConsumer func = new FuncConsumer(); + private SFunction[] args; - public final SFunction[] accept(SFunction a) { - return new SFunction[]{a}; + private Object[] values; + + public final FuncConsumer accept(SFunction a) { + this.args = new SFunction[]{a}; + return this; } - public final SFunction[] accept(SFunction a, SFunction b) { - return new SFunction[]{a, b}; + public final FuncConsumer accept(SFunction a, SFunction b) { + this.args = new SFunction[]{a, b}; + return this; } - public final SFunction[] accept(SFunction a, SFunction b, SFunction c) { - return new SFunction[]{a, b, c}; + public final FuncConsumer accept(SFunction a, SFunction b, SFunction c) { + this.args = new SFunction[]{a, b, c}; + return this; } - public final SFunction[] accept(SFunction a, SFunction b, SFunction c, SFunction d) { - return new SFunction[]{a, b, c, d}; + public final FuncConsumer accept(SFunction a, SFunction b, SFunction c, SFunction d) { + this.args = new SFunction[]{a, b, c, d}; + return this; } - public final SFunction[] accept(SFunction a, SFunction b, SFunction c, SFunction d, SFunction e) { - return new SFunction[]{a, b, c, d, e}; + public final FuncConsumer accept(SFunction a, SFunction b, SFunction c, SFunction d, SFunction e) { + this.args = new SFunction[]{a, b, c, d, e}; + return this; } - public final SFunction[] accept(SFunction a, SFunction b, SFunction c, SFunction d, SFunction e, SFunction f) { - return new SFunction[]{a, b, c, d, e, f}; + public final FuncConsumer accept(SFunction a, SFunction b, SFunction c, SFunction d, SFunction e, SFunction f) { + this.args = new SFunction[]{a, b, c, d, e, f}; + return this; } - public final SFunction[] accept(SFunction a, SFunction b, SFunction c, SFunction d, SFunction e, SFunction f, SFunction g) { - return new SFunction[]{a, b, c, d, e, f, g}; + public final FuncConsumer accept(SFunction a, SFunction b, SFunction c, SFunction d, SFunction e, SFunction f, SFunction g) { + this.args = new SFunction[]{a, b, c, d, e, f, g}; + return this; } - public final SFunction[] accept(SFunction a, SFunction b, SFunction c, SFunction d, SFunction e, SFunction f, SFunction g, SFunction h) { - return new SFunction[]{a, b, c, d, e, f, g, h}; + public final FuncConsumer accept(SFunction a, SFunction b, SFunction c, SFunction d, SFunction e, SFunction f, SFunction g, SFunction h) { + this.args = new SFunction[]{a, b, c, d, e, f, g, h}; + return this; } - public final SFunction[] accept(SFunction a, SFunction b, SFunction c, SFunction d, SFunction e, SFunction f, SFunction g, SFunction h, SFunction i) { - return new SFunction[]{a, b, c, d, e, f, g, h, i}; + public final FuncConsumer accept(SFunction a, SFunction b, SFunction c, SFunction d, SFunction e, SFunction f, SFunction g, SFunction h, SFunction i) { + this.args = new SFunction[]{a, b, c, d, e, f, g, h, i}; + return this; } - public final SFunction[] accept(SFunction a, SFunction b, SFunction c, SFunction d, SFunction e, SFunction f, SFunction g, SFunction h, SFunction i, SFunction j) { - return new SFunction[]{a, b, c, d, e, f, g, h, i, j}; + public final FuncConsumer accept(SFunction a, SFunction b, SFunction c, SFunction d, SFunction e, SFunction f, SFunction g, SFunction h, SFunction i, SFunction j) { + this.args = new SFunction[]{a, b, c, d, e, f, g, h, i, j}; + return this; } + + public final FuncConsumer values(Object... values) { + this.values = values; + return this; + } } diff --git a/mybatis-plus-join-test/test-join/pom.xml b/mybatis-plus-join-test/test-join/pom.xml index 1f9133f..b16dbd5 100644 --- a/mybatis-plus-join-test/test-join/pom.xml +++ b/mybatis-plus-join-test/test-join/pom.xml @@ -34,8 +34,15 @@ com.fasterxml.jackson.core jackson-core + + + + + + + @@ -47,7 +54,7 @@ com.github.yulichang mybatis-plus-join-processor - ${revision} + 1.5.1 org.projectlombok diff --git a/mybatis-plus-join-test/test-join/src/test/java/com/github/yulichang/test/join/unit/SelectFuncTest.java b/mybatis-plus-join-test/test-join/src/test/java/com/github/yulichang/test/join/unit/SelectFuncTest.java new file mode 100644 index 0000000..6c60fd5 --- /dev/null +++ b/mybatis-plus-join-test/test-join/src/test/java/com/github/yulichang/test/join/unit/SelectFuncTest.java @@ -0,0 +1,50 @@ +package com.github.yulichang.test.join.unit; + +import com.github.yulichang.test.join.dto.UserDTO; +import com.github.yulichang.test.join.entity.AddressDO; +import com.github.yulichang.test.join.entity.UserDO; +import com.github.yulichang.test.util.Reset; +import com.github.yulichang.test.util.ThreadLocalUtils; +import com.github.yulichang.toolkit.JoinWrappers; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.springframework.boot.test.context.SpringBootTest; + +import java.util.List; + +@SpringBootTest +public class SelectFuncTest { + + + @BeforeEach + void setUp() { + Reset.reset(); + } + + + @Test + void applyFunc() { + ThreadLocalUtils.set(""" + SELECT t.id, t.pid, t.`name`, t.`json`, + t.sex, t.head_img, t.create_time, t.address_id, + t.address_id2, t.del, t.create_by, t.update_by, + concat(t.id, t1.address, ?, ?) AS address + FROM `user` t LEFT JOIN address t1 ON (t1.user_id = t.id) + WHERE t.del = false AND t1.del = false + AND (concat(t.id, t1.user_id, ?) IS NOT NULL AND t.id >= ?) + """); + List list = JoinWrappers.lambda(UserDO.class) + .selectAll(UserDO.class) + .selectFunc("concat(%s,%s,{0},{1})", + arg -> arg + .accept(UserDO::getId, AddressDO::getAddress) + .values("aaa", 123), + UserDTO::getAddress) + .leftJoin(AddressDO.class, AddressDO::getUserId, UserDO::getId) + .applyFunc("concat(%s,%s,{0}) is not null", arg -> arg.accept(UserDO::getId, AddressDO::getUserId), "12") + .ge(UserDO::getId, 0) + .list(UserDTO.class); + list.forEach(System.out::println); + } + +}