third_codes/mybatis-plus-join
1
0
Fork 0
mirror of https://gitee.com/best_handsome/mybatis-plus-join synced 2025-07-11 00:02:22 +08:00
Code Issues Packages Projects Releases Wiki Activity

移除MyBaseEntity,

Browse Source 
实体类不再强制继承MyBaseEntity
This commit is contained in:
admin 2021-01-29 14:03:47 +08:00
parent 61acaab7ea
commit 9475dabae0
11 changed files with 264 additions and 273 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
src/main/java/com/github/mybatisplus/base/MyBaseEntity.java
View File

@ -1,10 +0,0 @@
package com.github.mybatisplus.base;
/**
* 所有数据库对应的entity类的父类
* 可以添加 id deleted create_by 等通用字段
*
* @author yulichang
*/
public class MyBaseEntity {
}

2
src/main/java/com/github/mybatisplus/base/MyBaseService.java
View File

@ -12,7 +12,7 @@ import java.util.Map;
* @author yulichang
* @see IService
*/
public interface MyBaseService<T extends MyBaseEntity> extends IService<T> {
public interface MyBaseService<T> extends IService<T> {
/**
* ignore

2
src/main/java/com/github/mybatisplus/base/MyBaseServiceImpl.java
View File

@ -11,7 +11,7 @@ import java.util.Map;
* @author yulichang
* @see ServiceImpl
*/
public class MyBaseServiceImpl<M extends MyBaseMapper<T>, T extends MyBaseEntity> extends ServiceImpl<M, T> implements MyBaseService<T> {
public class MyBaseServiceImpl<M extends MyBaseMapper<T>, T> extends ServiceImpl<M, T> implements MyBaseService<T> {
@Override

3
src/main/java/com/github/mybatisplus/func/MySFunction.java
View File

@ -2,7 +2,6 @@ package com.github.mybatisplus.func;
import com.baomidou.mybatisplus.core.toolkit.support.SFunction;
import com.github.mybatisplus.base.MyBaseEntity;
/**
* 支持别名的 SFunction
@ -11,6 +10,6 @@ import com.github.mybatisplus.base.MyBaseEntity;
* @see SFunction
*/
@FunctionalInterface
public interface MySFunction<T extends MyBaseEntity, R> extends SFunction<T, R> {
public interface MySFunction<T, R> extends SFunction<T, R> {
}

3
src/main/java/com/github/mybatisplus/func/MyWrapperFunc.java
View File

@ -1,13 +1,12 @@
package com.github.mybatisplus.func;
import com.github.mybatisplus.wrapper.MyLambdaQueryWrapper;
import com.github.mybatisplus.base.MyBaseEntity;
/**
* @author yulichang
*/
@FunctionalInterface
public interface MyWrapperFunc<T extends MyBaseEntity> {
public interface MyWrapperFunc<T> {
MyLambdaQueryWrapper<T> apply(MyLambdaQueryWrapper<T> wrapper);
}

5
src/main/java/com/github/mybatisplus/toolkit/MyLambdaUtils.java
View File

@ -3,7 +3,6 @@ package com.github.mybatisplus.toolkit;
import com.baomidou.mybatisplus.core.toolkit.LambdaUtils;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.core.toolkit.support.SFunction;
import com.github.mybatisplus.base.MyBaseEntity;
import com.github.mybatisplus.func.MySFunction;
import org.apache.ibatis.reflection.property.PropertyNamer;
@ -18,11 +17,11 @@ public class MyLambdaUtils {
return PropertyNamer.methodToProperty(LambdaUtils.resolve(fn).getImplMethodName());
}
public static <T extends MyBaseEntity> String getColumn(MySFunction<T, ?> fn) {
public static <T> String getColumn(MySFunction<T, ?> fn) {
return StringUtils.camelToUnderline(getName(fn));
}
public static <T extends MyBaseEntity> Class<T> getEntityClass(MySFunction<T, ?> fn) {
public static <T> Class<T> getEntityClass(MySFunction<T, ?> fn) {
return (Class<T>) LambdaUtils.resolve(fn).getImplClass();
}
}

19
src/main/java/com/github/mybatisplus/wrapper/MyJoinLambdaQueryWrapper.java
View File

@ -7,9 +7,9 @@ import com.baomidou.mybatisplus.core.metadata.TableFieldInfo;
import com.baomidou.mybatisplus.core.metadata.TableInfo;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.baomidou.mybatisplus.core.toolkit.ArrayUtils;
import com.baomidou.mybatisplus.core.toolkit.Assert;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.core.toolkit.support.SFunction;
import com.github.mybatisplus.base.MyBaseEntity;
import com.github.mybatisplus.toolkit.Constant;
import com.github.mybatisplus.toolkit.MyLambdaUtils;
import com.github.mybatisplus.wrapper.interfaces.MyJoin;
@ -30,7 +30,7 @@ import java.util.stream.Collectors;
* @see com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper
* @since 2021/01/19
*/
public class MyJoinLambdaQueryWrapper<T extends MyBaseEntity> extends MyAbstractLambdaWrapper<T, MyJoinLambdaQueryWrapper<T>>
public class MyJoinLambdaQueryWrapper<T> extends MyAbstractLambdaWrapper<T, MyJoinLambdaQueryWrapper<T>>
implements Query<MyJoinLambdaQueryWrapper<T>, T, SFunction<T, ?>>, MyJoin<MyJoinLambdaQueryWrapper<T>, T> {
protected SharedString sqlSelect = new SharedString();
@ -108,6 +108,7 @@ public class MyJoinLambdaQueryWrapper<T extends MyBaseEntity> extends MyAbstract
public MyJoinLambdaQueryWrapper<T> selectAll(Class<T> clazz) {
setEntityClass(clazz);
TableInfo info = TableInfoHelper.getTableInfo(getEntityClass());
Assert.notNull(info, "can not find table to entity %s", clazz);
info.getFieldList().forEach(s ->
selectColumnList.add(new SelectColumn(this.rUid, s.getColumn(), null, null)));
if (StringUtils.isNotBlank(info.getKeyColumn())) {
@ -158,6 +159,7 @@ public class MyJoinLambdaQueryWrapper<T extends MyBaseEntity> extends MyAbstract
public MyJoinLambdaQueryWrapper<T> select(Class<T> entityClass, Predicate<TableFieldInfo> predicate) {
this.setEntityClass(entityClass);
TableInfo info = TableInfoHelper.getTableInfo(getEntityClass());
Assert.notNull(info, "can not find table to entity %s", entityClass);
info.getFieldList().stream().filter(predicate).forEach(s ->
selectColumnList.add(new SelectColumn(this.rUid, s.getColumn(), null, null)));
return typedThis;
@ -207,7 +209,7 @@ public class MyJoinLambdaQueryWrapper<T extends MyBaseEntity> extends MyAbstract
* @param rightWrapper 子表的wrapper
*/
@Override
public <R extends MyBaseEntity, TE, RE> MyJoinLambdaQueryWrapper<T> leftJoin(boolean condition, String alias, MySFunction<T, TE> leftCondition, MySFunction<R, RE> rightCondition, Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
public <R, TE, RE> MyJoinLambdaQueryWrapper<T> leftJoin(boolean condition, String alias, MySFunction<T, TE> leftCondition, MySFunction<R, RE> rightCondition, Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
return join(condition, alias, Constant.LEFT_JOIN, leftCondition, rightCondition, rightWrapper);
}
@ -215,7 +217,7 @@ public class MyJoinLambdaQueryWrapper<T extends MyBaseEntity> extends MyAbstract
* 右连接查询(参考左连接)
*/
@Override
public <R extends MyBaseEntity, TE, RE> MyJoinLambdaQueryWrapper<T> rightJoin(boolean condition, String alias, MySFunction<T, TE> leftCondition, MySFunction<R, RE> rightCondition, Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
public <R, TE, RE> MyJoinLambdaQueryWrapper<T> rightJoin(boolean condition, String alias, MySFunction<T, TE> leftCondition, MySFunction<R, RE> rightCondition, Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
return join(condition, alias, Constant.RIGHT_JOIN, leftCondition, rightCondition, rightWrapper);
}
@ -223,15 +225,18 @@ public class MyJoinLambdaQueryWrapper<T extends MyBaseEntity> extends MyAbstract
* 内连接查询(参考左连接)
*/
@Override
public <R extends MyBaseEntity, TE, RE> MyJoinLambdaQueryWrapper<T> innerJoin(boolean condition, String alias, MySFunction<T, TE> leftCondition, MySFunction<R, RE> rightCondition, Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
public <R, TE, RE> MyJoinLambdaQueryWrapper<T> innerJoin(boolean condition, String alias, MySFunction<T, TE> leftCondition, MySFunction<R, RE> rightCondition, Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
return join(condition, alias, Constant.INNER_JOIN, leftCondition, rightCondition, rightWrapper);
}
private <R extends MyBaseEntity, TE, RE> MyJoinLambdaQueryWrapper<T> join(boolean condition, String alias, String keyWord, MySFunction<T, TE> leftCondition, MySFunction<R, RE> rightCondition, Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
private <R, TE, RE> MyJoinLambdaQueryWrapper<T> join(boolean condition, String alias, String keyWord, MySFunction<T, TE> leftCondition, MySFunction<R, RE> rightCondition, Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
if (condition) {
setEntityClass(MyLambdaUtils.getEntityClass(leftCondition));
int childrenId = rUid + 1;
classList.add(new SubTable(alias, keyWord, rUid, MyLambdaUtils.getColumn(leftCondition), childrenId, MyLambdaUtils.getColumn(rightCondition), TableInfoHelper.getTableInfo(MyLambdaUtils.getEntityClass(rightCondition)).getTableName()));
Class<R> clazz = MyLambdaUtils.getEntityClass(rightCondition);
TableInfo info = TableInfoHelper.getTableInfo(clazz);
Assert.notNull(info, "can not find table to entity %s", clazz);
classList.add(new SubTable(alias, keyWord, rUid, MyLambdaUtils.getColumn(leftCondition), childrenId, MyLambdaUtils.getColumn(rightCondition), info.getTableName()));
MyJoinLambdaQueryWrapper<R> apply = rightWrapper.apply(new MyJoinLambdaQueryWrapper<>(childrenId));
classList.addAll(apply.classList);
this.selectColumnList.addAll(apply.selectColumnList);

112
src/main/java/com/github/mybatisplus/wrapper/MyLambdaQueryWrapper.java
View File

@ -7,17 +7,14 @@ import com.baomidou.mybatisplus.core.enums.SqlKeyword;
import com.baomidou.mybatisplus.core.enums.SqlLike;
import com.baomidou.mybatisplus.core.exceptions.MybatisPlusException;
import com.baomidou.mybatisplus.core.metadata.TableFieldInfo;
import com.baomidou.mybatisplus.core.metadata.TableInfo;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.baomidou.mybatisplus.core.toolkit.ArrayUtils;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.core.toolkit.StringPool;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.core.toolkit.*;
import com.baomidou.mybatisplus.core.toolkit.sql.SqlUtils;
import com.baomidou.mybatisplus.core.toolkit.support.SFunction;
import com.github.mybatisplus.wrapper.interfaces.MyCompare;
import com.github.mybatisplus.wrapper.interfaces.MyFunc;
import com.github.mybatisplus.wrapper.interfaces.MyNested;
import com.github.mybatisplus.base.MyBaseEntity;
import com.github.mybatisplus.func.MySFunction;
import com.github.mybatisplus.toolkit.Constant;
import com.github.mybatisplus.toolkit.MyLambdaUtils;
@ -43,7 +40,7 @@ import static java.util.stream.Collectors.joining;
* @see com.baomidou.mybatisplus.core.conditions.interfaces.Func
* @since 2021/01/19
*/
public class MyLambdaQueryWrapper<T extends MyBaseEntity> extends MyJoinLambdaQueryWrapper<T>
public class MyLambdaQueryWrapper<T> extends MyJoinLambdaQueryWrapper<T>
implements MyCompare<MyLambdaQueryWrapper<T>>, MyNested<MyLambdaQueryWrapper<T>, MyLambdaQueryWrapper<T>>,
MyFunc<MyLambdaQueryWrapper<T>> {
@ -94,68 +91,71 @@ public class MyLambdaQueryWrapper<T extends MyBaseEntity> extends MyJoinLambdaQu
@Override
public <R extends MyBaseEntity, TE, RE> MyLambdaQueryWrapper<T> leftJoin(boolean condition, String alias, MySFunction<T, TE> leftCondition, MySFunction<R, RE> rightCondition, Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
public <R, TE, RE> MyLambdaQueryWrapper<T> leftJoin(boolean condition, String alias, MySFunction<T, TE> leftCondition, MySFunction<R, RE> rightCondition, Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
return join(condition, alias, Constant.LEFT_JOIN, leftCondition, rightCondition, rightWrapper);
}
@Override
public <R extends MyBaseEntity, TE, RE> MyLambdaQueryWrapper<T> leftJoin(MySFunction<T, TE> leftCondition, MySFunction<R, RE> rightCondition, Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
public <R, TE, RE> MyLambdaQueryWrapper<T> leftJoin(MySFunction<T, TE> leftCondition, MySFunction<R, RE> rightCondition, Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
return this.leftJoin(true, null, leftCondition, rightCondition, rightWrapper);
}
@Override
public <R extends MyBaseEntity, TE, RE> MyLambdaQueryWrapper<T> leftJoin(String alias, MySFunction<T, TE> leftCondition, MySFunction<R, RE> rightCondition, Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
public <R, TE, RE> MyLambdaQueryWrapper<T> leftJoin(String alias, MySFunction<T, TE> leftCondition, MySFunction<R, RE> rightCondition, Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
return this.leftJoin(true, alias, leftCondition, rightCondition, rightWrapper);
}
@Override
public <R extends MyBaseEntity, TE, RE> MyLambdaQueryWrapper<T> leftJoin(boolean condition, MySFunction<T, TE> leftCondition, MySFunction<R, RE> rightCondition, Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
public <R, TE, RE> MyLambdaQueryWrapper<T> leftJoin(boolean condition, MySFunction<T, TE> leftCondition, MySFunction<R, RE> rightCondition, Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
return this.leftJoin(condition, null, leftCondition, rightCondition, rightWrapper);
}
public <R extends MyBaseEntity, TE, RE> MyLambdaQueryWrapper<T> rightJoin(boolean condition, String alias, MySFunction<T, TE> leftCondition, MySFunction<R, RE> rightCondition, Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
public <R, TE, RE> MyLambdaQueryWrapper<T> rightJoin(boolean condition, String alias, MySFunction<T, TE> leftCondition, MySFunction<R, RE> rightCondition, Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
return join(condition, alias, Constant.RIGHT_JOIN, leftCondition, rightCondition, rightWrapper);
}
@Override
public <R extends MyBaseEntity, TE, RE> MyLambdaQueryWrapper<T> rightJoin(MySFunction<T, TE> leftCondition, MySFunction<R, RE> rightCondition, Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
public <R, TE, RE> MyLambdaQueryWrapper<T> rightJoin(MySFunction<T, TE> leftCondition, MySFunction<R, RE> rightCondition, Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
return this.rightJoin(true, null, leftCondition, rightCondition, rightWrapper);
}
@Override
public <R extends MyBaseEntity, TE, RE> MyLambdaQueryWrapper<T> rightJoin(String alias, MySFunction<T, TE> leftCondition, MySFunction<R, RE> rightCondition, Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
public <R, TE, RE> MyLambdaQueryWrapper<T> rightJoin(String alias, MySFunction<T, TE> leftCondition, MySFunction<R, RE> rightCondition, Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
return this.rightJoin(true, alias, leftCondition, rightCondition, rightWrapper);
}
@Override
public <R extends MyBaseEntity, TE, RE> MyLambdaQueryWrapper<T> rightJoin(boolean condition, MySFunction<T, TE> leftCondition, MySFunction<R, RE> rightCondition, Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
public <R, TE, RE> MyLambdaQueryWrapper<T> rightJoin(boolean condition, MySFunction<T, TE> leftCondition, MySFunction<R, RE> rightCondition, Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
return this.rightJoin(condition, null, leftCondition, rightCondition, rightWrapper);
}
public <R extends MyBaseEntity, TE, RE> MyLambdaQueryWrapper<T> innerJoin(boolean condition, String alias, MySFunction<T, TE> leftCondition, MySFunction<R, RE> rightCondition, Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
public <R, TE, RE> MyLambdaQueryWrapper<T> innerJoin(boolean condition, String alias, MySFunction<T, TE> leftCondition, MySFunction<R, RE> rightCondition, Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
return join(condition, alias, Constant.INNER_JOIN, leftCondition, rightCondition, rightWrapper);
}
@Override
public <R extends MyBaseEntity, TE, RE> MyLambdaQueryWrapper<T> innerJoin(MySFunction<T, TE> leftCondition, MySFunction<R, RE> rightCondition, Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
public <R, TE, RE> MyLambdaQueryWrapper<T> innerJoin(MySFunction<T, TE> leftCondition, MySFunction<R, RE> rightCondition, Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
return this.innerJoin(true, null, leftCondition, rightCondition, rightWrapper);
}
@Override
public <R extends MyBaseEntity, TE, RE> MyLambdaQueryWrapper<T> innerJoin(String alias, MySFunction<T, TE> leftCondition, MySFunction<R, RE> rightCondition, Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
public <R, TE, RE> MyLambdaQueryWrapper<T> innerJoin(String alias, MySFunction<T, TE> leftCondition, MySFunction<R, RE> rightCondition, Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
return this.innerJoin(true, alias, leftCondition, rightCondition, rightWrapper);
}
@Override
public <R extends MyBaseEntity, TE, RE> MyLambdaQueryWrapper<T> innerJoin(boolean condition, MySFunction<T, TE> leftCondition, MySFunction<R, RE> rightCondition, Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
public <R, TE, RE> MyLambdaQueryWrapper<T> innerJoin(boolean condition, MySFunction<T, TE> leftCondition, MySFunction<R, RE> rightCondition, Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
return this.innerJoin(condition, null, leftCondition, rightCondition, rightWrapper);
}
private <R extends MyBaseEntity, TE, RE> MyLambdaQueryWrapper<T> join(boolean condition, String alias, String keyWord, MySFunction<T, TE> leftCondition, MySFunction<R, RE> rightCondition, Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
private <R, TE, RE> MyLambdaQueryWrapper<T> join(boolean condition, String alias, String keyWord, MySFunction<T, TE> leftCondition, MySFunction<R, RE> rightCondition, Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
if (condition) {
setEntityClass(MyLambdaUtils.getEntityClass(leftCondition));
classList.add(new SubTable(alias, keyWord, rUid, MyLambdaUtils.getColumn(leftCondition), classList.size() + 1, MyLambdaUtils.getColumn(rightCondition), TableInfoHelper.getTableInfo(MyLambdaUtils.getEntityClass(rightCondition)).getTableName()));
Class<R> clazz = MyLambdaUtils.getEntityClass(rightCondition);
TableInfo info = TableInfoHelper.getTableInfo(clazz);
Assert.notNull(info, "can not find table to entity %s", clazz);
classList.add(new SubTable(alias, keyWord, rUid, MyLambdaUtils.getColumn(leftCondition), classList.size() + 1, MyLambdaUtils.getColumn(rightCondition), info.getTableName()));
MyJoinLambdaQueryWrapper<R> apply = rightWrapper.apply(new MyJoinLambdaQueryWrapper<>(classList.size()));
classList.addAll(apply.classList);
this.selectColumnList.addAll(apply.selectColumnList);
@ -285,11 +285,13 @@ public class MyLambdaQueryWrapper<T extends MyBaseEntity> extends MyJoinLambdaQu
/**
* 获取表前缀
*/
private String getClassTablePrefix(Class<?> tag) {
if (getEntityClass() == tag) {
private String getClassTablePrefix(Class<?> clazz) {
if (getEntityClass() == clazz) {
return Constant.TABLE_ALIAS + rUid;
} else {
String tableName = TableInfoHelper.getTableInfo(tag).getTableName();
TableInfo info = TableInfoHelper.getTableInfo(clazz);
Assert.notNull(info, "can not find table to entity %s", clazz);
String tableName = info.getTableName();
for (SubTable sub : classList) {
if (sub.getRightTableName().equals(tableName)) {
return Constant.TABLE_ALIAS + sub.getRightUid();
@ -302,7 +304,7 @@ public class MyLambdaQueryWrapper<T extends MyBaseEntity> extends MyJoinLambdaQu
/**
* 获取column
*/
private <E extends MyBaseEntity, F> String getColumn(MySFunction<E, F> column, String alias) {
private <E, F> String getColumn(MySFunction<E, F> column, String alias) {
if (alias != null) {
if (alias.equals(DEFAULT_ALIAS)) {
return Constant.TABLE_ALIAS + rUid + StringPool.DOT + column2String(column, true);
@ -316,100 +318,100 @@ public class MyLambdaQueryWrapper<T extends MyBaseEntity> extends MyJoinLambdaQu
return getClassTablePrefix(MyLambdaUtils.getEntityClass(column)) + StringPool.DOT + column2String(column, true);
}
private <E extends MyBaseEntity, F> String getColumn(String alias, MySFunction<E, F>... column) {
private <E, F> String getColumn(String alias, MySFunction<E, F>... column) {
return Arrays.stream(column).map(i -> getColumn(i, alias)).collect(joining(StringPool.COMMA));
}
@Override
public <E extends MyBaseEntity, F> MyLambdaQueryWrapper<T> eq(boolean condition, String alias, MySFunction<E, F> column, Object val) {
public <E, F> MyLambdaQueryWrapper<T> eq(boolean condition, String alias, MySFunction<E, F> column, Object val) {
return doIt(condition, () -> getColumn(column, alias), EQ,
() -> formatSql("{0}", val));
}
@Override
public <E extends MyBaseEntity, F, X extends MyBaseEntity, Y> MyLambdaQueryWrapper<T> eq(boolean condition, String alias, MySFunction<E, F> column, String as, MySFunction<X, Y> val) {
public <E, F, X, Y> MyLambdaQueryWrapper<T> eq(boolean condition, String alias, MySFunction<E, F> column, String as, MySFunction<X, Y> val) {
return doIt(condition, () -> getColumn(column, alias), EQ, () -> getColumn(val, as));
}
@Override
public <E extends MyBaseEntity, F> MyLambdaQueryWrapper<T> ne(boolean condition, String alias, MySFunction<E, F> column, Object val) {
public <E, F> MyLambdaQueryWrapper<T> ne(boolean condition, String alias, MySFunction<E, F> column, Object val) {
return doIt(condition, () -> getColumn(column, alias), NE, () -> formatSql("{0}", val));
}
@Override
public <E extends MyBaseEntity, F, X extends MyBaseEntity, Y> MyLambdaQueryWrapper<T> ne(boolean condition, String alias, MySFunction<E, F> column, String as, MySFunction<X, Y> val) {
public <E, F, X, Y> MyLambdaQueryWrapper<T> ne(boolean condition, String alias, MySFunction<E, F> column, String as, MySFunction<X, Y> val) {
return doIt(condition, () -> getColumn(column, alias), NE, () -> getColumn(val, as));
}
@Override
public <E extends MyBaseEntity, F> MyLambdaQueryWrapper<T> gt(boolean condition, String alias, MySFunction<E, F> column, Object val) {
public <E, F> MyLambdaQueryWrapper<T> gt(boolean condition, String alias, MySFunction<E, F> column, Object val) {
return doIt(condition, () -> getColumn(column, alias), GT, () -> formatSql("{0}", val));
}
@Override
public <E extends MyBaseEntity, F, X extends MyBaseEntity, Y> MyLambdaQueryWrapper<T> gt(boolean condition, String alias, MySFunction<E, F> column, String as, MySFunction<X, Y> val) {
public <E, F, X, Y> MyLambdaQueryWrapper<T> gt(boolean condition, String alias, MySFunction<E, F> column, String as, MySFunction<X, Y> val) {
return doIt(condition, () -> getColumn(column, alias), GT, () -> getColumn(val, as));
}
@Override
public <E extends MyBaseEntity, F> MyLambdaQueryWrapper<T> ge(boolean condition, String alias, MySFunction<E, F> column, Object val) {
public <E, F> MyLambdaQueryWrapper<T> ge(boolean condition, String alias, MySFunction<E, F> column, Object val) {
return doIt(condition, () -> getColumn(column, alias), GE, () -> formatSql("{0}", val));
}
@Override
public <E extends MyBaseEntity, F, X extends MyBaseEntity, Y> MyLambdaQueryWrapper<T> ge(boolean condition, String alias, MySFunction<E, F> column, String as, MySFunction<X, Y> val) {
public <E, F, X, Y> MyLambdaQueryWrapper<T> ge(boolean condition, String alias, MySFunction<E, F> column, String as, MySFunction<X, Y> val) {
return doIt(condition, () -> getColumn(column, alias), GE, () -> getColumn(val, as));
}
@Override
public <E extends MyBaseEntity, F> MyLambdaQueryWrapper<T> lt(boolean condition, String alias, MySFunction<E, F> column, Object val) {
public <E, F> MyLambdaQueryWrapper<T> lt(boolean condition, String alias, MySFunction<E, F> column, Object val) {
return doIt(condition, () -> getColumn(column, alias), LT, () -> formatSql("{0}", val));
}
@Override
public <E extends MyBaseEntity, F, X extends MyBaseEntity, Y> MyLambdaQueryWrapper<T> lt(boolean condition, String alias, MySFunction<E, F> column, String as, MySFunction<X, Y> val) {
public <E, F, X, Y> MyLambdaQueryWrapper<T> lt(boolean condition, String alias, MySFunction<E, F> column, String as, MySFunction<X, Y> val) {
return doIt(condition, () -> getColumn(column, alias), LT, () -> getColumn(val, as));
}
@Override
public <E extends MyBaseEntity, F> MyLambdaQueryWrapper<T> le(boolean condition, String alias, MySFunction<E, F> column, Object val) {
public <E, F> MyLambdaQueryWrapper<T> le(boolean condition, String alias, MySFunction<E, F> column, Object val) {
return doIt(condition, () -> getColumn(column, alias), LE, () -> formatSql("{0}", val));
}
@Override
public <E extends MyBaseEntity, F, X extends MyBaseEntity, Y> MyLambdaQueryWrapper<T> le(boolean condition, String alias, MySFunction<E, F> column, String as, MySFunction<X, Y> val) {
public <E, F, X, Y> MyLambdaQueryWrapper<T> le(boolean condition, String alias, MySFunction<E, F> column, String as, MySFunction<X, Y> val) {
return doIt(condition, () -> getColumn(column, alias), LE, () -> getColumn(val, as));
}
@Override
public <E extends MyBaseEntity, F> MyLambdaQueryWrapper<T> between(boolean condition, String alias, MySFunction<E, F> column, Object val1, Object val2) {
public <E, F> MyLambdaQueryWrapper<T> between(boolean condition, String alias, MySFunction<E, F> column, Object val1, Object val2) {
return doIt(condition, () -> getColumn(column, alias), BETWEEN, () -> formatSql("{0}", val1), AND,
() -> formatSql("{0}", val2));
}
@Override
public <E extends MyBaseEntity, F> MyLambdaQueryWrapper<T> notBetween(boolean condition, String alias, MySFunction<E, F> column, Object val1, Object val2) {
public <E, F> MyLambdaQueryWrapper<T> notBetween(boolean condition, String alias, MySFunction<E, F> column, Object val1, Object val2) {
return doIt(condition, () -> getColumn(column, alias), NOT_BETWEEN, () -> formatSql("{0}", val1), AND,
() -> formatSql("{0}", val2));
}
@Override
public <E extends MyBaseEntity, F> MyLambdaQueryWrapper<T> like(boolean condition, String alias, MySFunction<E, F> column, Object val) {
public <E, F> MyLambdaQueryWrapper<T> like(boolean condition, String alias, MySFunction<E, F> column, Object val) {
return likeValue(condition, LIKE, getColumn(column, alias), val, SqlLike.DEFAULT);
}
@Override
public <E extends MyBaseEntity, F> MyLambdaQueryWrapper<T> notLike(boolean condition, String alias, MySFunction<E, F> column, Object val) {
public <E, F> MyLambdaQueryWrapper<T> notLike(boolean condition, String alias, MySFunction<E, F> column, Object val) {
return likeValue(condition, NOT_LIKE, getColumn(column, alias), val, SqlLike.DEFAULT);
}
@Override
public <E extends MyBaseEntity, F> MyLambdaQueryWrapper<T> likeLeft(boolean condition, String alias, MySFunction<E, F> column, Object val) {
public <E, F> MyLambdaQueryWrapper<T> likeLeft(boolean condition, String alias, MySFunction<E, F> column, Object val) {
return likeValue(condition, LIKE, getColumn(column, alias), val, SqlLike.LEFT);
}
@Override
public <E extends MyBaseEntity, F> MyLambdaQueryWrapper<T> likeRight(boolean condition, String alias, MySFunction<E, F> column, Object val) {
public <E, F> MyLambdaQueryWrapper<T> likeRight(boolean condition, String alias, MySFunction<E, F> column, Object val) {
return likeValue(condition, LIKE, getColumn(column, alias), val, SqlLike.RIGHT);
}
@ -453,11 +455,11 @@ public class MyLambdaQueryWrapper<T extends MyBaseEntity> extends MyJoinLambdaQu
return this;
}
private <E extends MyBaseEntity, F> MyLambdaQueryWrapper<T> likeValue(boolean condition, SqlKeyword keyword, String column, Object val, SqlLike sqlLike) {
private <E, F> MyLambdaQueryWrapper<T> likeValue(boolean condition, SqlKeyword keyword, String column, Object val, SqlLike sqlLike) {
return doIt(condition, () -> column, keyword, () -> formatSql("{0}", SqlUtils.concatLike(val, sqlLike)));
}
protected <E extends MyBaseEntity, F> MyLambdaQueryWrapper<T> addCondition(boolean condition, String column, SqlKeyword sqlKeyword, Object val) {
protected <E, F> MyLambdaQueryWrapper<T> addCondition(boolean condition, String column, SqlKeyword sqlKeyword, Object val) {
return doIt(condition, () -> column, sqlKeyword, () -> formatSql("{0}", val));
}
@ -476,37 +478,37 @@ public class MyLambdaQueryWrapper<T extends MyBaseEntity> extends MyJoinLambdaQu
}
@Override
public <E extends MyBaseEntity, F> MyLambdaQueryWrapper<T> isNull(boolean condition, String alias, MySFunction<E, F> column) {
public <E, F> MyLambdaQueryWrapper<T> isNull(boolean condition, String alias, MySFunction<E, F> column) {
return doIt(condition, () -> getColumn(column, alias), IS_NULL);
}
@Override
public <E extends MyBaseEntity, F> MyLambdaQueryWrapper<T> isNotNull(boolean condition, String alias, MySFunction<E, F> column) {
public <E, F> MyLambdaQueryWrapper<T> isNotNull(boolean condition, String alias, MySFunction<E, F> column) {
return doIt(condition, () -> getColumn(column, alias), IS_NOT_NULL);
}
@Override
public <E extends MyBaseEntity, F> MyLambdaQueryWrapper<T> in(boolean condition, String alias, MySFunction<E, F> column, Collection<?> coll) {
public <E, F> MyLambdaQueryWrapper<T> in(boolean condition, String alias, MySFunction<E, F> column, Collection<?> coll) {
return doIt(condition, () -> getColumn(column, alias), IN, inExpression(coll));
}
@Override
public <E extends MyBaseEntity, F> MyLambdaQueryWrapper<T> notIn(boolean condition, String alias, MySFunction<E, F> column, Collection<?> coll) {
public <E, F> MyLambdaQueryWrapper<T> notIn(boolean condition, String alias, MySFunction<E, F> column, Collection<?> coll) {
return doIt(condition, () -> getColumn(column, alias), NOT_IN, inExpression(coll));
}
@Override
public <E extends MyBaseEntity, F> MyLambdaQueryWrapper<T> inSql(boolean condition, String alias, MySFunction<E, F> column, String inValue) {
public <E, F> MyLambdaQueryWrapper<T> inSql(boolean condition, String alias, MySFunction<E, F> column, String inValue) {
return doIt(condition, () -> getColumn(column, alias), IN, () -> String.format("(%s)", inValue));
}
@Override
public <E extends MyBaseEntity, F> MyLambdaQueryWrapper<T> notInSql(boolean condition, String alias, MySFunction<E, F> column, String inValue) {
public <E, F> MyLambdaQueryWrapper<T> notInSql(boolean condition, String alias, MySFunction<E, F> column, String inValue) {
return doIt(condition, () -> getColumn(column, alias), NOT_IN, () -> String.format("(%s)", inValue));
}
@Override
public <E extends MyBaseEntity, F> MyLambdaQueryWrapper<T> groupBy(boolean condition, String alias, MySFunction<E, F>... columns) {
public <E, F> MyLambdaQueryWrapper<T> groupBy(boolean condition, String alias, MySFunction<E, F>... columns) {
if (ArrayUtils.isEmpty(columns)) {
return this;
}
@ -515,7 +517,7 @@ public class MyLambdaQueryWrapper<T extends MyBaseEntity> extends MyJoinLambdaQu
}
@Override
public <E extends MyBaseEntity, F> MyLambdaQueryWrapper<T> orderBy(boolean condition, String alias, boolean isAsc, MySFunction<E, F>... columns) {
public <E, F> MyLambdaQueryWrapper<T> orderBy(boolean condition, String alias, boolean isAsc, MySFunction<E, F>... columns) {
if (ArrayUtils.isEmpty(columns)) {
return this;
}
@ -527,12 +529,12 @@ public class MyLambdaQueryWrapper<T extends MyBaseEntity> extends MyJoinLambdaQu
}
@Override
public <E extends MyBaseEntity, F> MyLambdaQueryWrapper<T> having(boolean condition, String alias, String sqlHaving, Object... params) {
public <E, F> MyLambdaQueryWrapper<T> having(boolean condition, String alias, String sqlHaving, Object... params) {
return doIt(condition, HAVING, () -> formatSqlIfNeed(condition, sqlHaving, params));
}
@Override
public <E extends MyBaseEntity, F> MyLambdaQueryWrapper<T> func(boolean condition, String alias, Consumer<MyLambdaQueryWrapper<T>> consumer) {
public <E, F> MyLambdaQueryWrapper<T> func(boolean condition, String alias, Consumer<MyLambdaQueryWrapper<T>> consumer) {
if (condition) {
consumer.accept(this);
}

193
src/main/java/com/github/mybatisplus/wrapper/interfaces/MyCompare.java
View File

@ -1,6 +1,5 @@
package com.github.mybatisplus.wrapper.interfaces;
import com.github.mybatisplus.base.MyBaseEntity;
import com.github.mybatisplus.func.MySFunction;
import java.io.Serializable;
@ -14,47 +13,47 @@ public interface MyCompare<Children> extends Serializable {
/* ***************************************** eq start ********************************************* */
<E extends MyBaseEntity, F> Children eq(boolean condition, String alias, MySFunction<E, F> column, Object val);
<E, F> Children eq(boolean condition, String alias, MySFunction<E, F> column, Object val);
default <E extends MyBaseEntity, F> Children eq(boolean condition, MySFunction<E, F> column, Object val) {
default <E, F> Children eq(boolean condition, MySFunction<E, F> column, Object val) {
return eq(condition, null, column, val);
}
default <E extends MyBaseEntity, F> Children eq(String alias, MySFunction<E, F> column, Object val) {
default <E, F> Children eq(String alias, MySFunction<E, F> column, Object val) {
return eq(true, alias, column, val);
}
default <E extends MyBaseEntity, F> Children eq(MySFunction<E, F> column, Object val) {
default <E, F> Children eq(MySFunction<E, F> column, Object val) {
return eq(true, null, column, val);
}
<E extends MyBaseEntity, F, X extends MyBaseEntity, Y> Children eq(boolean condition, String alias, MySFunction<E, F> column, String as, MySFunction<X, Y> val);
<E, F, X, Y> Children eq(boolean condition, String alias, MySFunction<E, F> column, String as, MySFunction<X, Y> val);
default <E extends MyBaseEntity, F, X extends MyBaseEntity, Y> Children eq(MySFunction<E, F> column, MySFunction<X, Y> val) {
default <E, F, X, Y> Children eq(MySFunction<E, F> column, MySFunction<X, Y> val) {
return eq(true, null, column, null, val);
}
default <E extends MyBaseEntity, F, X extends MyBaseEntity, Y> Children eq(Boolean condition, MySFunction<E, F> column, MySFunction<X, Y> val) {
default <E, F, X, Y> Children eq(Boolean condition, MySFunction<E, F> column, MySFunction<X, Y> val) {
return eq(condition, null, column, null, val);
}
default <E extends MyBaseEntity, F, X extends MyBaseEntity, Y> Children eq(String alias, MySFunction<E, F> column, MySFunction<X, Y> val) {
default <E, F, X, Y> Children eq(String alias, MySFunction<E, F> column, MySFunction<X, Y> val) {
return eq(true, alias, column, null, val);
}
default <E extends MyBaseEntity, F, X extends MyBaseEntity, Y> Children eq(MySFunction<E, F> column, String as, MySFunction<X, Y> val) {
default <E, F, X, Y> Children eq(MySFunction<E, F> column, String as, MySFunction<X, Y> val) {
return eq(true, null, column, as, val);
}
default <E extends MyBaseEntity, F, X extends MyBaseEntity, Y> Children eq(Boolean condition, String alias, MySFunction<E, F> column, MySFunction<X, Y> val) {
default <E, F, X, Y> Children eq(Boolean condition, String alias, MySFunction<E, F> column, MySFunction<X, Y> val) {
return eq(condition, alias, column, null, val);
}
default <E extends MyBaseEntity, F, X extends MyBaseEntity, Y> Children eq(Boolean condition, MySFunction<E, F> column, String as, MySFunction<X, Y> val) {
default <E, F, X, Y> Children eq(Boolean condition, MySFunction<E, F> column, String as, MySFunction<X, Y> val) {
return eq(condition, null, column, as, val);
}
default <E extends MyBaseEntity, F, X extends MyBaseEntity, Y> Children eq(String alias, MySFunction<E, F> column, String as, MySFunction<X, Y> val) {
default <E, F, X, Y> Children eq(String alias, MySFunction<E, F> column, String as, MySFunction<X, Y> val) {
return eq(true, alias, column, as, val);
}
@ -63,98 +62,98 @@ public interface MyCompare<Children> extends Serializable {
/* ***************************************** ne start ********************************************* */
default <E extends MyBaseEntity, F> Children ne(MySFunction<E, F> column, Object val) {
default <E, F> Children ne(MySFunction<E, F> column, Object val) {
return ne(true, null, column, val);
}
default <E extends MyBaseEntity, F> Children ne(boolean condition, MySFunction<E, F> column, Object val) {
default <E, F> Children ne(boolean condition, MySFunction<E, F> column, Object val) {
return ne(condition, null, column, val);
}
default <E extends MyBaseEntity, F> Children ne(String alias, MySFunction<E, F> column, Object val) {
default <E, F> Children ne(String alias, MySFunction<E, F> column, Object val) {
return ne(true, alias, column, val);
}
<E extends MyBaseEntity, F> Children ne(boolean condition, String alias, MySFunction<E, F> column, Object val);
<E, F> Children ne(boolean condition, String alias, MySFunction<E, F> column, Object val);
default <E extends MyBaseEntity, F, X extends MyBaseEntity, Y> Children ne(MySFunction<E, F> column, MySFunction<X, Y> val) {
default <E, F, X, Y> Children ne(MySFunction<E, F> column, MySFunction<X, Y> val) {
return ne(true, null, column, null, val);
}
default <E extends MyBaseEntity, F, X extends MyBaseEntity, Y> Children ne(boolean condition, MySFunction<E, F> column, MySFunction<X, Y> val) {
default <E, F, X, Y> Children ne(boolean condition, MySFunction<E, F> column, MySFunction<X, Y> val) {
return ne(condition, null, column, null, val);
}
default <E extends MyBaseEntity, F, X extends MyBaseEntity, Y> Children ne(String alias, MySFunction<E, F> column, MySFunction<X, Y> val) {
default <E, F, X, Y> Children ne(String alias, MySFunction<E, F> column, MySFunction<X, Y> val) {
return ne(true, alias, column, null, val);
}
default <E extends MyBaseEntity, F, X extends MyBaseEntity, Y> Children ne(MySFunction<E, F> column, String as, MySFunction<X, Y> val) {
default <E, F, X, Y> Children ne(MySFunction<E, F> column, String as, MySFunction<X, Y> val) {
return ne(true, null, column, as, val);
}
default <E extends MyBaseEntity, F, X extends MyBaseEntity, Y> Children ne(boolean condition, String alias, MySFunction<E, F> column, MySFunction<X, Y> val) {
default <E, F, X, Y> Children ne(boolean condition, String alias, MySFunction<E, F> column, MySFunction<X, Y> val) {
return ne(condition, alias, column, null, val);
}
default <E extends MyBaseEntity, F, X extends MyBaseEntity, Y> Children ne(String alias, MySFunction<E, F> column, String as, MySFunction<X, Y> val) {
default <E, F, X, Y> Children ne(String alias, MySFunction<E, F> column, String as, MySFunction<X, Y> val) {
return ne(true, alias, column, as, val);
}
default <E extends MyBaseEntity, F, X extends MyBaseEntity, Y> Children ne(boolean condition, MySFunction<E, F> column, String as, MySFunction<X, Y> val) {
default <E, F, X, Y> Children ne(boolean condition, MySFunction<E, F> column, String as, MySFunction<X, Y> val) {
return ne(condition, null, column, as, val);
}
<E extends MyBaseEntity, F, X extends MyBaseEntity, Y> Children ne(boolean condition, String alias, MySFunction<E, F> column, String as, MySFunction<X, Y> val);
<E, F, X, Y> Children ne(boolean condition, String alias, MySFunction<E, F> column, String as, MySFunction<X, Y> val);
/* ***************************************** ne end ********************************************* */
/* ***************************************** gt start ********************************************* */
default <E extends MyBaseEntity, F> Children gt(MySFunction<E, F> column, Object val) {
default <E, F> Children gt(MySFunction<E, F> column, Object val) {
return gt(true, null, column, val);
}
default <E extends MyBaseEntity, F> Children gt(boolean condition, MySFunction<E, F> column, Object val) {
default <E, F> Children gt(boolean condition, MySFunction<E, F> column, Object val) {
return gt(condition, null, column, val);
}
default <E extends MyBaseEntity, F> Children gt(String alias, MySFunction<E, F> column, Object val) {
default <E, F> Children gt(String alias, MySFunction<E, F> column, Object val) {
return gt(true, alias, column, val);
}
<E extends MyBaseEntity, F> Children gt(boolean condition, String alias, MySFunction<E, F> column, Object val);
<E, F> Children gt(boolean condition, String alias, MySFunction<E, F> column, Object val);
default <E extends MyBaseEntity, F, X extends MyBaseEntity, Y> Children gt(MySFunction<E, F> column, MySFunction<X, Y> val) {
default <E, F, X, Y> Children gt(MySFunction<E, F> column, MySFunction<X, Y> val) {
return gt(true, null, column, null, val);
}
default <E extends MyBaseEntity, F, X extends MyBaseEntity, Y> Children gt(boolean condition, MySFunction<E, F> column, MySFunction<X, Y> val) {
default <E, F, X, Y> Children gt(boolean condition, MySFunction<E, F> column, MySFunction<X, Y> val) {
return gt(condition, null, column, null, val);
}
default <E extends MyBaseEntity, F, X extends MyBaseEntity, Y> Children gt(String alias, MySFunction<E, F> column, MySFunction<X, Y> val) {
default <E, F, X, Y> Children gt(String alias, MySFunction<E, F> column, MySFunction<X, Y> val) {
return gt(true, alias, column, null, val);
}
default <E extends MyBaseEntity, F, X extends MyBaseEntity, Y> Children gt(MySFunction<E, F> column, String as, MySFunction<X, Y> val) {
default <E, F, X, Y> Children gt(MySFunction<E, F> column, String as, MySFunction<X, Y> val) {
return gt(true, null, column, as, val);
}
default <E extends MyBaseEntity, F, X extends MyBaseEntity, Y> Children gt(boolean condition, String alias, MySFunction<E, F> column, MySFunction<X, Y> val) {
default <E, F, X, Y> Children gt(boolean condition, String alias, MySFunction<E, F> column, MySFunction<X, Y> val) {
return gt(condition, alias, column, null, val);
}
default <E extends MyBaseEntity, F, X extends MyBaseEntity, Y> Children gt(String alias, MySFunction<E, F> column, String as, MySFunction<X, Y> val) {
default <E, F, X, Y> Children gt(String alias, MySFunction<E, F> column, String as, MySFunction<X, Y> val) {
return gt(true, alias, column, as, val);
}
default <E extends MyBaseEntity, F, X extends MyBaseEntity, Y> Children gt(boolean condition, MySFunction<E, F> column, String as, MySFunction<X, Y> val) {
default <E, F, X, Y> Children gt(boolean condition, MySFunction<E, F> column, String as, MySFunction<X, Y> val) {
return gt(condition, null, column, as, val);
}
<E extends MyBaseEntity, F, X extends MyBaseEntity, Y> Children gt(boolean condition, String alias, MySFunction<E, F> column, String as, MySFunction<X, Y> val);
<E, F, X, Y> Children gt(boolean condition, String alias, MySFunction<E, F> column, String as, MySFunction<X, Y> val);
/* ***************************************** gt end ********************************************* */
@ -162,241 +161,241 @@ public interface MyCompare<Children> extends Serializable {
/* ***************************************** ge start ********************************************* */
default <E extends MyBaseEntity, F> Children ge(MySFunction<E, F> column, Object val) {
default <E, F> Children ge(MySFunction<E, F> column, Object val) {
return ge(true, null, column, val);
}
default <E extends MyBaseEntity, F> Children ge(boolean condition, MySFunction<E, F> column, Object val) {
default <E, F> Children ge(boolean condition, MySFunction<E, F> column, Object val) {
return ge(condition, null, column, val);
}
default <E extends MyBaseEntity, F> Children ge(String alias, MySFunction<E, F> column, Object val) {
default <E, F> Children ge(String alias, MySFunction<E, F> column, Object val) {
return ge(true, alias, column, val);
}
<E extends MyBaseEntity, F> Children ge(boolean condition, String alias, MySFunction<E, F> column, Object val);
<E, F> Children ge(boolean condition, String alias, MySFunction<E, F> column, Object val);
default <E extends MyBaseEntity, F, X extends MyBaseEntity, Y> Children ge(MySFunction<E, F> column, MySFunction<X, Y> val) {
default <E, F, X, Y> Children ge(MySFunction<E, F> column, MySFunction<X, Y> val) {
return ge(true, null, column, null, val);
}
default <E extends MyBaseEntity, F, X extends MyBaseEntity, Y> Children ge(boolean condition, MySFunction<E, F> column, MySFunction<X, Y> val) {
default <E, F, X, Y> Children ge(boolean condition, MySFunction<E, F> column, MySFunction<X, Y> val) {
return ge(condition, null, column, null, val);
}
default <E extends MyBaseEntity, F, X extends MyBaseEntity, Y> Children ge(String alias, MySFunction<E, F> column, MySFunction<X, Y> val) {
default <E, F, X, Y> Children ge(String alias, MySFunction<E, F> column, MySFunction<X, Y> val) {
return ge(true, alias, column, null, val);
}
default <E extends MyBaseEntity, F, X extends MyBaseEntity, Y> Children ge(MySFunction<E, F> column, String as, MySFunction<X, Y> val) {
default <E, F, X, Y> Children ge(MySFunction<E, F> column, String as, MySFunction<X, Y> val) {
return ge(true, null, column, as, val);
}
default <E extends MyBaseEntity, F, X extends MyBaseEntity, Y> Children ge(boolean condition, String alias, MySFunction<E, F> column, MySFunction<X, Y> val) {
default <E, F, X, Y> Children ge(boolean condition, String alias, MySFunction<E, F> column, MySFunction<X, Y> val) {
return ge(condition, alias, column, null, val);
}
default <E extends MyBaseEntity, F, X extends MyBaseEntity, Y> Children ge(String alias, MySFunction<E, F> column, String as, MySFunction<X, Y> val) {
default <E, F, X, Y> Children ge(String alias, MySFunction<E, F> column, String as, MySFunction<X, Y> val) {
return ge(true, alias, column, as, val);
}
default <E extends MyBaseEntity, F, X extends MyBaseEntity, Y> Children ge(boolean condition, MySFunction<E, F> column, String as, MySFunction<X, Y> val) {
default <E, F, X, Y> Children ge(boolean condition, MySFunction<E, F> column, String as, MySFunction<X, Y> val) {
return ge(condition, null, column, as, val);
}
<E extends MyBaseEntity, F, X extends MyBaseEntity, Y> Children ge(boolean condition, String alias, MySFunction<E, F> column, String as, MySFunction<X, Y> val);
<E, F, X, Y> Children ge(boolean condition, String alias, MySFunction<E, F> column, String as, MySFunction<X, Y> val);
/* ***************************************** ge end ********************************************* */
/* ***************************************** lt start ********************************************* */
default <E extends MyBaseEntity, F> Children lt(MySFunction<E, F> column, Object val) {
default <E, F> Children lt(MySFunction<E, F> column, Object val) {
return lt(true, null, column, val);
}
default <E extends MyBaseEntity, F> Children lt(boolean condition, MySFunction<E, F> column, Object val) {
default <E, F> Children lt(boolean condition, MySFunction<E, F> column, Object val) {
return lt(condition, null, column, val);
}
default <E extends MyBaseEntity, F> Children lt(String alias, MySFunction<E, F> column, Object val) {
default <E, F> Children lt(String alias, MySFunction<E, F> column, Object val) {
return lt(true, alias, column, val);
}
<E extends MyBaseEntity, F> Children lt(boolean condition, String alias, MySFunction<E, F> column, Object val);
<E, F> Children lt(boolean condition, String alias, MySFunction<E, F> column, Object val);
default <E extends MyBaseEntity, F, X extends MyBaseEntity, Y> Children lt(MySFunction<E, F> column, MySFunction<X, Y> val) {
default <E, F, X, Y> Children lt(MySFunction<E, F> column, MySFunction<X, Y> val) {
return lt(true, null, column, null, val);
}
default <E extends MyBaseEntity, F, X extends MyBaseEntity, Y> Children lt(boolean condition, MySFunction<E, F> column, MySFunction<X, Y> val) {
default <E, F, X, Y> Children lt(boolean condition, MySFunction<E, F> column, MySFunction<X, Y> val) {
return lt(condition, null, column, null, val);
}
default <E extends MyBaseEntity, F, X extends MyBaseEntity, Y> Children lt(String alias, MySFunction<E, F> column, MySFunction<X, Y> val) {
default <E, F, X, Y> Children lt(String alias, MySFunction<E, F> column, MySFunction<X, Y> val) {
return lt(true, alias, column, null, val);
}
default <E extends MyBaseEntity, F, X extends MyBaseEntity, Y> Children lt(MySFunction<E, F> column, String as, MySFunction<X, Y> val) {
default <E, F, X, Y> Children lt(MySFunction<E, F> column, String as, MySFunction<X, Y> val) {
return lt(true, null, column, as, val);
}
default <E extends MyBaseEntity, F, X extends MyBaseEntity, Y> Children lt(boolean condition, String alias, MySFunction<E, F> column, MySFunction<X, Y> val) {
default <E, F, X, Y> Children lt(boolean condition, String alias, MySFunction<E, F> column, MySFunction<X, Y> val) {
return lt(condition, alias, column, null, val);
}
default <E extends MyBaseEntity, F, X extends MyBaseEntity, Y> Children lt(String alias, MySFunction<E, F> column, String as, MySFunction<X, Y> val) {
default <E, F, X, Y> Children lt(String alias, MySFunction<E, F> column, String as, MySFunction<X, Y> val) {
return lt(true, alias, column, as, val);
}
default <E extends MyBaseEntity, F, X extends MyBaseEntity, Y> Children lt(boolean condition, MySFunction<E, F> column, String as, MySFunction<X, Y> val) {
default <E, F, X, Y> Children lt(boolean condition, MySFunction<E, F> column, String as, MySFunction<X, Y> val) {
return lt(condition, null, column, as, val);
}
<E extends MyBaseEntity, F, X extends MyBaseEntity, Y> Children lt(boolean condition, String alias, MySFunction<E, F> column, String as, MySFunction<X, Y> val);
<E, F, X, Y> Children lt(boolean condition, String alias, MySFunction<E, F> column, String as, MySFunction<X, Y> val);
/* ***************************************** lt end ********************************************* */
/* ***************************************** lt start ********************************************* */
default <E extends MyBaseEntity, F> Children le(MySFunction<E, F> column, Object val) {
default <E, F> Children le(MySFunction<E, F> column, Object val) {
return le(true, null, column, val);
}
default <E extends MyBaseEntity, F> Children le(boolean condition, MySFunction<E, F> column, Object val) {
default <E, F> Children le(boolean condition, MySFunction<E, F> column, Object val) {
return le(condition, null, column, val);
}
default <E extends MyBaseEntity, F> Children le(String alias, MySFunction<E, F> column, Object val) {
default <E, F> Children le(String alias, MySFunction<E, F> column, Object val) {
return le(true, alias, column, val);
}
<E extends MyBaseEntity, F> Children le(boolean condition, String alias, MySFunction<E, F> column, Object val);
<E, F> Children le(boolean condition, String alias, MySFunction<E, F> column, Object val);
default <E extends MyBaseEntity, F, X extends MyBaseEntity, Y> Children le(MySFunction<E, F> column, MySFunction<X, Y> val) {
default <E, F, X, Y> Children le(MySFunction<E, F> column, MySFunction<X, Y> val) {
return le(true, null, column, null, val);
}
default <E extends MyBaseEntity, F, X extends MyBaseEntity, Y> Children le(boolean condition, MySFunction<E, F> column, MySFunction<X, Y> val) {
default <E, F, X, Y> Children le(boolean condition, MySFunction<E, F> column, MySFunction<X, Y> val) {
return le(condition, null, column, null, val);
}
default <E extends MyBaseEntity, F, X extends MyBaseEntity, Y> Children le(String alias, MySFunction<E, F> column, MySFunction<X, Y> val) {
default <E, F, X, Y> Children le(String alias, MySFunction<E, F> column, MySFunction<X, Y> val) {
return le(true, alias, column, null, val);
}
default <E extends MyBaseEntity, F, X extends MyBaseEntity, Y> Children le(MySFunction<E, F> column, String as, MySFunction<X, Y> val) {
default <E, F, X, Y> Children le(MySFunction<E, F> column, String as, MySFunction<X, Y> val) {
return le(true, null, column, as, val);
}
default <E extends MyBaseEntity, F, X extends MyBaseEntity, Y> Children le(boolean condition, String alias, MySFunction<E, F> column, MySFunction<X, Y> val) {
default <E, F, X, Y> Children le(boolean condition, String alias, MySFunction<E, F> column, MySFunction<X, Y> val) {
return le(condition, alias, column, null, val);
}
default <E extends MyBaseEntity, F, X extends MyBaseEntity, Y> Children le(String alias, MySFunction<E, F> column, String as, MySFunction<X, Y> val) {
default <E, F, X, Y> Children le(String alias, MySFunction<E, F> column, String as, MySFunction<X, Y> val) {
return le(true, alias, column, as, val);
}
default <E extends MyBaseEntity, F, X extends MyBaseEntity, Y> Children le(boolean condition, MySFunction<E, F> column, String as, MySFunction<X, Y> val) {
default <E, F, X, Y> Children le(boolean condition, MySFunction<E, F> column, String as, MySFunction<X, Y> val) {
return le(condition, null, column, as, val);
}
<E extends MyBaseEntity, F, X extends MyBaseEntity, Y> Children le(boolean condition, String alias, MySFunction<E, F> column, String as, MySFunction<X, Y> val);
<E, F, X, Y> Children le(boolean condition, String alias, MySFunction<E, F> column, String as, MySFunction<X, Y> val);
/* ***************************************** le end ********************************************* */
/* ***************************************** between start ********************************************* */
default <E extends MyBaseEntity, F> Children between(MySFunction<E, F> column, Object val1, Object val2) {
default <E, F> Children between(MySFunction<E, F> column, Object val1, Object val2) {
return between(true, null, column, val1, val2);
}
default <E extends MyBaseEntity, F> Children between(boolean condition, MySFunction<E, F> column, Object val1, Object val2) {
default <E, F> Children between(boolean condition, MySFunction<E, F> column, Object val1, Object val2) {
return between(condition, null, column, val1, val2);
}
default <E extends MyBaseEntity, F> Children between(String alias, MySFunction<E, F> column, Object val1, Object val2) {
default <E, F> Children between(String alias, MySFunction<E, F> column, Object val1, Object val2) {
return between(true, alias, column, val1, val2);
}
<E extends MyBaseEntity, F> Children between(boolean condition, String alias, MySFunction<E, F> column, Object val1, Object val2);
<E, F> Children between(boolean condition, String alias, MySFunction<E, F> column, Object val1, Object val2);
/* ***************************************** between end ********************************************* */
/* ***************************************** notBetween start ********************************************* */
default <E extends MyBaseEntity, F> Children notBetween(MySFunction<E, F> column, Object val1, Object val2) {
default <E, F> Children notBetween(MySFunction<E, F> column, Object val1, Object val2) {
return notBetween(true, null, column, val1, val2);
}
default <E extends MyBaseEntity, F> Children notBetween(boolean condition, MySFunction<E, F> column, Object val1, Object val2) {
default <E, F> Children notBetween(boolean condition, MySFunction<E, F> column, Object val1, Object val2) {
return notBetween(condition, null, column, val1, val2);
}
default <E extends MyBaseEntity, F> Children notBetween(String alias, MySFunction<E, F> column, Object val1, Object val2) {
default <E, F> Children notBetween(String alias, MySFunction<E, F> column, Object val1, Object val2) {
return notBetween(true, alias, column, val1, val2);
}
<E extends MyBaseEntity, F> Children notBetween(boolean condition, String alias, MySFunction<E, F> column, Object val1, Object val2);
<E, F> Children notBetween(boolean condition, String alias, MySFunction<E, F> column, Object val1, Object val2);
/* ***************************************** notBetween end ********************************************* */
/* ***************************************** like start ********************************************* */
default <E extends MyBaseEntity, F> Children like(MySFunction<E, F> column, Object val) {
default <E, F> Children like(MySFunction<E, F> column, Object val) {
return like(true, null, column, val);
}
default <E extends MyBaseEntity, F> Children like(boolean condition, MySFunction<E, F> column, Object val) {
default <E, F> Children like(boolean condition, MySFunction<E, F> column, Object val) {
return like(condition, null, column, val);
}
default <E extends MyBaseEntity, F> Children like(String alias, MySFunction<E, F> column, Object val) {
default <E, F> Children like(String alias, MySFunction<E, F> column, Object val) {
return like(true, alias, column, val);
}
<E extends MyBaseEntity, F> Children like(boolean condition, String alias, MySFunction<E, F> column, Object val);
<E, F> Children like(boolean condition, String alias, MySFunction<E, F> column, Object val);
/* ***************************************** like end ********************************************* */
/* ***************************************** notLike start ********************************************* */
default <E extends MyBaseEntity, F> Children notLike(MySFunction<E, F> column, Object val) {
default <E, F> Children notLike(MySFunction<E, F> column, Object val) {
return notLike(true, null, column, val);
}
default <E extends MyBaseEntity, F> Children notLike(boolean condition, MySFunction<E, F> column, Object val) {
default <E, F> Children notLike(boolean condition, MySFunction<E, F> column, Object val) {
return notLike(condition, null, column, val);
}
default <E extends MyBaseEntity, F> Children notLike(String alias, MySFunction<E, F> column, Object val) {
default <E, F> Children notLike(String alias, MySFunction<E, F> column, Object val) {
return notLike(true, alias, column, val);
}
<E extends MyBaseEntity, F> Children notLike(boolean condition, String alias, MySFunction<E, F> column, Object val);
<E, F> Children notLike(boolean condition, String alias, MySFunction<E, F> column, Object val);
/* ***************************************** notLike end ********************************************* */
/* ***************************************** likeLeft start ********************************************* */
default <E extends MyBaseEntity, F> Children likeLeft(MySFunction<E, F> column, Object val) {
default <E, F> Children likeLeft(MySFunction<E, F> column, Object val) {
return likeLeft(true, null, column, val);
}
default <E extends MyBaseEntity, F> Children likeLeft(boolean condition, MySFunction<E, F> column, Object val) {
default <E, F> Children likeLeft(boolean condition, MySFunction<E, F> column, Object val) {
return likeLeft(condition, null, column, val);
}
default <E extends MyBaseEntity, F> Children likeLeft(String alias, MySFunction<E, F> column, Object val) {
default <E, F> Children likeLeft(String alias, MySFunction<E, F> column, Object val) {
return likeLeft(true, alias, column, val);
}
<E extends MyBaseEntity, F> Children likeLeft(boolean condition, String alias, MySFunction<E, F> column, Object val);
<E, F> Children likeLeft(boolean condition, String alias, MySFunction<E, F> column, Object val);
/* ***************************************** likeLeft end ********************************************* */
@ -404,19 +403,19 @@ public interface MyCompare<Children> extends Serializable {
/* ***************************************** likeRight start ********************************************* */
default <E extends MyBaseEntity, F> Children likeRight(MySFunction<E, F> column, Object val) {
default <E, F> Children likeRight(MySFunction<E, F> column, Object val) {
return likeRight(true, null, column, val);
}
default <E extends MyBaseEntity, F> Children likeRight(boolean condition, MySFunction<E, F> column, Object val) {
default <E, F> Children likeRight(boolean condition, MySFunction<E, F> column, Object val) {
return likeRight(condition, null, column, val);
}
default <E extends MyBaseEntity, F> Children likeRight(String alias, MySFunction<E, F> column, Object val) {
default <E, F> Children likeRight(String alias, MySFunction<E, F> column, Object val) {
return likeRight(true, alias, column, val);
}
<E extends MyBaseEntity, F> Children likeRight(boolean condition, String alias, MySFunction<E, F> column, Object val);
<E, F> Children likeRight(boolean condition, String alias, MySFunction<E, F> column, Object val);
/* ***************************************** likeRight end ********************************************* */

107
src/main/java/com/github/mybatisplus/wrapper/interfaces/MyFunc.java
View File

@ -1,6 +1,5 @@
package com.github.mybatisplus.wrapper.interfaces;
import com.github.mybatisplus.base.MyBaseEntity;
import com.github.mybatisplus.func.MySFunction;
import java.io.Serializable;
@ -17,198 +16,198 @@ import static java.util.stream.Collectors.toList;
@SuppressWarnings("unchecked")
public interface MyFunc<Children> extends Serializable {
default <E extends MyBaseEntity, F> Children isNull(MySFunction<E, F> column) {
default <E, F> Children isNull(MySFunction<E, F> column) {
return isNull(true, null, column);
}
default <E extends MyBaseEntity, F> Children isNull(boolean condition, MySFunction<E, F> column) {
default <E, F> Children isNull(boolean condition, MySFunction<E, F> column) {
return isNull(condition, null, column);
}
default <E extends MyBaseEntity, F> Children isNull(String alias, MySFunction<E, F> column) {
default <E, F> Children isNull(String alias, MySFunction<E, F> column) {
return isNull(true, alias, column);
}
<E extends MyBaseEntity, F> Children isNull(boolean condition, String alias, MySFunction<E, F> column);
<E, F> Children isNull(boolean condition, String alias, MySFunction<E, F> column);
default <E extends MyBaseEntity, F> Children isNotNull(MySFunction<E, F> column) {
default <E, F> Children isNotNull(MySFunction<E, F> column) {
return isNotNull(true, column);
}
default <E extends MyBaseEntity, F> Children isNotNull(boolean condition, MySFunction<E, F> column) {
default <E, F> Children isNotNull(boolean condition, MySFunction<E, F> column) {
return isNotNull(condition, null, column);
}
default <E extends MyBaseEntity, F> Children isNotNull(String alias, MySFunction<E, F> column) {
default <E, F> Children isNotNull(String alias, MySFunction<E, F> column) {
return isNotNull(true, alias, column);
}
<E extends MyBaseEntity, F> Children isNotNull(boolean condition, String alias, MySFunction<E, F> column);
<E, F> Children isNotNull(boolean condition, String alias, MySFunction<E, F> column);
default <E extends MyBaseEntity, F> Children in(MySFunction<E, F> column, Collection<?> coll) {
default <E, F> Children in(MySFunction<E, F> column, Collection<?> coll) {
return in(true, null, column, coll);
}
default <E extends MyBaseEntity, F> Children in(boolean condition, MySFunction<E, F> column, Collection<?> coll) {
default <E, F> Children in(boolean condition, MySFunction<E, F> column, Collection<?> coll) {
return in(condition, null, column, coll);
}
default <E extends MyBaseEntity, F> Children in(String alias, MySFunction<E, F> column, Collection<?> coll) {
default <E, F> Children in(String alias, MySFunction<E, F> column, Collection<?> coll) {
return in(true, alias, column, coll);
}
<E extends MyBaseEntity, F> Children in(boolean condition, String alias, MySFunction<E, F> column, Collection<?> coll);
<E, F> Children in(boolean condition, String alias, MySFunction<E, F> column, Collection<?> coll);
default <E extends MyBaseEntity, F> Children in(MySFunction<E, F> column, Object... values) {
default <E, F> Children in(MySFunction<E, F> column, Object... values) {
return in(true, null, column, values);
}
default <E extends MyBaseEntity, F> Children in(boolean condition, MySFunction<E, F> column, Object... values) {
default <E, F> Children in(boolean condition, MySFunction<E, F> column, Object... values) {
return in(condition, null, column, values);
}
default <E extends MyBaseEntity, F> Children in(String alias, MySFunction<E, F> column, Object... values) {
default <E, F> Children in(String alias, MySFunction<E, F> column, Object... values) {
return in(true, alias, column, values);
}
default <E extends MyBaseEntity, F> Children in(boolean condition, String alias, MySFunction<E, F> column, Object... values) {
default <E, F> Children in(boolean condition, String alias, MySFunction<E, F> column, Object... values) {
return in(condition, alias, column, Arrays.stream(Optional.ofNullable(values).orElseGet(() -> new Object[]{}))
.collect(toList()));
}
default <E extends MyBaseEntity, F> Children notIn(MySFunction<E, F> column, Collection<?> coll) {
default <E, F> Children notIn(MySFunction<E, F> column, Collection<?> coll) {
return notIn(true, null, column, coll);
}
default <E extends MyBaseEntity, F> Children notIn(boolean condition, MySFunction<E, F> column, Collection<?> coll) {
default <E, F> Children notIn(boolean condition, MySFunction<E, F> column, Collection<?> coll) {
return notIn(condition, null, column, coll);
}
default <E extends MyBaseEntity, F> Children notIn(String alias, MySFunction<E, F> column, Collection<?> coll) {
default <E, F> Children notIn(String alias, MySFunction<E, F> column, Collection<?> coll) {
return notIn(true, alias, column, coll);
}
<E extends MyBaseEntity, F> Children notIn(boolean condition, String alias, MySFunction<E, F> column, Collection<?> coll);
<E, F> Children notIn(boolean condition, String alias, MySFunction<E, F> column, Collection<?> coll);
default <E extends MyBaseEntity, F> Children notIn(MySFunction<E, F> column, Object... value) {
default <E, F> Children notIn(MySFunction<E, F> column, Object... value) {
return notIn(true, null, column, value);
}
default <E extends MyBaseEntity, F> Children notIn(boolean condition, MySFunction<E, F> column, Object... value) {
default <E, F> Children notIn(boolean condition, MySFunction<E, F> column, Object... value) {
return notIn(condition, null, column, value);
}
default <E extends MyBaseEntity, F> Children notIn(String alias, MySFunction<E, F> column, Object... value) {
default <E, F> Children notIn(String alias, MySFunction<E, F> column, Object... value) {
return notIn(true, alias, column, value);
}
default <E extends MyBaseEntity, F> Children notIn(boolean condition, String alias, MySFunction<E, F> column, Object... values) {
default <E, F> Children notIn(boolean condition, String alias, MySFunction<E, F> column, Object... values) {
return notIn(condition, alias, column, Arrays.stream(Optional.ofNullable(values).orElseGet(() -> new Object[]{}))
.collect(toList()));
}
default <E extends MyBaseEntity, F> Children inSql(MySFunction<E, F> column, String inValue) {
default <E, F> Children inSql(MySFunction<E, F> column, String inValue) {
return inSql(true, null, column, inValue);
}
default <E extends MyBaseEntity, F> Children inSql(boolean condition, MySFunction<E, F> column, String inValue) {
default <E, F> Children inSql(boolean condition, MySFunction<E, F> column, String inValue) {
return inSql(condition, null, column, inValue);
}
default <E extends MyBaseEntity, F> Children inSql(String alias, MySFunction<E, F> column, String inValue) {
default <E, F> Children inSql(String alias, MySFunction<E, F> column, String inValue) {
return inSql(true, alias, column, inValue);
}
<E extends MyBaseEntity, F> Children inSql(boolean condition, String alias, MySFunction<E, F> column, String inValue);
<E, F> Children inSql(boolean condition, String alias, MySFunction<E, F> column, String inValue);
default <E extends MyBaseEntity, F> Children notInSql(MySFunction<E, F> column, String inValue) {
default <E, F> Children notInSql(MySFunction<E, F> column, String inValue) {
return notInSql(true, null, column, inValue);
}
default <E extends MyBaseEntity, F> Children notInSql(boolean condition, MySFunction<E, F> column, String inValue) {
default <E, F> Children notInSql(boolean condition, MySFunction<E, F> column, String inValue) {
return notInSql(condition, null, column, inValue);
}
default <E extends MyBaseEntity, F> Children notInSql(String alias, MySFunction<E, F> column, String inValue) {
default <E, F> Children notInSql(String alias, MySFunction<E, F> column, String inValue) {
return notInSql(true, alias, column, inValue);
}
<E extends MyBaseEntity, F> Children notInSql(boolean condition, String alias, MySFunction<E, F> column, String inValue);
<E, F> Children notInSql(boolean condition, String alias, MySFunction<E, F> column, String inValue);
default <E extends MyBaseEntity, F> Children groupBy(MySFunction<E, F>... columns) {
default <E, F> Children groupBy(MySFunction<E, F>... columns) {
return groupBy(true, null, columns);
}
default <E extends MyBaseEntity, F> Children groupBy(boolean condition, MySFunction<E, F>... columns) {
default <E, F> Children groupBy(boolean condition, MySFunction<E, F>... columns) {
return groupBy(condition, null, columns);
}
default <E extends MyBaseEntity, F> Children groupBy(String alias, MySFunction<E, F>... columns) {
default <E, F> Children groupBy(String alias, MySFunction<E, F>... columns) {
return groupBy(true, alias, columns);
}
<E extends MyBaseEntity, F> Children groupBy(boolean condition, String alias, MySFunction<E, F>... columns);
<E, F> Children groupBy(boolean condition, String alias, MySFunction<E, F>... columns);
default <E extends MyBaseEntity, F> Children orderByAsc(MySFunction<E, F>... columns) {
default <E, F> Children orderByAsc(MySFunction<E, F>... columns) {
return orderByAsc(true, null, columns);
}
default <E extends MyBaseEntity, F> Children orderByAsc(boolean condition, MySFunction<E, F>... columns) {
default <E, F> Children orderByAsc(boolean condition, MySFunction<E, F>... columns) {
return orderByAsc(condition, null, columns);
}
default <E extends MyBaseEntity, F> Children orderByAsc(String alias, MySFunction<E, F>... columns) {
default <E, F> Children orderByAsc(String alias, MySFunction<E, F>... columns) {
return orderByAsc(true, alias, columns);
}
default <E extends MyBaseEntity, F> Children orderByAsc(boolean condition, String alias, MySFunction<E, F>... columns) {
default <E, F> Children orderByAsc(boolean condition, String alias, MySFunction<E, F>... columns) {
return orderBy(condition, alias, true, columns);
}
default <E extends MyBaseEntity, F> Children orderByDesc(MySFunction<E, F>... columns) {
default <E, F> Children orderByDesc(MySFunction<E, F>... columns) {
return orderByDesc(true, null, columns);
}
default <E extends MyBaseEntity, F> Children orderByDesc(boolean condition, MySFunction<E, F>... columns) {
default <E, F> Children orderByDesc(boolean condition, MySFunction<E, F>... columns) {
return orderByDesc(condition, null, columns);
}
default <E extends MyBaseEntity, F> Children orderByDesc(String alias, MySFunction<E, F>... columns) {
default <E, F> Children orderByDesc(String alias, MySFunction<E, F>... columns) {
return orderByDesc(true, alias, columns);
}
default <E extends MyBaseEntity, F> Children orderByDesc(boolean condition, String alias, MySFunction<E, F>... columns) {
default <E, F> Children orderByDesc(boolean condition, String alias, MySFunction<E, F>... columns) {
return orderBy(condition, alias, false, columns);
}
<E extends MyBaseEntity, F> Children orderBy(boolean condition, String alias, boolean isAsc, MySFunction<E, F>... columns);
<E, F> Children orderBy(boolean condition, String alias, boolean isAsc, MySFunction<E, F>... columns);
default <E extends MyBaseEntity, F> Children having(String sqlHaving, Object... params) {
default <E, F> Children having(String sqlHaving, Object... params) {
return having(true, null, sqlHaving, params);
}
default <E extends MyBaseEntity, F> Children having(boolean condition, String sqlHaving, Object... params) {
default <E, F> Children having(boolean condition, String sqlHaving, Object... params) {
return having(condition, null, sqlHaving, params);
}
default <E extends MyBaseEntity, F> Children having(String alias, String sqlHaving, Object... params) {
default <E, F> Children having(String alias, String sqlHaving, Object... params) {
return having(true, alias, sqlHaving, params);
}
<E extends MyBaseEntity, F> Children having(boolean condition, String alias, String sqlHaving, Object... params);
<E, F> Children having(boolean condition, String alias, String sqlHaving, Object... params);
default <E extends MyBaseEntity, F> Children func(Consumer<Children> consumer) {
default <E, F> Children func(Consumer<Children> consumer) {
return func(true, null, consumer);
}
default <E extends MyBaseEntity, F> Children func(boolean condition, Consumer<Children> consumer) {
default <E, F> Children func(boolean condition, Consumer<Children> consumer) {
return func(condition, null, consumer);
}
default <E extends MyBaseEntity, F> Children func(String alias, Consumer<Children> consumer) {
default <E, F> Children func(String alias, Consumer<Children> consumer) {
return func(true, alias, consumer);
}
<E extends MyBaseEntity, F> Children func(boolean condition, String alias, Consumer<Children> consumer);
<E, F> Children func(boolean condition, String alias, Consumer<Children> consumer);
}

81
src/main/java/com/github/mybatisplus/wrapper/interfaces/MyJoin.java
View File

@ -1,6 +1,5 @@
package com.github.mybatisplus.wrapper.interfaces;
import com.github.mybatisplus.base.MyBaseEntity;
import com.github.mybatisplus.func.MySFunction;
import com.github.mybatisplus.wrapper.MyJoinLambdaQueryWrapper;
@ -9,80 +8,80 @@ import java.util.function.Function;
/**
* @author yulichang
*/
public interface MyJoin<Children, T extends MyBaseEntity> {
public interface MyJoin<Children, T> {
<R extends MyBaseEntity, TE, RE> Children leftJoin(boolean condition,
String alias,
MySFunction<T, TE> leftCondition,
MySFunction<R, RE> rightCondition,
Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper);
<R, TE, RE> Children leftJoin(boolean condition,
String alias,
MySFunction<T, TE> leftCondition,
MySFunction<R, RE> rightCondition,
Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper);
default <R extends MyBaseEntity, TE, RE> Children leftJoin(MySFunction<T, TE> leftCondition,
MySFunction<R, RE> rightCondition,
Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
default <R, TE, RE> Children leftJoin(MySFunction<T, TE> leftCondition,
MySFunction<R, RE> rightCondition,
Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
return leftJoin(true, null, leftCondition, rightCondition, rightWrapper);
}
default <R extends MyBaseEntity, TE, RE> Children leftJoin(String alias, MySFunction<T, TE> leftCondition, MySFunction<R, RE> rightCondition, Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
default <R, TE, RE> Children leftJoin(String alias, MySFunction<T, TE> leftCondition, MySFunction<R, RE> rightCondition, Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
return leftJoin(true, alias, leftCondition, rightCondition, rightWrapper);
}
default <R extends MyBaseEntity, TE, RE> Children leftJoin(boolean condition,
MySFunction<T, TE> leftCondition,
MySFunction<R, RE> rightCondition,
Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
default <R, TE, RE> Children leftJoin(boolean condition,
MySFunction<T, TE> leftCondition,
MySFunction<R, RE> rightCondition,
Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
return leftJoin(condition, null, leftCondition, rightCondition, rightWrapper);
}
<R extends MyBaseEntity, TE, RE> Children rightJoin(boolean condition,
String alias,
MySFunction<T, TE> leftCondition,
MySFunction<R, RE> rightCondition,
Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper);
<R, TE, RE> Children rightJoin(boolean condition,
String alias,
MySFunction<T, TE> leftCondition,
MySFunction<R, RE> rightCondition,
Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper);
default <R extends MyBaseEntity, TE, RE> Children rightJoin(MySFunction<T, TE> leftCondition,
MySFunction<R, RE> rightCondition,
Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
default <R, TE, RE> Children rightJoin(MySFunction<T, TE> leftCondition,
MySFunction<R, RE> rightCondition,
Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
return rightJoin(true, null, leftCondition, rightCondition, rightWrapper);
}
default <R extends MyBaseEntity, TE, RE> Children rightJoin(String alias, MySFunction<T, TE> leftCondition, MySFunction<R, RE> rightCondition, Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
default <R, TE, RE> Children rightJoin(String alias, MySFunction<T, TE> leftCondition, MySFunction<R, RE> rightCondition, Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
return rightJoin(true, alias, leftCondition, rightCondition, rightWrapper);
}
default <R extends MyBaseEntity, TE, RE> Children rightJoin(boolean condition,
MySFunction<T, TE> leftCondition,
MySFunction<R, RE> rightCondition,
Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
default <R, TE, RE> Children rightJoin(boolean condition,
MySFunction<T, TE> leftCondition,
MySFunction<R, RE> rightCondition,
Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
return rightJoin(condition, null, leftCondition, rightCondition, rightWrapper);
}
<R extends MyBaseEntity, TE, RE> Children innerJoin(boolean condition,
String alias,
MySFunction<T, TE> leftCondition,
MySFunction<R, RE> rightCondition,
Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper);
<R, TE, RE> Children innerJoin(boolean condition,
String alias,
MySFunction<T, TE> leftCondition,
MySFunction<R, RE> rightCondition,
Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper);
default <R extends MyBaseEntity, TE, RE> Children innerJoin(MySFunction<T, TE> leftCondition,
MySFunction<R, RE> rightCondition,
Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
default <R, TE, RE> Children innerJoin(MySFunction<T, TE> leftCondition,
MySFunction<R, RE> rightCondition,
Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
return innerJoin(true, null, leftCondition, rightCondition, rightWrapper);
}
default <R extends MyBaseEntity, TE, RE> Children innerJoin(String alias, MySFunction<T, TE> leftCondition, MySFunction<R, RE> rightCondition, Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
default <R, TE, RE> Children innerJoin(String alias, MySFunction<T, TE> leftCondition, MySFunction<R, RE> rightCondition, Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
return innerJoin(true, alias, leftCondition, rightCondition, rightWrapper);
}
default <R extends MyBaseEntity, TE, RE> Children innerJoin(boolean condition,
MySFunction<T, TE> leftCondition,
MySFunction<R, RE> rightCondition,
Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
default <R, TE, RE> Children innerJoin(boolean condition,
MySFunction<T, TE> leftCondition,
MySFunction<R, RE> rightCondition,
Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
return innerJoin(condition, null, leftCondition, rightCondition, rightWrapper);
}