third_codes/mybatis-plus-join
1
0
Fork 0
mirror of https://gitee.com/best_handsome/mybatis-plus-join synced 2025-07-25 00:00:12 +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 * @author yulichang
* @see IService * @see IService
*/ */
public interface MyBaseService<T extends MyBaseEntity> extends IService<T> { public interface MyBaseService<T> extends IService<T> {
/** /**
* ignore * ignore

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

@ -11,7 +11,7 @@ import java.util.Map;
* @author yulichang * @author yulichang
* @see ServiceImpl * @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 @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.baomidou.mybatisplus.core.toolkit.support.SFunction;
import com.github.mybatisplus.base.MyBaseEntity;
/** /**
* 支持别名的 SFunction * 支持别名的 SFunction
@ -11,6 +10,6 @@ import com.github.mybatisplus.base.MyBaseEntity;
* @see SFunction * @see SFunction
*/ */
@FunctionalInterface @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; package com.github.mybatisplus.func;
import com.github.mybatisplus.wrapper.MyLambdaQueryWrapper; import com.github.mybatisplus.wrapper.MyLambdaQueryWrapper;
import com.github.mybatisplus.base.MyBaseEntity;
/** /**
* @author yulichang * @author yulichang
*/ */
@FunctionalInterface @FunctionalInterface
public interface MyWrapperFunc<T extends MyBaseEntity> { public interface MyWrapperFunc<T> {
MyLambdaQueryWrapper<T> apply(MyLambdaQueryWrapper<T> wrapper); 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.LambdaUtils;
import com.baomidou.mybatisplus.core.toolkit.StringUtils; import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.core.toolkit.support.SFunction; import com.baomidou.mybatisplus.core.toolkit.support.SFunction;
import com.github.mybatisplus.base.MyBaseEntity;
import com.github.mybatisplus.func.MySFunction; import com.github.mybatisplus.func.MySFunction;
import org.apache.ibatis.reflection.property.PropertyNamer; import org.apache.ibatis.reflection.property.PropertyNamer;
@ -18,11 +17,11 @@ public class MyLambdaUtils {
return PropertyNamer.methodToProperty(LambdaUtils.resolve(fn).getImplMethodName()); 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)); 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(); 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.TableInfo;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper; import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.baomidou.mybatisplus.core.toolkit.ArrayUtils; 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.StringUtils;
import com.baomidou.mybatisplus.core.toolkit.support.SFunction; 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.Constant;
import com.github.mybatisplus.toolkit.MyLambdaUtils; import com.github.mybatisplus.toolkit.MyLambdaUtils;
import com.github.mybatisplus.wrapper.interfaces.MyJoin; import com.github.mybatisplus.wrapper.interfaces.MyJoin;
@ -30,7 +30,7 @@ import java.util.stream.Collectors;
* @see com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper * @see com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper
* @since 2021/01/19 * @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> { implements Query<MyJoinLambdaQueryWrapper<T>, T, SFunction<T, ?>>, MyJoin<MyJoinLambdaQueryWrapper<T>, T> {
protected SharedString sqlSelect = new SharedString(); protected SharedString sqlSelect = new SharedString();
@ -108,6 +108,7 @@ public class MyJoinLambdaQueryWrapper<T extends MyBaseEntity> extends MyAbstract
public MyJoinLambdaQueryWrapper<T> selectAll(Class<T> clazz) { public MyJoinLambdaQueryWrapper<T> selectAll(Class<T> clazz) {
setEntityClass(clazz); setEntityClass(clazz);
TableInfo info = TableInfoHelper.getTableInfo(getEntityClass()); TableInfo info = TableInfoHelper.getTableInfo(getEntityClass());
Assert.notNull(info, "can not find table to entity %s", clazz);
info.getFieldList().forEach(s -> info.getFieldList().forEach(s ->
selectColumnList.add(new SelectColumn(this.rUid, s.getColumn(), null, null))); selectColumnList.add(new SelectColumn(this.rUid, s.getColumn(), null, null)));
if (StringUtils.isNotBlank(info.getKeyColumn())) { 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) { public MyJoinLambdaQueryWrapper<T> select(Class<T> entityClass, Predicate<TableFieldInfo> predicate) {
this.setEntityClass(entityClass); this.setEntityClass(entityClass);
TableInfo info = TableInfoHelper.getTableInfo(getEntityClass()); TableInfo info = TableInfoHelper.getTableInfo(getEntityClass());
Assert.notNull(info, "can not find table to entity %s", entityClass);
info.getFieldList().stream().filter(predicate).forEach(s -> info.getFieldList().stream().filter(predicate).forEach(s ->
selectColumnList.add(new SelectColumn(this.rUid, s.getColumn(), null, null))); selectColumnList.add(new SelectColumn(this.rUid, s.getColumn(), null, null)));
return typedThis; return typedThis;
@ -207,7 +209,7 @@ public class MyJoinLambdaQueryWrapper<T extends MyBaseEntity> extends MyAbstract
* @param rightWrapper 子表的wrapper * @param rightWrapper 子表的wrapper
*/ */
@Override @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); return join(condition, alias, Constant.LEFT_JOIN, leftCondition, rightCondition, rightWrapper);
} }
@ -215,7 +217,7 @@ public class MyJoinLambdaQueryWrapper<T extends MyBaseEntity> extends MyAbstract
* 右连接查询(参考左连接) * 右连接查询(参考左连接)
*/ */
@Override @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); return join(condition, alias, Constant.RIGHT_JOIN, leftCondition, rightCondition, rightWrapper);
} }
@ -223,15 +225,18 @@ public class MyJoinLambdaQueryWrapper<T extends MyBaseEntity> extends MyAbstract
* 内连接查询(参考左连接) * 内连接查询(参考左连接)
*/ */
@Override @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); 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) { if (condition) {
setEntityClass(MyLambdaUtils.getEntityClass(leftCondition)); setEntityClass(MyLambdaUtils.getEntityClass(leftCondition));
int childrenId = rUid + 1; 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)); MyJoinLambdaQueryWrapper<R> apply = rightWrapper.apply(new MyJoinLambdaQueryWrapper<>(childrenId));
classList.addAll(apply.classList); classList.addAll(apply.classList);
this.selectColumnList.addAll(apply.selectColumnList); 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.enums.SqlLike;
import com.baomidou.mybatisplus.core.exceptions.MybatisPlusException; import com.baomidou.mybatisplus.core.exceptions.MybatisPlusException;
import com.baomidou.mybatisplus.core.metadata.TableFieldInfo; 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.metadata.TableInfoHelper;
import com.baomidou.mybatisplus.core.toolkit.ArrayUtils; import com.baomidou.mybatisplus.core.toolkit.*;
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.sql.SqlUtils; import com.baomidou.mybatisplus.core.toolkit.sql.SqlUtils;
import com.baomidou.mybatisplus.core.toolkit.support.SFunction; import com.baomidou.mybatisplus.core.toolkit.support.SFunction;
import com.github.mybatisplus.wrapper.interfaces.MyCompare; import com.github.mybatisplus.wrapper.interfaces.MyCompare;
import com.github.mybatisplus.wrapper.interfaces.MyFunc; import com.github.mybatisplus.wrapper.interfaces.MyFunc;
import com.github.mybatisplus.wrapper.interfaces.MyNested; import com.github.mybatisplus.wrapper.interfaces.MyNested;
import com.github.mybatisplus.base.MyBaseEntity;
import com.github.mybatisplus.func.MySFunction; import com.github.mybatisplus.func.MySFunction;
import com.github.mybatisplus.toolkit.Constant; import com.github.mybatisplus.toolkit.Constant;
import com.github.mybatisplus.toolkit.MyLambdaUtils; 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 * @see com.baomidou.mybatisplus.core.conditions.interfaces.Func
* @since 2021/01/19 * @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>>, implements MyCompare<MyLambdaQueryWrapper<T>>, MyNested<MyLambdaQueryWrapper<T>, MyLambdaQueryWrapper<T>>,
MyFunc<MyLambdaQueryWrapper<T>> { MyFunc<MyLambdaQueryWrapper<T>> {
@ -94,68 +91,71 @@ public class MyLambdaQueryWrapper<T extends MyBaseEntity> extends MyJoinLambdaQu
@Override @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); return join(condition, alias, Constant.LEFT_JOIN, leftCondition, rightCondition, rightWrapper);
} }
@Override @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); return this.leftJoin(true, null, leftCondition, rightCondition, rightWrapper);
} }
@Override @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); return this.leftJoin(true, alias, leftCondition, rightCondition, rightWrapper);
} }
@Override @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); 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); return join(condition, alias, Constant.RIGHT_JOIN, leftCondition, rightCondition, rightWrapper);
} }
@Override @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); return this.rightJoin(true, null, leftCondition, rightCondition, rightWrapper);
} }
@Override @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); return this.rightJoin(true, alias, leftCondition, rightCondition, rightWrapper);
} }
@Override @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); 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); return join(condition, alias, Constant.INNER_JOIN, leftCondition, rightCondition, rightWrapper);
} }
@Override @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); return this.innerJoin(true, null, leftCondition, rightCondition, rightWrapper);
} }
@Override @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); return this.innerJoin(true, alias, leftCondition, rightCondition, rightWrapper);
} }
@Override @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); 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) { if (condition) {
setEntityClass(MyLambdaUtils.getEntityClass(leftCondition)); 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())); MyJoinLambdaQueryWrapper<R> apply = rightWrapper.apply(new MyJoinLambdaQueryWrapper<>(classList.size()));
classList.addAll(apply.classList); classList.addAll(apply.classList);
this.selectColumnList.addAll(apply.selectColumnList); this.selectColumnList.addAll(apply.selectColumnList);
@ -285,11 +285,13 @@ public class MyLambdaQueryWrapper<T extends MyBaseEntity> extends MyJoinLambdaQu
/** /**
* 获取表前缀 * 获取表前缀
*/ */
private String getClassTablePrefix(Class<?> tag) { private String getClassTablePrefix(Class<?> clazz) {
if (getEntityClass() == tag) { if (getEntityClass() == clazz) {
return Constant.TABLE_ALIAS + rUid; return Constant.TABLE_ALIAS + rUid;
} else { } 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) { for (SubTable sub : classList) {
if (sub.getRightTableName().equals(tableName)) { if (sub.getRightTableName().equals(tableName)) {
return Constant.TABLE_ALIAS + sub.getRightUid(); return Constant.TABLE_ALIAS + sub.getRightUid();
@ -302,7 +304,7 @@ public class MyLambdaQueryWrapper<T extends MyBaseEntity> extends MyJoinLambdaQu
/** /**
* 获取column * 获取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 != null) {
if (alias.equals(DEFAULT_ALIAS)) { if (alias.equals(DEFAULT_ALIAS)) {
return Constant.TABLE_ALIAS + rUid + StringPool.DOT + column2String(column, true); 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); 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)); return Arrays.stream(column).map(i -> getColumn(i, alias)).collect(joining(StringPool.COMMA));
} }
@Override @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, return doIt(condition, () -> getColumn(column, alias), EQ,
() -> formatSql("{0}", val)); () -> formatSql("{0}", val));
} }
@Override @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)); return doIt(condition, () -> getColumn(column, alias), EQ, () -> getColumn(val, as));
} }
@Override @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)); return doIt(condition, () -> getColumn(column, alias), NE, () -> formatSql("{0}", val));
} }
@Override @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)); return doIt(condition, () -> getColumn(column, alias), NE, () -> getColumn(val, as));
} }
@Override @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)); return doIt(condition, () -> getColumn(column, alias), GT, () -> formatSql("{0}", val));
} }
@Override @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)); return doIt(condition, () -> getColumn(column, alias), GT, () -> getColumn(val, as));
} }
@Override @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)); return doIt(condition, () -> getColumn(column, alias), GE, () -> formatSql("{0}", val));
} }
@Override @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)); return doIt(condition, () -> getColumn(column, alias), GE, () -> getColumn(val, as));
} }
@Override @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)); return doIt(condition, () -> getColumn(column, alias), LT, () -> formatSql("{0}", val));
} }
@Override @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)); return doIt(condition, () -> getColumn(column, alias), LT, () -> getColumn(val, as));
} }
@Override @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)); return doIt(condition, () -> getColumn(column, alias), LE, () -> formatSql("{0}", val));
} }
@Override @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)); return doIt(condition, () -> getColumn(column, alias), LE, () -> getColumn(val, as));
} }
@Override @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, return doIt(condition, () -> getColumn(column, alias), BETWEEN, () -> formatSql("{0}", val1), AND,
() -> formatSql("{0}", val2)); () -> formatSql("{0}", val2));
} }
@Override @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, return doIt(condition, () -> getColumn(column, alias), NOT_BETWEEN, () -> formatSql("{0}", val1), AND,
() -> formatSql("{0}", val2)); () -> formatSql("{0}", val2));
} }
@Override @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); return likeValue(condition, LIKE, getColumn(column, alias), val, SqlLike.DEFAULT);
} }
@Override @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); return likeValue(condition, NOT_LIKE, getColumn(column, alias), val, SqlLike.DEFAULT);
} }
@Override @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); return likeValue(condition, LIKE, getColumn(column, alias), val, SqlLike.LEFT);
} }
@Override @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); return likeValue(condition, LIKE, getColumn(column, alias), val, SqlLike.RIGHT);
} }
@ -453,11 +455,11 @@ public class MyLambdaQueryWrapper<T extends MyBaseEntity> extends MyJoinLambdaQu
return this; 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))); 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)); return doIt(condition, () -> column, sqlKeyword, () -> formatSql("{0}", val));
} }
@ -476,37 +478,37 @@ public class MyLambdaQueryWrapper<T extends MyBaseEntity> extends MyJoinLambdaQu
} }
@Override @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); return doIt(condition, () -> getColumn(column, alias), IS_NULL);
} }
@Override @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); return doIt(condition, () -> getColumn(column, alias), IS_NOT_NULL);
} }
@Override @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)); return doIt(condition, () -> getColumn(column, alias), IN, inExpression(coll));
} }
@Override @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)); return doIt(condition, () -> getColumn(column, alias), NOT_IN, inExpression(coll));
} }
@Override @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)); return doIt(condition, () -> getColumn(column, alias), IN, () -> String.format("(%s)", inValue));
} }
@Override @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)); return doIt(condition, () -> getColumn(column, alias), NOT_IN, () -> String.format("(%s)", inValue));
} }
@Override @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)) { if (ArrayUtils.isEmpty(columns)) {
return this; return this;
} }
@ -515,7 +517,7 @@ public class MyLambdaQueryWrapper<T extends MyBaseEntity> extends MyJoinLambdaQu
} }
@Override @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)) { if (ArrayUtils.isEmpty(columns)) {
return this; return this;
} }
@ -527,12 +529,12 @@ public class MyLambdaQueryWrapper<T extends MyBaseEntity> extends MyJoinLambdaQu
} }
@Override @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)); return doIt(condition, HAVING, () -> formatSqlIfNeed(condition, sqlHaving, params));
} }
@Override @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) { if (condition) {
consumer.accept(this); 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; package com.github.mybatisplus.wrapper.interfaces;
import com.github.mybatisplus.base.MyBaseEntity;
import com.github.mybatisplus.func.MySFunction; import com.github.mybatisplus.func.MySFunction;
import java.io.Serializable; import java.io.Serializable;
@ -14,47 +13,47 @@ public interface MyCompare<Children> extends Serializable {
/* ***************************************** eq start ********************************************* */ /* ***************************************** 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); return eq(true, alias, column, as, val);
} }
@ -63,98 +62,98 @@ public interface MyCompare<Children> extends Serializable {
/* ***************************************** ne start ********************************************* */ /* ***************************************** 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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 ********************************************* */ /* ***************************************** ne end ********************************************* */
/* ***************************************** gt start ********************************************* */ /* ***************************************** 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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 ********************************************* */ /* ***************************************** gt end ********************************************* */
@ -162,241 +161,241 @@ public interface MyCompare<Children> extends Serializable {
/* ***************************************** ge start ********************************************* */ /* ***************************************** 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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 ********************************************* */ /* ***************************************** ge end ********************************************* */
/* ***************************************** lt start ********************************************* */ /* ***************************************** 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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 end ********************************************* */
/* ***************************************** lt start ********************************************* */ /* ***************************************** 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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 ********************************************* */ /* ***************************************** le end ********************************************* */
/* ***************************************** between start ********************************************* */ /* ***************************************** 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); 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); 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); 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 ********************************************* */ /* ***************************************** between end ********************************************* */
/* ***************************************** notBetween start ********************************************* */ /* ***************************************** 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); 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); 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); 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 ********************************************* */ /* ***************************************** notBetween end ********************************************* */
/* ***************************************** like start ********************************************* */ /* ***************************************** 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); 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); 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); 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 ********************************************* */ /* ***************************************** like end ********************************************* */
/* ***************************************** notLike start ********************************************* */ /* ***************************************** 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); 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); 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); 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 ********************************************* */ /* ***************************************** notLike end ********************************************* */
/* ***************************************** likeLeft start ********************************************* */ /* ***************************************** 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); 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); 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); 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 ********************************************* */ /* ***************************************** likeLeft end ********************************************* */
@ -404,19 +403,19 @@ public interface MyCompare<Children> extends Serializable {
/* ***************************************** likeRight start ********************************************* */ /* ***************************************** 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); 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); 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); 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 ********************************************* */ /* ***************************************** 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; package com.github.mybatisplus.wrapper.interfaces;
import com.github.mybatisplus.base.MyBaseEntity;
import com.github.mybatisplus.func.MySFunction; import com.github.mybatisplus.func.MySFunction;
import java.io.Serializable; import java.io.Serializable;
@ -17,198 +16,198 @@ import static java.util.stream.Collectors.toList;
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
public interface MyFunc<Children> extends Serializable { 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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[]{})) return in(condition, alias, column, Arrays.stream(Optional.ofNullable(values).orElseGet(() -> new Object[]{}))
.collect(toList())); .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); 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); 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); 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); 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); 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); 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[]{})) return notIn(condition, alias, column, Arrays.stream(Optional.ofNullable(values).orElseGet(() -> new Object[]{}))
.collect(toList())); .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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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; package com.github.mybatisplus.wrapper.interfaces;
import com.github.mybatisplus.base.MyBaseEntity;
import com.github.mybatisplus.func.MySFunction; import com.github.mybatisplus.func.MySFunction;
import com.github.mybatisplus.wrapper.MyJoinLambdaQueryWrapper; import com.github.mybatisplus.wrapper.MyJoinLambdaQueryWrapper;
@ -9,80 +8,80 @@ import java.util.function.Function;
/** /**
* @author yulichang * @author yulichang
*/ */
public interface MyJoin<Children, T extends MyBaseEntity> { public interface MyJoin<Children, T> {
<R extends MyBaseEntity, TE, RE> Children leftJoin(boolean condition, <R, TE, RE> Children leftJoin(boolean condition,
String alias, String alias,
MySFunction<T, TE> leftCondition, MySFunction<T, TE> leftCondition,
MySFunction<R, RE> rightCondition, MySFunction<R, RE> rightCondition,
Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper); Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper);
default <R extends MyBaseEntity, TE, RE> Children leftJoin(MySFunction<T, TE> leftCondition, default <R, TE, RE> Children leftJoin(MySFunction<T, TE> leftCondition,
MySFunction<R, RE> rightCondition, MySFunction<R, RE> rightCondition,
Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) { Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
return leftJoin(true, null, leftCondition, rightCondition, 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); return leftJoin(true, alias, leftCondition, rightCondition, rightWrapper);
} }
default <R extends MyBaseEntity, TE, RE> Children leftJoin(boolean condition, default <R, TE, RE> Children leftJoin(boolean condition,
MySFunction<T, TE> leftCondition, MySFunction<T, TE> leftCondition,
MySFunction<R, RE> rightCondition, MySFunction<R, RE> rightCondition,
Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) { Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
return leftJoin(condition, null, leftCondition, rightCondition, rightWrapper); return leftJoin(condition, null, leftCondition, rightCondition, rightWrapper);
} }
<R extends MyBaseEntity, TE, RE> Children rightJoin(boolean condition, <R, TE, RE> Children rightJoin(boolean condition,
String alias, String alias,
MySFunction<T, TE> leftCondition, MySFunction<T, TE> leftCondition,
MySFunction<R, RE> rightCondition, MySFunction<R, RE> rightCondition,
Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper); Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper);
default <R extends MyBaseEntity, TE, RE> Children rightJoin(MySFunction<T, TE> leftCondition, default <R, TE, RE> Children rightJoin(MySFunction<T, TE> leftCondition,
MySFunction<R, RE> rightCondition, MySFunction<R, RE> rightCondition,
Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) { Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
return rightJoin(true, null, leftCondition, rightCondition, 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); return rightJoin(true, alias, leftCondition, rightCondition, rightWrapper);
} }
default <R extends MyBaseEntity, TE, RE> Children rightJoin(boolean condition, default <R, TE, RE> Children rightJoin(boolean condition,
MySFunction<T, TE> leftCondition, MySFunction<T, TE> leftCondition,
MySFunction<R, RE> rightCondition, MySFunction<R, RE> rightCondition,
Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) { Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
return rightJoin(condition, null, leftCondition, rightCondition, rightWrapper); return rightJoin(condition, null, leftCondition, rightCondition, rightWrapper);
} }
<R extends MyBaseEntity, TE, RE> Children innerJoin(boolean condition, <R, TE, RE> Children innerJoin(boolean condition,
String alias, String alias,
MySFunction<T, TE> leftCondition, MySFunction<T, TE> leftCondition,
MySFunction<R, RE> rightCondition, MySFunction<R, RE> rightCondition,
Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper); Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper);
default <R extends MyBaseEntity, TE, RE> Children innerJoin(MySFunction<T, TE> leftCondition, default <R, TE, RE> Children innerJoin(MySFunction<T, TE> leftCondition,
MySFunction<R, RE> rightCondition, MySFunction<R, RE> rightCondition,
Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) { Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
return innerJoin(true, null, leftCondition, rightCondition, 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); return innerJoin(true, alias, leftCondition, rightCondition, rightWrapper);
} }
default <R extends MyBaseEntity, TE, RE> Children innerJoin(boolean condition, default <R, TE, RE> Children innerJoin(boolean condition,
MySFunction<T, TE> leftCondition, MySFunction<T, TE> leftCondition,
MySFunction<R, RE> rightCondition, MySFunction<R, RE> rightCondition,
Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) { Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
return innerJoin(condition, null, leftCondition, rightCondition, rightWrapper); return innerJoin(condition, null, leftCondition, rightCondition, rightWrapper);
} }