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

update

Browse Source
This commit is contained in:
yulichang 2021-01-30 19:37:07 +08:00
parent af5fe0e0df
commit a1a04a2216
23 changed files with 1314 additions and 331 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

179
README.md
View File

@ -14,7 +14,7 @@
1. 将代码down到本地，使用maven install 1. 将代码down到本地，使用maven install
2. 在自己的项目中替换mybatisplus依赖(框架依赖mybatisplus<3.4.2>) 2. 在自己的项目中添加依赖
```xml ```xml
<dependency> <dependency>
@ -26,12 +26,9 @@
### 方法二 ### 方法二
1. 将mybatisplus目录复制到你的工程中 1. 将mybatisplus目录复制到你的工程中的springboot扫描路径下
2. 如果mybatisplus目录不在springboot扫描路径下, 2. 添加cglib依赖
将MybatisPlusConfiguration移动到springboot扫描路径下或添加springboot扫描路径
3. 添加cglib依赖
```xml ```xml
<dependency> <dependency>
@ -47,9 +44,152 @@
* service继承MyBaseService (可选) * service继承MyBaseService (可选)
* serviceImpl继承MyBaseServiceImpl (可选) * serviceImpl继承MyBaseServiceImpl (可选)
### MyLambdaQueryWrapper用法 ## MyQueryWrapper用法
#### select(UserEntity::getId) 查询指定的字段,支持可变参数 简单的3表查询
```java
class test {
@Resource
private UserMapper userMapper;
void testJoin() {
List<UserDTO> list = userMapper.selectJoinList(UserDTO.class,
new MyLambdaQuery<UserDO>()
.selectAll(UserDO.class)
.select("addr.tel", "addr.address")
.select("a.province")
.leftJoin("user_address addr on t.id = addr.user_id")
.rightJoin("area a on addr.area_id = a.id")
.eq(true, UserDO::getId, 1)
.stringQuery()
.like(true, "addr.tel", "1")
.le(true, "a.province", "1"));
}
}
```
对应sql
```sql
SELECT
t.id,
t.name,
t.sex,
t.head_img,
addr.tel,
addr.address,
a.province
FROM
user t
LEFT JOIN user_address addr on t.id = addr.user_id
RIGHT JOIN area a on addr.area_id = a.id
WHERE (
t.id = ?
AND addr.tel LIKE ?
AND a.province <= ?)
```
说明:
* UserDTO.class 查询结果类(resultType)
* selectAll(UserDO.class) 查询主表全部字段(主表实体类)
* select() mp的select策略是覆盖,这里的策略是追加,可以一直select
主表字段可以用lambda,会自动添加表别名,主表别名默认是 t ,非主表字段必须带别名查询
* leftJoin() rightJoin() innerJoin() 传sql片段 格式 (表 + 别名 + 关联条件)
* stringQuery() lambda查询转string查询
* lambda() string查询转lambda查询
* sql组装由mp完成,正常使用没有sql注入风险
分页查询
```java
class test {
@Resource
private UserMapper userMapper;
void testJoin() {
IPage<UserDTO> page = userMapper.selectJoinPage(new Page<>(1, 10), UserDTO.class,
new MyLambdaQuery<UserDO>()
.selectAll(UserDO.class)
.select("addr.tel", "addr.address")
.select("a.province")
.leftJoin("user_address addr on t.id = addr.user_id")
.rightJoin("area a on addr.area_id = a.id"));
}
}
```
对应sql
```sql
SELECT
t.id,
t.name,
t.sex,
t.head_img,
addr.tel,
addr.address,
a.province
FROM
user t
LEFT JOIN user_address addr on t.id = addr.user_id
RIGHT JOIN area a on addr.area_id = a.id
LIMIT ?,?
```
还可以怎么操作,但不建议
```java
class test {
@Resource
private UserMapper userMapper;
void testJoin() {
List<UserDTO> list = userMapper.selectJoinList(UserDTO.class,
new MyLambdaQuery<UserDO>()
.selectAll(UserDO.class)
.select("addr.tel", "addr.address")
//行列转换
.select("CASE t.sex WHEN '男' THEN '1' ELSE '0' END AS sex")
//求和函数
.select("sum(a.province) as province")
//自定义数据集
.leftJoin("(select * from user_address) addr on t.id = addr.user_id")
.rightJoin("area a on addr.area_id = a.id")
.eq(true, UserDO::getId, 1)
.stringQuery()
.like(true, "addr.tel", "1")
.le(true, "a.province", "1")
.orderByDesc("addr.id"));
}
}
```
对应sql
```sql
SELECT
t.id,
t.name,
t.sex,
t.head_img,
addr.tel,
addr.address,
CASE t.sex WHEN '男' THEN '1' ELSE '0' END AS sex,
sum(a.province) as province
FROM
user t
LEFT JOIN (select * from user_address) addr on t.id = addr.user_id
RIGHT JOIN area a on addr.area_id = a.id
WHERE (
t.id = ?
AND addr.tel LIKE ?
AND a.province <= ?)
ORDER BY addr.id DESC
```
# MyLambdaQueryWrapper用法
### MyLambdaQueryWrapper更符合面向对象(OOP),没有难以理解的常量(魔术值),全部基于lambda,但好像不那么好理解
简单的3表查询 简单的3表查询
@ -101,8 +241,6 @@ class test {
} }
``` ```
#### selectAll() 查询UserEntity全部字段
查询user全部字段和user_address表中的address,tel 查询user全部字段和user_address表中的address,tel
```java ```java
@ -111,11 +249,10 @@ class test {
private UserMapper userMapper; private UserMapper userMapper;
void testJoin() { void testJoin() {
List<UserDTO> list = userMapper.selectJoinList(new MyLambdaQueryWrapper<UserEntity>() List<UserDTO> list = userMapper.selectJoinList(UserDTO.class, new MyLambdaQueryWrapper<UserEntity>()
.selectAll(UserEntity.class) .selectAll(UserEntity.class)
.leftJoin(UserEntity::getId, UserAddressEntity::getUserId, .leftJoin(UserEntity::getId, UserAddressEntity::getUserId,
right -> right.select(UserAddressEntity::getAddress, UserAddressEntity::getTel)) right -> right.select(UserAddressEntity::getAddress, UserAddressEntity::getTel)));
, UserDTO.class);
} }
} }
``` ```
@ -133,8 +270,6 @@ FROM user t0
LEFT JOIN user_address t1 ON t0.id = t1.user_id LEFT JOIN user_address t1 ON t0.id = t1.user_id
``` ```
#### as(UserEntity::getHeadImg,UserDTO::getUserHeadImg)
查询字段别名 head_img as userHeadImg 查询字段别名 head_img as userHeadImg
```java ```java
@ -143,11 +278,10 @@ class test {
private UserMapper userMapper; private UserMapper userMapper;
void testJoin() { void testJoin() {
List<UserDTO> list = userMapper.selectJoinList(new MyLambdaQueryWrapper<UserEntity>() List<UserDTO> list = userMapper.selectJoinList(UserDTO.class, new MyLambdaQueryWrapper<UserEntity>()
.as(UserEntity::getHeadImg, UserDTO::getUserHeadImg) .as(UserEntity::getHeadImg, UserDTO::getUserHeadImg)
.leftJoin(UserEntity::getId, UserAddressEntity::getUserId, .leftJoin(UserEntity::getId, UserAddressEntity::getUserId,
right -> right.select(UserAddressEntity::getAddress, UserAddressEntity::getTel)) right -> right.select(UserAddressEntity::getAddress, UserAddressEntity::getTel)));
, UserDTO.class);
} }
} }
``` ```
@ -168,7 +302,7 @@ FROM user t0
user left join user_address on user.id = User_address.user_id user left join user_address on user.id = User_address.user_id
第三个参数是右表wrapper对象,可以继续使用,以上方法. 第三个参数是右表wrapper对象,可以继续使用,以上方法.
#### 条件查询eq() 连表条件查询
```java ```java
class test { class test {
@ -176,14 +310,13 @@ class test {
private UserMapper userMapper; private UserMapper userMapper;
void testJoin() { void testJoin() {
List<UserDTO> list = userMapper.selectJoinList(new MyLambdaQueryWrapper<UserEntity>() List<UserDTO> list = userMapper.selectJoinList(UserDTO.class, new MyLambdaQueryWrapper<UserEntity>()
.selectAll(UserEntity.class) .selectAll(UserEntity.class)
.leftJoin(UserEntity::getId, UserAddressEntity::getUserId, .leftJoin(UserEntity::getId, UserAddressEntity::getUserId,
right -> right.select(UserAddressEntity::getAddress, UserAddressEntity::getTel)) right -> right.select(UserAddressEntity::getAddress, UserAddressEntity::getTel))
.eq(true, UserEntity::getId, 1) .eq(true, UserEntity::getId, 1)
.like(UserAddressEntity::getTel, "1") .like(UserAddressEntity::getTel, "1")
.eq(UserEntity::getId, UserAddressEntity::getUserId) .eq(UserEntity::getId, UserAddressEntity::getUserId));
, UserDTO.class);
} }
} }
``` ```
@ -205,5 +338,3 @@ WHERE (
AND t0.id = t1.user_id) AND t0.id = t1.user_id)
``` ```
#### [参考测试类](https://gitee.com/best_handsome/mybatis-plus-join/blob/master/src/test/java/com/example/mp/MpJoinTest.java)

13
src/main/java/com/github/mybatisplus/base/MyBaseMapper.java
View File

@ -20,9 +20,9 @@ public interface MyBaseMapper<T> extends BaseMapper<T> {
* 连表查询返回一条记录 * 连表查询返回一条记录
* *
* @param queryWrapper joinWrapper * @param queryWrapper joinWrapper
* @param clazz 返回对象class * @param clazz resultType
*/ */
<DTO> DTO selectJoinOne(@Param(Constants.WRAPPER) Wrapper<?> queryWrapper, @Param(Constant.CLAZZ) Class<DTO> clazz); <DTO> DTO selectJoinOne(@Param(Constant.CLAZZ) Class<DTO> clazz, @Param(Constants.WRAPPER) Wrapper<?> queryWrapper);
/** /**
* 连表查询返回Map * 连表查询返回Map
@ -35,9 +35,9 @@ public interface MyBaseMapper<T> extends BaseMapper<T> {
* 连表查询返回记录集合 * 连表查询返回记录集合
* *
* @param queryWrapper joinWrapper * @param queryWrapper joinWrapper
* @param clazz 返回对象class * @param clazz resultType
*/ */
<DTO> List<DTO> selectJoinList(@Param(Constants.WRAPPER) Wrapper<?> queryWrapper,@Param(Constant.CLAZZ) Class<DTO> clazz); <DTO> List<DTO> selectJoinList(@Param(Constant.CLAZZ) Class<DTO> clazz, @Param(Constants.WRAPPER) Wrapper<?> queryWrapper);
/** /**
* 连表查询返回Map集合 * 连表查询返回Map集合
@ -50,9 +50,12 @@ public interface MyBaseMapper<T> extends BaseMapper<T> {
* 连表查询返回记录集合并分页 * 连表查询返回记录集合并分页
* *
* @param queryWrapper joinWrapper * @param queryWrapper joinWrapper
* @param clazz resultType
* @param <DTO> 分页返回对象 * @param <DTO> 分页返回对象
*/ */
<DTO, P extends IPage<?>> IPage<DTO> selectJoinPage(P page, @Param(Constants.WRAPPER) Wrapper<?> queryWrapper, @Param(Constant.CLAZZ) Class<DTO> clazz); <DTO, P extends IPage<?>> IPage<DTO> selectJoinPage(P page,
@Param(Constant.CLAZZ) Class<DTO> clazz,
@Param(Constants.WRAPPER) Wrapper<?> queryWrapper);
/** /**
* 连表查询返回Map集合并分页 * 连表查询返回Map集合并分页

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

@ -17,39 +17,39 @@ public interface MyBaseService<T> extends IService<T> {
/** /**
* ignore * ignore
*/ */
default <DTO> DTO selectJoinOne(MyWrapperFunc<T> wrapperFunc, Class<DTO> clazz) { default <DTO> DTO selectJoinOne(Class<DTO> clazz, MyWrapperFunc<T> wrapperFunc) {
return selectJoinOne(wrapperFunc.apply(new MyLambdaQueryWrapper<>()), clazz); return selectJoinOne(clazz, wrapperFunc.apply(new MyLambdaQueryWrapper<>()));
} }
/** /**
* 连接查询返回一条记录 * 连接查询返回一条记录
*/ */
<DTO> DTO selectJoinOne(MyLambdaQueryWrapper<T> wrapper, Class<DTO> clazz); <DTO> DTO selectJoinOne(Class<DTO> clazz, MyLambdaQueryWrapper<T> wrapper);
/** /**
* ignore * ignore
*/ */
default <DTO> List<DTO> selectJoinList(MyWrapperFunc<T> wrapperFunc, Class<DTO> clazz) { default <DTO> List<DTO> selectJoinList(Class<DTO> clazz, MyWrapperFunc<T> wrapperFunc) {
return selectJoinList(wrapperFunc.apply(new MyLambdaQueryWrapper<>()), clazz); return selectJoinList(clazz, wrapperFunc.apply(new MyLambdaQueryWrapper<>()));
} }
/** /**
* 连接查询返回集合 * 连接查询返回集合
*/ */
<DTO> List<DTO> selectJoinList(MyLambdaQueryWrapper<T> wrapper, Class<DTO> clazz); <DTO> List<DTO> selectJoinList(Class<DTO> clazz, MyLambdaQueryWrapper<T> wrapper);
/** /**
* ignore * ignore
*/ */
default <DTO, P extends IPage<?>> IPage<DTO> selectJoinListPage(P page, MyWrapperFunc<T> wrapperFunc, Class<DTO> clazz) { default <DTO, P extends IPage<?>> IPage<DTO> selectJoinListPage(P page, Class<DTO> clazz, MyWrapperFunc<T> wrapperFunc) {
return selectJoinListPage(page, wrapperFunc.apply(new MyLambdaQueryWrapper<>()), clazz); return selectJoinListPage(page, clazz, wrapperFunc.apply(new MyLambdaQueryWrapper<>()));
} }
/** /**
* 连接查询返回集合并分页 * 连接查询返回集合并分页
*/ */
<DTO, P extends IPage<?>> IPage<DTO> selectJoinListPage(P page, MyLambdaQueryWrapper<T> wrapper, Class<DTO> clazz); <DTO, P extends IPage<?>> IPage<DTO> selectJoinListPage(P page, Class<DTO> clazz, MyLambdaQueryWrapper<T> wrapper);
/** /**

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

@ -15,19 +15,19 @@ public class MyBaseServiceImpl<M extends MyBaseMapper<T>, T> extends ServiceImpl
@Override @Override
public <DTO> DTO selectJoinOne(MyLambdaQueryWrapper<T> wrapper, Class<DTO> clazz) { public <DTO> DTO selectJoinOne(Class<DTO> clazz, MyLambdaQueryWrapper<T> wrapper) {
return baseMapper.selectJoinOne(wrapper, clazz); return baseMapper.selectJoinOne(clazz, wrapper);
} }
@Override @Override
public <DTO> List<DTO> selectJoinList(MyLambdaQueryWrapper<T> wrapper, Class<DTO> clazz) { public <DTO> List<DTO> selectJoinList(Class<DTO> clazz, MyLambdaQueryWrapper<T> wrapper) {
return baseMapper.selectJoinList(wrapper, clazz); return baseMapper.selectJoinList(clazz, wrapper);
} }
@Override @Override
public <DTO, P extends IPage<?>> IPage<DTO> selectJoinListPage(P page, MyLambdaQueryWrapper<T> wrapper, Class<DTO> clazz) { public <DTO, P extends IPage<?>> IPage<DTO> selectJoinListPage(P page, Class<DTO> clazz, MyLambdaQueryWrapper<T> wrapper) {
return baseMapper.selectJoinPage(page, wrapper, clazz); return baseMapper.selectJoinPage(page, clazz, wrapper);
} }
@Override @Override

3
src/main/java/com/github/mybatisplus/interceptor/MyResultInterceptor.java
View File

@ -21,7 +21,6 @@ import java.util.Objects;
* @author yulichang * @author yulichang
*/ */
@Intercepts({@Signature(type = ResultSetHandler.class, method = "handleResultSets", args = {Statement.class})}) @Intercepts({@Signature(type = ResultSetHandler.class, method = "handleResultSets", args = {Statement.class})})
//@Intercepts({@Signature(type = ResultSetHandler.class, method = "handleCursorResultSets", args = {Statement.class})})
public class MyResultInterceptor implements Interceptor { public class MyResultInterceptor implements Interceptor {
@ -78,7 +77,7 @@ public class MyResultInterceptor implements Interceptor {
return (Class<?>) args.get("clazz"); return (Class<?>) args.get("clazz");
} }
} catch (Exception e) { } catch (Exception e) {
e.printStackTrace(); return null;
} }
} }
} }

3
src/main/java/com/github/mybatisplus/method/MyAbstractMethod.java
View File

@ -5,7 +5,6 @@ import com.baomidou.mybatisplus.core.metadata.TableInfo;
import com.baomidou.mybatisplus.core.toolkit.StringPool; import com.baomidou.mybatisplus.core.toolkit.StringPool;
import com.baomidou.mybatisplus.core.toolkit.sql.SqlScriptUtils; import com.baomidou.mybatisplus.core.toolkit.sql.SqlScriptUtils;
import com.github.mybatisplus.toolkit.Constant; import com.github.mybatisplus.toolkit.Constant;
import com.github.mybatisplus.wrapper.MyLambdaQueryWrapper;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.List; import java.util.List;
@ -24,7 +23,7 @@ public abstract class MyAbstractMethod extends AbstractMethod {
String[] columns = selectColumns.split(StringPool.COMMA); String[] columns = selectColumns.split(StringPool.COMMA);
List<String> selectColumnList = new ArrayList<>(); List<String> selectColumnList = new ArrayList<>();
for (String c : columns) { for (String c : columns) {
selectColumnList.add(Constant.TABLE_ALIAS + MyLambdaQueryWrapper.TABLE_ALIAS_INDEX + StringPool.DOT + c); selectColumnList.add(Constant.TABLE_ALIAS + StringPool.DOT + c);
} }
selectColumns = String.join(StringPool.COMMA, selectColumnList); selectColumns = String.join(StringPool.COMMA, selectColumnList);
} }

3
src/main/java/com/github/mybatisplus/method/SelectJoinList.java
View File

@ -2,7 +2,6 @@ package com.github.mybatisplus.method;
import com.baomidou.mybatisplus.core.metadata.TableInfo; import com.baomidou.mybatisplus.core.metadata.TableInfo;
import com.github.mybatisplus.toolkit.Constant; import com.github.mybatisplus.toolkit.Constant;
import com.github.mybatisplus.wrapper.MyLambdaQueryWrapper;
import org.apache.ibatis.mapping.MappedStatement; import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.SqlSource; import org.apache.ibatis.mapping.SqlSource;
@ -17,7 +16,7 @@ public class SelectJoinList extends MyAbstractMethod {
public MappedStatement injectMappedStatement(Class<?> mapperClass, Class<?> modelClass, TableInfo tableInfo) { public MappedStatement injectMappedStatement(Class<?> mapperClass, Class<?> modelClass, TableInfo tableInfo) {
SqlMethod sqlMethod = SqlMethod.SELECT_JOIN_LIST; SqlMethod sqlMethod = SqlMethod.SELECT_JOIN_LIST;
String sql = String.format(sqlMethod.getSql(), sqlSelectColumns(tableInfo, true), String sql = String.format(sqlMethod.getSql(), sqlSelectColumns(tableInfo, true),
tableInfo.getTableName(), Constant.TABLE_ALIAS + MyLambdaQueryWrapper.TABLE_ALIAS_INDEX, sqlWhereEntityWrapper(true, tableInfo), sqlComment()); tableInfo.getTableName(), Constant.TABLE_ALIAS, sqlWhereEntityWrapper(true, tableInfo), sqlComment());
SqlSource sqlSource = languageDriver.createSqlSource(configuration, sql, modelClass); SqlSource sqlSource = languageDriver.createSqlSource(configuration, sql, modelClass);
return this.addSelectMappedStatementForOther(mapperClass, sqlMethod.getMethod(), sqlSource, Map.class); return this.addSelectMappedStatementForOther(mapperClass, sqlMethod.getMethod(), sqlSource, Map.class);
} }

3
src/main/java/com/github/mybatisplus/method/SelectJoinMap.java
View File

@ -2,7 +2,6 @@ package com.github.mybatisplus.method;
import com.baomidou.mybatisplus.core.metadata.TableInfo; import com.baomidou.mybatisplus.core.metadata.TableInfo;
import com.github.mybatisplus.toolkit.Constant; import com.github.mybatisplus.toolkit.Constant;
import com.github.mybatisplus.wrapper.MyLambdaQueryWrapper;
import org.apache.ibatis.mapping.MappedStatement; import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.SqlSource; import org.apache.ibatis.mapping.SqlSource;
@ -17,7 +16,7 @@ public class SelectJoinMap extends MyAbstractMethod {
public MappedStatement injectMappedStatement(Class<?> mapperClass, Class<?> modelClass, TableInfo tableInfo) { public MappedStatement injectMappedStatement(Class<?> mapperClass, Class<?> modelClass, TableInfo tableInfo) {
SqlMethod sqlMethod = SqlMethod.SELECT_JOIN_MAP; SqlMethod sqlMethod = SqlMethod.SELECT_JOIN_MAP;
String sql = String.format(sqlMethod.getSql(), sqlSelectColumns(tableInfo, true), String sql = String.format(sqlMethod.getSql(), sqlSelectColumns(tableInfo, true),
tableInfo.getTableName(), Constant.TABLE_ALIAS + MyLambdaQueryWrapper.TABLE_ALIAS_INDEX, sqlWhereEntityWrapper(true, tableInfo), sqlComment()); tableInfo.getTableName(), Constant.TABLE_ALIAS, sqlWhereEntityWrapper(true, tableInfo), sqlComment());
SqlSource sqlSource = languageDriver.createSqlSource(configuration, sql, modelClass); SqlSource sqlSource = languageDriver.createSqlSource(configuration, sql, modelClass);
return this.addSelectMappedStatementForOther(mapperClass, sqlMethod.getMethod(), sqlSource, Map.class); return this.addSelectMappedStatementForOther(mapperClass, sqlMethod.getMethod(), sqlSource, Map.class);
} }

3
src/main/java/com/github/mybatisplus/method/SelectJoinMaps.java
View File

@ -2,7 +2,6 @@ package com.github.mybatisplus.method;
import com.baomidou.mybatisplus.core.metadata.TableInfo; import com.baomidou.mybatisplus.core.metadata.TableInfo;
import com.github.mybatisplus.toolkit.Constant; import com.github.mybatisplus.toolkit.Constant;
import com.github.mybatisplus.wrapper.MyLambdaQueryWrapper;
import org.apache.ibatis.mapping.MappedStatement; import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.SqlSource; import org.apache.ibatis.mapping.SqlSource;
@ -17,7 +16,7 @@ public class SelectJoinMaps extends MyAbstractMethod {
public MappedStatement injectMappedStatement(Class<?> mapperClass, Class<?> modelClass, TableInfo tableInfo) { public MappedStatement injectMappedStatement(Class<?> mapperClass, Class<?> modelClass, TableInfo tableInfo) {
SqlMethod sqlMethod = SqlMethod.SELECT_JOIN_MAPS; SqlMethod sqlMethod = SqlMethod.SELECT_JOIN_MAPS;
String sql = String.format(sqlMethod.getSql(), sqlSelectColumns(tableInfo, true), String sql = String.format(sqlMethod.getSql(), sqlSelectColumns(tableInfo, true),
tableInfo.getTableName(), Constant.TABLE_ALIAS + MyLambdaQueryWrapper.TABLE_ALIAS_INDEX, sqlWhereEntityWrapper(true, tableInfo), sqlComment()); tableInfo.getTableName(), Constant.TABLE_ALIAS, sqlWhereEntityWrapper(true, tableInfo), sqlComment());
SqlSource sqlSource = languageDriver.createSqlSource(configuration, sql, modelClass); SqlSource sqlSource = languageDriver.createSqlSource(configuration, sql, modelClass);
return this.addSelectMappedStatementForOther(mapperClass, sqlMethod.getMethod(), sqlSource, Map.class); return this.addSelectMappedStatementForOther(mapperClass, sqlMethod.getMethod(), sqlSource, Map.class);
} }

3
src/main/java/com/github/mybatisplus/method/SelectJoinMapsPage.java
View File

@ -2,7 +2,6 @@ package com.github.mybatisplus.method;
import com.baomidou.mybatisplus.core.metadata.TableInfo; import com.baomidou.mybatisplus.core.metadata.TableInfo;
import com.github.mybatisplus.toolkit.Constant; import com.github.mybatisplus.toolkit.Constant;
import com.github.mybatisplus.wrapper.MyLambdaQueryWrapper;
import org.apache.ibatis.mapping.MappedStatement; import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.SqlSource; import org.apache.ibatis.mapping.SqlSource;
@ -17,7 +16,7 @@ public class SelectJoinMapsPage extends MyAbstractMethod {
public MappedStatement injectMappedStatement(Class<?> mapperClass, Class<?> modelClass, TableInfo tableInfo) { public MappedStatement injectMappedStatement(Class<?> mapperClass, Class<?> modelClass, TableInfo tableInfo) {
SqlMethod sqlMethod = SqlMethod.SELECT_JOIN_MAPS_PAGE; SqlMethod sqlMethod = SqlMethod.SELECT_JOIN_MAPS_PAGE;
String sql = String.format(sqlMethod.getSql(), sqlSelectColumns(tableInfo, true), String sql = String.format(sqlMethod.getSql(), sqlSelectColumns(tableInfo, true),
tableInfo.getTableName(), Constant.TABLE_ALIAS + MyLambdaQueryWrapper.TABLE_ALIAS_INDEX, sqlWhereEntityWrapper(true, tableInfo), sqlComment()); tableInfo.getTableName(), Constant.TABLE_ALIAS, sqlWhereEntityWrapper(true, tableInfo), sqlComment());
SqlSource sqlSource = languageDriver.createSqlSource(configuration, sql, modelClass); SqlSource sqlSource = languageDriver.createSqlSource(configuration, sql, modelClass);
return this.addSelectMappedStatementForOther(mapperClass, sqlMethod.getMethod(), sqlSource, Map.class); return this.addSelectMappedStatementForOther(mapperClass, sqlMethod.getMethod(), sqlSource, Map.class);
} }

3
src/main/java/com/github/mybatisplus/method/SelectJoinOne.java
View File

@ -2,7 +2,6 @@ package com.github.mybatisplus.method;
import com.baomidou.mybatisplus.core.metadata.TableInfo; import com.baomidou.mybatisplus.core.metadata.TableInfo;
import com.github.mybatisplus.toolkit.Constant; import com.github.mybatisplus.toolkit.Constant;
import com.github.mybatisplus.wrapper.MyLambdaQueryWrapper;
import org.apache.ibatis.mapping.MappedStatement; import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.SqlSource; import org.apache.ibatis.mapping.SqlSource;
@ -17,7 +16,7 @@ public class SelectJoinOne extends MyAbstractMethod {
public MappedStatement injectMappedStatement(Class<?> mapperClass, Class<?> modelClass, TableInfo tableInfo) { public MappedStatement injectMappedStatement(Class<?> mapperClass, Class<?> modelClass, TableInfo tableInfo) {
SqlMethod sqlMethod = SqlMethod.SELECT_JOIN_ONE; SqlMethod sqlMethod = SqlMethod.SELECT_JOIN_ONE;
String sql = String.format(sqlMethod.getSql(), sqlSelectColumns(tableInfo, true), String sql = String.format(sqlMethod.getSql(), sqlSelectColumns(tableInfo, true),
tableInfo.getTableName(), Constant.TABLE_ALIAS + MyLambdaQueryWrapper.TABLE_ALIAS_INDEX, sqlWhereEntityWrapper(true, tableInfo), sqlComment()); tableInfo.getTableName(), Constant.TABLE_ALIAS, sqlWhereEntityWrapper(true, tableInfo), sqlComment());
SqlSource sqlSource = languageDriver.createSqlSource(configuration, sql, modelClass); SqlSource sqlSource = languageDriver.createSqlSource(configuration, sql, modelClass);
return this.addSelectMappedStatementForOther(mapperClass, sqlMethod.getMethod(), sqlSource, Map.class); return this.addSelectMappedStatementForOther(mapperClass, sqlMethod.getMethod(), sqlSource, Map.class);
} }

3
src/main/java/com/github/mybatisplus/method/SelectJoinPage.java
View File

@ -2,7 +2,6 @@ package com.github.mybatisplus.method;
import com.baomidou.mybatisplus.core.metadata.TableInfo; import com.baomidou.mybatisplus.core.metadata.TableInfo;
import com.github.mybatisplus.toolkit.Constant; import com.github.mybatisplus.toolkit.Constant;
import com.github.mybatisplus.wrapper.MyLambdaQueryWrapper;
import org.apache.ibatis.mapping.MappedStatement; import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.SqlSource; import org.apache.ibatis.mapping.SqlSource;
@ -17,7 +16,7 @@ public class SelectJoinPage extends MyAbstractMethod {
public MappedStatement injectMappedStatement(Class<?> mapperClass, Class<?> modelClass, TableInfo tableInfo) { public MappedStatement injectMappedStatement(Class<?> mapperClass, Class<?> modelClass, TableInfo tableInfo) {
SqlMethod sqlMethod = SqlMethod.SELECT_JOIN_PAGE; SqlMethod sqlMethod = SqlMethod.SELECT_JOIN_PAGE;
String sql = String.format(sqlMethod.getSql(), sqlSelectColumns(tableInfo, true), String sql = String.format(sqlMethod.getSql(), sqlSelectColumns(tableInfo, true),
tableInfo.getTableName(), Constant.TABLE_ALIAS + MyLambdaQueryWrapper.TABLE_ALIAS_INDEX, sqlWhereEntityWrapper(true, tableInfo), sqlComment()); tableInfo.getTableName(), Constant.TABLE_ALIAS, sqlWhereEntityWrapper(true, tableInfo), sqlComment());
SqlSource sqlSource = languageDriver.createSqlSource(configuration, sql, modelClass); SqlSource sqlSource = languageDriver.createSqlSource(configuration, sql, modelClass);
return this.addSelectMappedStatementForOther(mapperClass, sqlMethod.getMethod(), sqlSource, Map.class); return this.addSelectMappedStatementForOther(mapperClass, sqlMethod.getMethod(), sqlSource, Map.class);
} }

85
src/main/java/com/github/mybatisplus/query/MyAbstractLambda.java Normal file
View File

@ -0,0 +1,85 @@
package com.github.mybatisplus.query;
import com.baomidou.mybatisplus.core.toolkit.Assert;
import com.baomidou.mybatisplus.core.toolkit.LambdaUtils;
import com.baomidou.mybatisplus.core.toolkit.StringPool;
import com.baomidou.mybatisplus.core.toolkit.support.ColumnCache;
import com.baomidou.mybatisplus.core.toolkit.support.SFunction;
import com.baomidou.mybatisplus.core.toolkit.support.SerializedLambda;
import com.github.mybatisplus.toolkit.Constant;
import org.apache.ibatis.reflection.property.PropertyNamer;
import java.util.Arrays;
import java.util.Map;
import static java.util.stream.Collectors.joining;
/**
* copy {@link com.baomidou.mybatisplus.core.conditions.AbstractLambdaWrapper}
*/
@SuppressWarnings("serial")
public abstract class MyAbstractLambda<T, Children extends MyAbstractLambda<T, Children>>
extends MyAbstractWrapper<T, SFunction<T, ?>, Children> {
private Map<String, ColumnCache> columnMap = null;
private boolean initColumnMap = false;
@SuppressWarnings("unchecked")
@Override
protected String columnsToString(SFunction<T, ?>... columns) {
return columnsToString(true, columns);
}
@SuppressWarnings("unchecked")
protected String columnsToString(boolean onlyColumn, SFunction<T, ?>... columns) {
return Arrays.stream(columns).map(i -> Constant.TABLE_ALIAS + StringPool.DOT + columnToString(i, onlyColumn)).collect(joining(StringPool.COMMA));
}
@Override
protected String columnToString(SFunction<T, ?> column) {
return columnToString(column, true);
}
protected String columnToString(SFunction<T, ?> column, boolean onlyColumn) {
return Constant.TABLE_ALIAS + StringPool.DOT + getColumn(LambdaUtils.resolve(column), onlyColumn);
}
/**
* 获取 SerializedLambda 对应的列信息，从 lambda 表达式中推测实体类
* <p>
* 如果获取不到列信息，那么本次条件组装将会失败
*
* @param lambda lambda 表达式
* @param onlyColumn 如果是，结果: "name", 如果否： "name" as "name"
* @return 列
* @throws com.baomidou.mybatisplus.core.exceptions.MybatisPlusException 获取不到列信息时抛出异常
* @see SerializedLambda#getImplClass()
* @see SerializedLambda#getImplMethodName()
*/
private String getColumn(SerializedLambda lambda, boolean onlyColumn) {
Class<?> aClass = lambda.getInstantiatedType();
tryInitCache(aClass);
String fieldName = PropertyNamer.methodToProperty(lambda.getImplMethodName());
ColumnCache columnCache = getColumnCache(fieldName, aClass);
return onlyColumn ? columnCache.getColumn() : columnCache.getColumnSelect();
}
private void tryInitCache(Class<?> lambdaClass) {
if (!initColumnMap) {
final Class<T> entityClass = getEntityClass();
if (entityClass != null) {
lambdaClass = entityClass;
}
columnMap = LambdaUtils.getColumnMap(lambdaClass);
initColumnMap = true;
}
Assert.notNull(columnMap, "can not find lambda cache for this entity [%s]", lambdaClass.getName());
}
private ColumnCache getColumnCache(String fieldName, Class<?> lambdaClass) {
ColumnCache columnCache = columnMap.get(LambdaUtils.formatKey(fieldName));
Assert.notNull(columnCache, "can not find lambda cache for this property [%s] of entity [%s]",
fieldName, lambdaClass.getName());
return columnCache;
}
}

543
src/main/java/com/github/mybatisplus/query/MyAbstractWrapper.java Normal file
View File

@ -0,0 +1,543 @@
package com.github.mybatisplus.query;
import com.baomidou.mybatisplus.core.conditions.ISqlSegment;
import com.baomidou.mybatisplus.core.conditions.SharedString;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.interfaces.Compare;
import com.baomidou.mybatisplus.core.conditions.interfaces.Func;
import com.baomidou.mybatisplus.core.conditions.interfaces.Join;
import com.baomidou.mybatisplus.core.conditions.interfaces.Nested;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.segments.MergeSegments;
import com.baomidou.mybatisplus.core.enums.SqlKeyword;
import com.baomidou.mybatisplus.core.enums.SqlLike;
import com.baomidou.mybatisplus.core.toolkit.*;
import com.baomidou.mybatisplus.core.toolkit.sql.SqlUtils;
import com.baomidou.mybatisplus.core.toolkit.sql.StringEscape;
import com.github.mybatisplus.query.interfaces.MyJoin;
import com.github.mybatisplus.toolkit.Constant;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.BiPredicate;
import java.util.function.Consumer;
import static com.baomidou.mybatisplus.core.enums.SqlKeyword.*;
import static com.baomidou.mybatisplus.core.enums.WrapperKeyword.APPLY;
import static java.util.stream.Collectors.joining;
/**
* copy {@link com.baomidou.mybatisplus.core.conditions.AbstractWrapper}
*/
@SuppressWarnings({"serial", "unchecked"})
public abstract class MyAbstractWrapper<T, R, Children extends MyAbstractWrapper<T, R, Children>> extends Wrapper<T>
implements Compare<Children, R>, Nested<Children, Children>, Join<Children>, Func<Children, R>, MyJoin<Children> {
/**
* 占位符
*/
protected final Children typedThis = (Children) this;
/**
* 必要度量
*/
protected AtomicInteger paramNameSeq;
protected Map<String, Object> paramNameValuePairs;
protected SharedString lastSql;
/**
* SQL注释
*/
protected SharedString sqlComment;
/**
* SQL起始语句
*/
protected SharedString sqlFirst;
/**
* 连表字段
*/
protected SharedString from = SharedString.emptyString();
/**
* ß
* 数据库表映射实体类
*/
private T entity;
protected MergeSegments expression;
/**
* 实体类型(主要用于确定泛型以及取TableInfo缓存)
*/
private Class<T> entityClass;
@Override
public T getEntity() {
return entity;
}
public Children setEntity(T entity) {
this.entity = entity;
return typedThis;
}
public Class<T> getEntityClass() {
if (entityClass == null && entity != null) {
entityClass = (Class<T>) entity.getClass();
}
return entityClass;
}
public Children setEntityClass(Class<T> entityClass) {
if (entityClass != null) {
this.entityClass = entityClass;
}
return typedThis;
}
@Override
public Children leftJoin(boolean condition, String joinSql) {
if (condition) {
from.setStringValue(from.getStringValue() + Constant.LEFT_JOIN + joinSql);
}
return typedThis;
}
@Override
public Children rightJoin(boolean condition, String joinSql) {
if (condition) {
from.setStringValue(from.getStringValue() + Constant.RIGHT_JOIN + joinSql);
}
return typedThis;
}
@Override
public Children innerJoin(boolean condition, String joinSql) {
if (condition) {
from.setStringValue(from.getStringValue() + Constant.INNER_JOIN + joinSql);
}
return typedThis;
}
@Override
public <V> Children allEq(boolean condition, Map<R, V> params, boolean null2IsNull) {
if (condition && CollectionUtils.isNotEmpty(params)) {
params.forEach((k, v) -> {
if (StringUtils.checkValNotNull(v)) {
eq(k, v);
} else {
if (null2IsNull) {
isNull(k);
}
}
});
}
return typedThis;
}
@Override
public <V> Children allEq(boolean condition, BiPredicate<R, V> filter, Map<R, V> params, boolean null2IsNull) {
if (condition && CollectionUtils.isNotEmpty(params)) {
params.forEach((k, v) -> {
if (filter.test(k, v)) {
if (StringUtils.checkValNotNull(v)) {
eq(k, v);
} else {
if (null2IsNull) {
isNull(k);
}
}
}
});
}
return typedThis;
}
@Override
public Children eq(boolean condition, R column, Object val) {
return addCondition(condition, column, EQ, val);
}
@Override
public Children ne(boolean condition, R column, Object val) {
return addCondition(condition, column, NE, val);
}
@Override
public Children gt(boolean condition, R column, Object val) {
return addCondition(condition, column, GT, val);
}
@Override
public Children ge(boolean condition, R column, Object val) {
return addCondition(condition, column, GE, val);
}
@Override
public Children lt(boolean condition, R column, Object val) {
return addCondition(condition, column, LT, val);
}
@Override
public Children le(boolean condition, R column, Object val) {
return addCondition(condition, column, LE, val);
}
@Override
public Children like(boolean condition, R column, Object val) {
return likeValue(condition, LIKE, column, val, SqlLike.DEFAULT);
}
@Override
public Children notLike(boolean condition, R column, Object val) {
return likeValue(condition, NOT_LIKE, column, val, SqlLike.DEFAULT);
}
@Override
public Children likeLeft(boolean condition, R column, Object val) {
return likeValue(condition, LIKE, column, val, SqlLike.LEFT);
}
@Override
public Children likeRight(boolean condition, R column, Object val) {
return likeValue(condition, LIKE, column, val, SqlLike.RIGHT);
}
@Override
public Children between(boolean condition, R column, Object val1, Object val2) {
return doIt(condition, () -> columnToString(column), BETWEEN, () -> formatSql("{0}", val1), AND,
() -> formatSql("{0}", val2));
}
@Override
public Children notBetween(boolean condition, R column, Object val1, Object val2) {
return doIt(condition, () -> columnToString(column), NOT_BETWEEN, () -> formatSql("{0}", val1), AND,
() -> formatSql("{0}", val2));
}
@Override
public Children and(boolean condition, Consumer<Children> consumer) {
return and(condition).addNestedCondition(condition, consumer);
}
@Override
public Children or(boolean condition, Consumer<Children> consumer) {
return or(condition).addNestedCondition(condition, consumer);
}
@Override
public Children nested(boolean condition, Consumer<Children> consumer) {
return addNestedCondition(condition, consumer);
}
@Override
public Children not(boolean condition, Consumer<Children> consumer) {
return not(condition).addNestedCondition(condition, consumer);
}
@Override
public Children or(boolean condition) {
return doIt(condition, OR);
}
@Override
public Children apply(boolean condition, String applySql, Object... value) {
return doIt(condition, APPLY, () -> formatSql(applySql, value));
}
@Override
public Children last(boolean condition, String lastSql) {
if (condition) {
this.lastSql.setStringValue(StringPool.SPACE + lastSql);
}
return typedThis;
}
@Override
public Children comment(boolean condition, String comment) {
if (condition) {
this.sqlComment.setStringValue(comment);
}
return typedThis;
}
@Override
public Children first(boolean condition, String firstSql) {
if (condition) {
this.sqlFirst.setStringValue(firstSql);
}
return typedThis;
}
@Override
public Children exists(boolean condition, String existsSql) {
return doIt(condition, EXISTS, () -> String.format("(%s)", existsSql));
}
@Override
public Children notExists(boolean condition, String existsSql) {
return not(condition).exists(condition, existsSql);
}
@Override
public Children isNull(boolean condition, R column) {
return doIt(condition, () -> columnToString(column), IS_NULL);
}
@Override
public Children isNotNull(boolean condition, R column) {
return doIt(condition, () -> columnToString(column), IS_NOT_NULL);
}
@Override
public Children in(boolean condition, R column, Collection<?> coll) {
return doIt(condition, () -> columnToString(column), IN, inExpression(coll));
}
@Override
public Children notIn(boolean condition, R column, Collection<?> coll) {
return doIt(condition, () -> columnToString(column), NOT_IN, inExpression(coll));
}
@Override
public Children inSql(boolean condition, R column, String inValue) {
return doIt(condition, () -> columnToString(column), IN, () -> String.format("(%s)", inValue));
}
@Override
public Children notInSql(boolean condition, R column, String inValue) {
return doIt(condition, () -> columnToString(column), NOT_IN, () -> String.format("(%s)", inValue));
}
@Override
public Children groupBy(boolean condition, R... columns) {
if (ArrayUtils.isEmpty(columns)) {
return typedThis;
}
return doIt(condition, GROUP_BY,
() -> columns.length == 1 ? columnToString(columns[0]) : columnsToString(columns));
}
@Override
public Children orderBy(boolean condition, boolean isAsc, R... columns) {
if (ArrayUtils.isEmpty(columns)) {
return typedThis;
}
SqlKeyword mode = isAsc ? ASC : DESC;
for (R column : columns) {
doIt(condition, ORDER_BY, () -> columnToString(column), mode);
}
return typedThis;
}
@Override
public Children having(boolean condition, String sqlHaving, Object... params) {
return doIt(condition, HAVING, () -> formatSqlIfNeed(condition, sqlHaving, params));
}
@Override
public Children func(boolean condition, Consumer<Children> consumer) {
if (condition) {
consumer.accept(typedThis);
}
return typedThis;
}
/**
* 内部自用
* <p>NOT 关键词</p>
*/
protected Children not(boolean condition) {
return doIt(condition, NOT);
}
/**
* 内部自用
* <p>拼接 AND</p>
*/
protected Children and(boolean condition) {
return doIt(condition, AND);
}
/**
* 内部自用
* <p>拼接 LIKE 以及 值</p>
*/
protected Children likeValue(boolean condition, SqlKeyword keyword, R column, Object val, SqlLike sqlLike) {
return doIt(condition, () -> columnToString(column), keyword, () -> formatSql("{0}", SqlUtils.concatLike(val, sqlLike)));
}
/**
* 普通查询条件
*
* @param condition 是否执行
* @param column 属性
* @param sqlKeyword SQL 关键词
* @param val 条件值
*/
protected Children addCondition(boolean condition, R column, SqlKeyword sqlKeyword, Object val) {
return doIt(condition, () -> columnToString(column), sqlKeyword, () -> formatSql("{0}", val));
}
/**
* 多重嵌套查询条件
*
* @param condition 查询条件值
*/
protected Children addNestedCondition(boolean condition, Consumer<Children> consumer) {
if (condition) {
final Children instance = instance();
consumer.accept(instance);
return doIt(true, APPLY, instance);
}
return typedThis;
}
/**
* 子类返回一个自己的新对象
*/
protected abstract Children instance();
/**
* 格式化SQL
*
* @param sqlStr SQL语句部分
* @param params 参数集
* @return sql
*/
protected final String formatSql(String sqlStr, Object... params) {
return formatSqlIfNeed(true, sqlStr, params);
}
/**
* <p>
* 根据需要格式化SQL<br>
* <br>
* Format SQL for methods: EntityQ<T>.where/and/or...("name={0}", value);
* ALL the {<b>i</b>} will be replaced with #{MPGENVAL<b>i</b>}<br>
* <br>
* ew.where("sample_name=<b>{0}</b>", "haha").and("sample_age &gt;<b>{0}</b>
* and sample_age&lt;<b>{1}</b>", 18, 30) <b>TO</b>
* sample_name=<b>#{MPGENVAL1}</b> and sample_age&gt;#<b>{MPGENVAL2}</b> and
* sample_age&lt;<b>#{MPGENVAL3}</b><br>
* </p>
*
* @param need 是否需要格式化
* @param sqlStr SQL语句部分
* @param params 参数集
* @return sql
*/
protected final String formatSqlIfNeed(boolean need, String sqlStr, Object... params) {
if (!need || StringUtils.isBlank(sqlStr)) {
return null;
}
if (ArrayUtils.isNotEmpty(params)) {
for (int i = 0; i < params.length; ++i) {
String genParamName = Constants.WRAPPER_PARAM + paramNameSeq.incrementAndGet();
sqlStr = sqlStr.replace(String.format("{%s}", i),
String.format(Constants.WRAPPER_PARAM_FORMAT, Constants.WRAPPER, genParamName));
paramNameValuePairs.put(genParamName, params[i]);
}
}
return sqlStr;
}
/**
* 获取in表达式 包含括号
*
* @param value 集合
*/
private ISqlSegment inExpression(Collection<?> value) {
return () -> value.stream().map(i -> formatSql("{0}", i))
.collect(joining(StringPool.COMMA, StringPool.LEFT_BRACKET, StringPool.RIGHT_BRACKET));
}
/**
* 必要的初始化
*/
protected void initNeed() {
paramNameSeq = new AtomicInteger(0);
paramNameValuePairs = new HashMap<>(16);
expression = new MergeSegments();
lastSql = SharedString.emptyString();
sqlComment = SharedString.emptyString();
sqlFirst = SharedString.emptyString();
}
@Override
public void clear() {
entity = null;
paramNameSeq.set(0);
paramNameValuePairs.clear();
expression.clear();
lastSql.toEmpty();
sqlComment.toEmpty();
sqlFirst.toEmpty();
}
/**
* 对sql片段进行组装
*
* @param condition 是否执行
* @param sqlSegments sql片段数组
* @return children
*/
protected Children doIt(boolean condition, ISqlSegment... sqlSegments) {
if (condition) {
expression.add(sqlSegments);
}
return typedThis;
}
@Override
public String getSqlSegment() {
return expression.getSqlSegment() + lastSql.getStringValue();
}
@Override
public String getSqlComment() {
if (StringUtils.isNotBlank(sqlComment.getStringValue())) {
return "/*" + StringEscape.escapeRawString(sqlComment.getStringValue()) + "*/";
}
return null;
}
@Override
public String getSqlFirst() {
if (StringUtils.isNotBlank(sqlFirst.getStringValue())) {
return StringEscape.escapeRawString(sqlFirst.getStringValue());
}
return null;
}
@Override
public MergeSegments getExpression() {
return expression;
}
public Map<String, Object> getParamNameValuePairs() {
return paramNameValuePairs;
}
/**
* 获取 columnName
*/
protected String columnToString(R column) {
return (String) column;
}
/**
* 多字段转换为逗号 "," 分割字符串
*
* @param columns 多字段
*/
protected String columnsToString(R... columns) {
return Arrays.stream(columns).map(this::columnToString).collect(joining(StringPool.COMMA));
}
@Override
@SuppressWarnings("all")
public Children clone() {
return SerializationUtils.clone(typedThis);
}
}

188
src/main/java/com/github/mybatisplus/query/MyLambdaQuery.java Normal file
View File

@ -0,0 +1,188 @@
package com.github.mybatisplus.query;
import com.baomidou.mybatisplus.core.conditions.SharedString;
import com.baomidou.mybatisplus.core.conditions.query.Query;
import com.baomidou.mybatisplus.core.conditions.segments.MergeSegments;
import com.baomidou.mybatisplus.core.metadata.TableFieldInfo;
import com.baomidou.mybatisplus.core.metadata.TableInfo;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.baomidou.mybatisplus.core.toolkit.ArrayUtils;
import com.baomidou.mybatisplus.core.toolkit.Assert;
import com.baomidou.mybatisplus.core.toolkit.StringPool;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.core.toolkit.support.SFunction;
import com.github.mybatisplus.toolkit.Constant;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Predicate;
import java.util.stream.Collectors;
/**
* copy {@link com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper}
* <p>
* sqlSelect 由覆盖改为追加
*/
@SuppressWarnings("serial")
public class MyLambdaQuery<T> extends MyAbstractLambda<T, MyLambdaQuery<T>>
implements Query<MyLambdaQuery<T>, T, SFunction<T, ?>> {
/**
* 查询字段
*/
private SharedString sqlSelect = new SharedString();
/**
* 不建议直接 new 该实例，使用 Wrappers.lambdaQuery(entity)
*/
public MyLambdaQuery() {
this((T) null);
}
/**
* 不建议直接 new 该实例，使用 Wrappers.lambdaQuery(entity)
*/
public MyLambdaQuery(T entity) {
super.setEntity(entity);
super.initNeed();
}
/**
* 不建议直接 new 该实例，使用 Wrappers.lambdaQuery(entity)
*/
public MyLambdaQuery(Class<T> entityClass) {
super.setEntityClass(entityClass);
super.initNeed();
}
/**
* 不建议直接 new 该实例，使用 Wrappers.lambdaQuery(...)
*/
MyLambdaQuery(T entity, Class<T> entityClass, SharedString from, SharedString sqlSelect, AtomicInteger paramNameSeq,
Map<String, Object> paramNameValuePairs, MergeSegments mergeSegments,
SharedString lastSql, SharedString sqlComment, SharedString sqlFirst) {
super.setEntity(entity);
super.setEntityClass(entityClass);
this.paramNameSeq = paramNameSeq;
this.paramNameValuePairs = paramNameValuePairs;
this.expression = mergeSegments;
this.sqlSelect = sqlSelect;
this.from = from;
this.lastSql = lastSql;
this.sqlComment = sqlComment;
this.sqlFirst = sqlFirst;
}
/**
* SELECT 部分 SQL 设置
*
* @param columns 查询字段
*/
@SafeVarargs
@Override
public final MyLambdaQuery<T> select(SFunction<T, ?>... columns) {
if (ArrayUtils.isNotEmpty(columns)) {
String s = columnsToString(false, columns);
if (StringUtils.isBlank(sqlSelect.getStringValue())) {
this.sqlSelect.setStringValue(s);
} else {
this.sqlSelect.setStringValue(this.getSqlSelect() + StringPool.COMMA + s);
}
}
return typedThis;
}
@SafeVarargs
public final MyLambdaQuery<T> select(String... columns) {
if (ArrayUtils.isNotEmpty(columns)) {
String s = String.join(StringPool.COMMA, columns);
if (StringUtils.isBlank(sqlSelect.getStringValue())) {
this.sqlSelect.setStringValue(s);
} else {
this.sqlSelect.setStringValue(this.getSqlSelect() + StringPool.COMMA + s);
}
}
return typedThis;
}
/**
* 过滤查询的字段信息(主键除外!)
* <p>例1: 只要 java 字段名以 "test" 开头的 -> select(i -&gt; i.getProperty().startsWith("test"))</p>
* <p>例2: 只要 java 字段属性是 CharSequence 类型的 -> select(TableFieldInfo::isCharSequence)</p>
* <p>例3: 只要 java 字段没有填充策略的 -> select(i -&gt; i.getFieldFill() == FieldFill.DEFAULT)</p>
* <p>例4: 要全部字段 -> select(i -&gt; true)</p>
* <p>例5: 只要主键字段 -> select(i -&gt; false)</p>
*
* @param predicate 过滤方式
* @return this
*/
@Override
public MyLambdaQuery<T> select(Class<T> entityClass, Predicate<TableFieldInfo> predicate) {
if (entityClass == null) {
entityClass = getEntityClass();
} else {
setEntityClass(entityClass);
}
Assert.notNull(entityClass, "entityClass can not be null");
String s = TableInfoHelper.getTableInfo(entityClass).chooseSelect(predicate);
List<String> list = Arrays.stream(s.split(StringPool.COMMA)).map(i -> Constant.TABLE_ALIAS + StringPool.DOT + i).collect(Collectors.toList());
String join = String.join(StringPool.COMMA, list);
if (StringUtils.isBlank(sqlSelect.getStringValue())) {
this.sqlSelect.setStringValue(join);
} else {
this.sqlSelect.setStringValue(this.getSqlSelect() + StringPool.COMMA + join);
}
return typedThis;
}
public final MyLambdaQuery<T> selectAll(Class<T> clazz) {
TableInfo info = TableInfoHelper.getTableInfo(clazz);
List<String> list = new ArrayList<>();
list.add(Constant.TABLE_ALIAS + StringPool.DOT + info.getKeyColumn());
list.addAll(info.getFieldList().stream().map(i -> Constant.TABLE_ALIAS + StringPool.DOT + i.getColumn()).collect(Collectors.toList()));
String join = String.join(StringPool.COMMA, list);
if (StringUtils.isBlank(sqlSelect.getStringValue())) {
this.sqlSelect.setStringValue(join);
} else {
this.sqlSelect.setStringValue(this.getSqlSelect() + StringPool.COMMA + join);
}
return typedThis;
}
/**
* 返回一个支持 lambda 函数写法的 wrapper
*/
public MyQueryWrapper<T> stringQuery() {
return new MyQueryWrapper<>(getEntity(), getEntityClass(), paramNameSeq, paramNameValuePairs,
expression, sqlSelect, from, lastSql, sqlComment, sqlFirst);
}
@Override
public String getSqlSelect() {
return sqlSelect.getStringValue();
}
public String getFrom() {
return from.getStringValue();
}
/**
* 用于生成嵌套 sql
* <p>故 sqlSelect from不向下传递</p>
*/
@Override
protected MyLambdaQuery<T> instance() {
return new MyLambdaQuery<>(getEntity(), getEntityClass(), null, null, paramNameSeq, paramNameValuePairs,
new MergeSegments(), SharedString.emptyString(), SharedString.emptyString(), SharedString.emptyString());
}
@Override
public void clear() {
super.clear();
sqlSelect.toNull();
}
}

112
src/main/java/com/github/mybatisplus/query/MyQueryWrapper.java Normal file
View File

@ -0,0 +1,112 @@
package com.github.mybatisplus.query;
import com.baomidou.mybatisplus.core.conditions.SharedString;
import com.baomidou.mybatisplus.core.conditions.query.Query;
import com.baomidou.mybatisplus.core.conditions.segments.MergeSegments;
import com.baomidou.mybatisplus.core.metadata.TableFieldInfo;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.baomidou.mybatisplus.core.toolkit.ArrayUtils;
import com.baomidou.mybatisplus.core.toolkit.StringPool;
import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Predicate;
/**
* copy {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
*/
@SuppressWarnings("serial")
public class MyQueryWrapper<T> extends MyAbstractWrapper<T, String, MyQueryWrapper<T>>
implements Query<MyQueryWrapper<T>, T, String> {
/**
* 查询字段
*/
private SharedString sqlSelect = new SharedString();
public MyQueryWrapper() {
this(null);
}
public MyQueryWrapper(T entity) {
super.setEntity(entity);
super.initNeed();
}
public MyQueryWrapper(T entity, String... columns) {
super.setEntity(entity);
super.initNeed();
this.select(columns);
}
/**
* 非对外公开的构造方法,只用于生产嵌套 sql
*
* @param entityClass 本不应该需要的
*/
public MyQueryWrapper(T entity, Class<T> entityClass, AtomicInteger paramNameSeq,
Map<String, Object> paramNameValuePairs, MergeSegments mergeSegments,
SharedString sqlSelect, SharedString from, SharedString lastSql, SharedString sqlComment, SharedString sqlFirst) {
super.setEntity(entity);
super.setEntityClass(entityClass);
this.paramNameSeq = paramNameSeq;
this.paramNameValuePairs = paramNameValuePairs;
this.expression = mergeSegments;
this.sqlSelect = sqlSelect;
this.lastSql = lastSql;
this.from = from;
this.sqlComment = sqlComment;
this.sqlFirst = sqlFirst;
}
@Override
public MyQueryWrapper<T> select(String... columns) {
if (ArrayUtils.isNotEmpty(columns)) {
this.sqlSelect.setStringValue(String.join(StringPool.COMMA, columns));
}
return typedThis;
}
@Override
public MyQueryWrapper<T> select(Class<T> entityClass, Predicate<TableFieldInfo> predicate) {
super.setEntityClass(entityClass);
this.sqlSelect.setStringValue(TableInfoHelper.getTableInfo(getEntityClass()).chooseSelect(predicate));
return typedThis;
}
@Override
public String getSqlSelect() {
return sqlSelect.getStringValue();
}
public String getFrom() {
return from.getStringValue();
}
/**
* 返回一个支持 lambda 函数写法的 wrapper
*/
public MyLambdaQuery<T> lambda() {
return new MyLambdaQuery<>(getEntity(), getEntityClass(), null, null, paramNameSeq, paramNameValuePairs,
expression, lastSql, sqlComment, sqlFirst);
}
/**
* 用于生成嵌套 sql
* <p>
* 故 sqlSelect from 不向下传递
* </p>
*/
@Override
protected MyQueryWrapper<T> instance() {
return new MyQueryWrapper<>(getEntity(), getEntityClass(), paramNameSeq, paramNameValuePairs, new MergeSegments(),
null, null, SharedString.emptyString(), SharedString.emptyString(), SharedString.emptyString());
}
@Override
public void clear() {
super.clear();
sqlSelect.toNull();
}
}

22
src/main/java/com/github/mybatisplus/query/interfaces/MyJoin.java Normal file
View File

@ -0,0 +1,22 @@
package com.github.mybatisplus.query.interfaces;
public interface MyJoin<Children> {
default Children leftJoin(String joinSql) {
return leftJoin(true, joinSql);
}
Children leftJoin(boolean condition, String joinSql);
default Children rightJoin(String joinSql) {
return rightJoin(true, joinSql);
}
Children rightJoin(boolean condition, String joinSql);
default Children innerJoin(String joinSql) {
return innerJoin(true, joinSql);
}
Children innerJoin(boolean condition, String joinSql);
}

10
src/main/java/com/github/mybatisplus/wrapper/MyAbstractLambdaWrapper.java
View File

@ -22,16 +22,6 @@ public abstract class MyAbstractLambdaWrapper<T, Children extends MyAbstractLamb
private Map<String, ColumnCache> columnMap = null; private Map<String, ColumnCache> columnMap = null;
@SuppressWarnings("unchecked")
@Override
protected String columnsToString(SFunction<T, ?>... columns) {
return columnsToString(true, columns);
}
@SuppressWarnings("unchecked")
protected String columnsToString(boolean onlyColumn, SFunction<T, ?>... columns) {
return Arrays.stream(columns).map(i -> columnToString(i, onlyColumn)).collect(joining(StringPool.COMMA));
}
@Override @Override
protected String columnToString(SFunction<T, ?> column) { protected String columnToString(SFunction<T, ?> column) {

12
src/main/java/com/github/mybatisplus/wrapper/MyAbstractWrapper.java
View File

@ -171,9 +171,6 @@ public abstract class MyAbstractWrapper<T, R, Children extends MyAbstractWrapper
return expression; return expression;
} }
public Map<String, Object> getParamNameValuePairs() {
return paramNameValuePairs;
}
/** /**
* 获取 columnName * 获取 columnName
@ -182,15 +179,6 @@ public abstract class MyAbstractWrapper<T, R, Children extends MyAbstractWrapper
return (String) column; return (String) column;
} }
/**
* 多字段转换为逗号 "," 分割字符串
*
* @param columns 多字段
*/
protected String columnsToString(R... columns) {
return Arrays.stream(columns).map(this::columnToString).collect(joining(StringPool.COMMA));
}
@Override @Override
@SuppressWarnings("all") @SuppressWarnings("all")
public Children clone() { public Children clone() {

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

@ -10,10 +10,9 @@ import com.baomidou.mybatisplus.core.toolkit.ArrayUtils;
import com.baomidou.mybatisplus.core.toolkit.Assert; 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.toolkit.Constant; import com.github.mybatisplus.func.MySFunction;
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;
import com.github.mybatisplus.func.MySFunction;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.List; import java.util.List;
@ -30,6 +29,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
*/ */
@SuppressWarnings("all")
public class MyJoinLambdaQueryWrapper<T> 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> {
@ -52,22 +52,23 @@ public class MyJoinLambdaQueryWrapper<T> extends MyAbstractLambdaWrapper<T, MyJo
protected int rUid = 1; protected int rUid = 1;
public MyJoinLambdaQueryWrapper() { public MyJoinLambdaQueryWrapper() {
super.setEntity(null); setEntity(null);
super.initNeed(); super.initNeed();
} }
public MyJoinLambdaQueryWrapper(int rUid) { public MyJoinLambdaQueryWrapper(int rUid) {
this.rUid = rUid; this.rUid = rUid;
super.setEntity(null); setEntity(null);
super.initNeed(); super.initNeed();
} }
public MyJoinLambdaQueryWrapper(T entity, Class<T> entityClass, SharedString sqlSelect, AtomicInteger paramNameSeq, public MyJoinLambdaQueryWrapper(T entity, Class<T> entityClass, SharedString sqlSelect, AtomicInteger paramNameSeq,
Map<String, Object> paramNameValuePairs, MergeSegments mergeSegments, Map<String, Object> paramNameValuePairs, MergeSegments mergeSegments,
SharedString lastSql, SharedString sqlComment) { SharedString lastSql, SharedString sqlComment) {
super.setEntity(entity); setEntity(entity);
this.setEntityClass(entityClass); setEntityClass(entityClass);
this.paramNameSeq = paramNameSeq; this.paramNameSeq = paramNameSeq;
this.paramNameValuePairs = paramNameValuePairs; this.paramNameValuePairs = paramNameValuePairs;
this.expression = mergeSegments; this.expression = mergeSegments;
@ -92,8 +93,9 @@ public class MyJoinLambdaQueryWrapper<T> extends MyAbstractLambdaWrapper<T, MyJo
this.rUid = 1; this.rUid = 1;
} }
@SafeVarargs
@Override @Override
public MyJoinLambdaQueryWrapper<T> select(SFunction<T, ?>... columns) { public final MyJoinLambdaQueryWrapper<T> select(SFunction<T, ?>... columns) {
if (ArrayUtils.isNotEmpty(columns)) { if (ArrayUtils.isNotEmpty(columns)) {
for (SFunction<T, ?> str : columns) { for (SFunction<T, ?> str : columns) {
selectColumnList.add(new SelectColumn(rUid, columnToString(str), null, null)); selectColumnList.add(new SelectColumn(rUid, columnToString(str), null, null));
@ -157,7 +159,7 @@ public class MyJoinLambdaQueryWrapper<T> extends MyAbstractLambdaWrapper<T, MyJo
@Override @Override
public MyJoinLambdaQueryWrapper<T> select(Class<T> entityClass, Predicate<TableFieldInfo> predicate) { public MyJoinLambdaQueryWrapper<T> select(Class<T> entityClass, Predicate<TableFieldInfo> predicate) {
this.setEntityClass(entityClass); setEntityClass(entityClass);
TableInfo info = TableInfoHelper.getTableInfo(getEntityClass()); TableInfo info = TableInfoHelper.getTableInfo(getEntityClass());
Assert.notNull(info, "can not find table to entity %s", entityClass); 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 ->
@ -165,71 +167,13 @@ public class MyJoinLambdaQueryWrapper<T> extends MyAbstractLambdaWrapper<T, MyJo
return typedThis; return typedThis;
} }
public <DTO> MyJoinLambdaQueryWrapper<T> as(SFunction<T, ?> entityColumn, SFunction<DTO, ?> DTOColumn) {
selectColumnList.add(new SelectColumn(rUid, columnToString(entityColumn), MyLambdaUtils.getName(DTOColumn), null));
return this;
}
public <DTO> MyJoinLambdaQueryWrapper<T> asCount(MySFunction<T, ?> entityColumn, SFunction<DTO, ?> DTOColumn) {
selectColumnList.add(new SelectColumn(rUid, columnToString(entityColumn), MyLambdaUtils.getName(DTOColumn), SelectFunc.COUNT));
return this;
}
public <DTO> MyJoinLambdaQueryWrapper<T> asSum(MySFunction<T, ?> entityColumn, SFunction<DTO, ?> DTOColumn) {
selectColumnList.add(new SelectColumn(rUid, columnToString(entityColumn), MyLambdaUtils.getName(DTOColumn), SelectFunc.SUM));
return this;
}
public <DTO> MyJoinLambdaQueryWrapper<T> asAvg(MySFunction<T, ?> entityColumn, SFunction<DTO, ?> DTOColumn) {
selectColumnList.add(new SelectColumn(rUid, columnToString(entityColumn), MyLambdaUtils.getName(DTOColumn), SelectFunc.AVG));
return this;
}
public <DTO> MyJoinLambdaQueryWrapper<T> asMax(MySFunction<T, ?> entityColumn, SFunction<DTO, ?> DTOColumn) {
selectColumnList.add(new SelectColumn(rUid, columnToString(entityColumn), MyLambdaUtils.getName(DTOColumn), SelectFunc.MAX));
return this;
}
public <DTO> MyJoinLambdaQueryWrapper<T> asMin(MySFunction<T, ?> entityColumn, SFunction<DTO, ?> DTOColumn) {
selectColumnList.add(new SelectColumn(rUid, columnToString(entityColumn), MyLambdaUtils.getName(DTOColumn), SelectFunc.MIN));
return this;
}
public <DTO> MyJoinLambdaQueryWrapper<T> asDateFormat(MySFunction<T, ?> entityColumn, SFunction<DTO, ?> DTOColumn) {
selectColumnList.add(new SelectColumn(rUid, columnToString(entityColumn), MyLambdaUtils.getName(DTOColumn), SelectFunc.DATE_FORMAT));
return this;
}
/**
* 左连接查询
*
* @param leftCondition 主表参与比较的字段 (on)
* @param rightCondition 子表参与比较的字段 (on)
* @param rightWrapper 子表的wrapper
*/
@Override @Override
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) { public <R, TE, RE> MyJoinLambdaQueryWrapper<T> join(boolean condition,
return join(condition, alias, Constant.LEFT_JOIN, leftCondition, rightCondition, rightWrapper); String alias,
} String keyWord,
MySFunction<T, TE> leftCondition,
/** MySFunction<R, RE> rightCondition,
* 右连接查询(参考左连接) Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
*/
@Override
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);
}
/**
* 内连接查询(参考左连接)
*/
@Override
public <R, TE, RE> MyJoinLambdaQueryWrapper<T> innerJoin(boolean condition, String alias, MySFunction<T, TE> leftCondition, MySFunction<R, RE> rightCondition, Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
return join(condition, alias, Constant.INNER_JOIN, leftCondition, rightCondition, rightWrapper);
}
private <R, 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;
@ -237,7 +181,7 @@ public class MyJoinLambdaQueryWrapper<T> extends MyAbstractLambdaWrapper<T, MyJo
TableInfo info = TableInfoHelper.getTableInfo(clazz); TableInfo info = TableInfoHelper.getTableInfo(clazz);
Assert.notNull(info, "can not find table to entity %s", 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())); 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 = (MyJoinLambdaQueryWrapper<R>) rightWrapper.apply(new MyJoinLambdaQueryWrapper<>(childrenId));
classList.addAll(apply.classList); classList.addAll(apply.classList);
this.selectColumnList.addAll(apply.selectColumnList); this.selectColumnList.addAll(apply.selectColumnList);
} }

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

@ -2,6 +2,7 @@ package com.github.mybatisplus.wrapper;
import com.baomidou.mybatisplus.core.conditions.ISqlSegment; import com.baomidou.mybatisplus.core.conditions.ISqlSegment;
import com.baomidou.mybatisplus.core.conditions.SharedString; import com.baomidou.mybatisplus.core.conditions.SharedString;
import com.baomidou.mybatisplus.core.conditions.query.Query;
import com.baomidou.mybatisplus.core.conditions.segments.MergeSegments; import com.baomidou.mybatisplus.core.conditions.segments.MergeSegments;
import com.baomidou.mybatisplus.core.enums.SqlKeyword; import com.baomidou.mybatisplus.core.enums.SqlKeyword;
import com.baomidou.mybatisplus.core.enums.SqlLike; import com.baomidou.mybatisplus.core.enums.SqlLike;
@ -12,12 +13,10 @@ import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.baomidou.mybatisplus.core.toolkit.*; import com.baomidou.mybatisplus.core.toolkit.*;
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.MyFunc;
import com.github.mybatisplus.wrapper.interfaces.MyNested;
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;
import com.github.mybatisplus.wrapper.interfaces.*;
import java.util.*; import java.util.*;
import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.atomic.AtomicInteger;
@ -31,6 +30,8 @@ import static java.util.stream.Collectors.joining;
/** /**
* 连接查询Query * 连接查询Query
* 只允许主表有条件查询,内部的表只允许select和继续连表的功能,
* 所以将条件查询接口在此实现 结构臃肿,有待进一步优化
* *
* @author yulichang * @author yulichang
* @see com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper * @see com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper
@ -40,125 +41,85 @@ 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 MyJoinLambdaQueryWrapper<T> @SuppressWarnings("all")
implements MyCompare<MyLambdaQueryWrapper<T>>, MyNested<MyLambdaQueryWrapper<T>, MyLambdaQueryWrapper<T>>, public class MyLambdaQueryWrapper<T> extends MyAbstractLambdaWrapper<T, MyLambdaQueryWrapper<T>>
MyFunc<MyLambdaQueryWrapper<T>> { implements
Query<MyLambdaQueryWrapper<T>, T, SFunction<T, ?>>,
MyJoin<MyLambdaQueryWrapper<T>, T>,
MyCompare<MyLambdaQueryWrapper<T>>,
MyNested<MyLambdaQueryWrapper<T>, MyLambdaQueryWrapper<T>>,
MyFunc<MyLambdaQueryWrapper<T>>,
MyMPJoin<MyLambdaQueryWrapper<T>> {
private MyJoinLambdaQueryWrapper<T> wrapper = new MyJoinLambdaQueryWrapper<>();
/** /**
* 表别名初始序号 * 表别名初始序号
*/ */
public static final int TABLE_ALIAS_INDEX = 0; public static final int TABLE_ALIAS_INDEX = 0;
/**
* 主表默认别名
*/
public static final String DEFAULT_ALIAS = "t";
public MyLambdaQueryWrapper() { public MyLambdaQueryWrapper() {
this(null); this(null);
} }
public MyLambdaQueryWrapper(T entity) { public MyLambdaQueryWrapper(T entity) {
super.rUid = TABLE_ALIAS_INDEX; wrapper.rUid = TABLE_ALIAS_INDEX;
super.setEntity(entity); wrapper.setEntity(entity);
super.initNeed(); super.initNeed();
} }
MyLambdaQueryWrapper(T entity, Class<T> entityClass, SharedString sqlSelect, AtomicInteger paramNameSeq, MyLambdaQueryWrapper(T entity, Class<T> entityClass, SharedString sqlSelect, AtomicInteger paramNameSeq,
Map<String, Object> paramNameValuePairs, MergeSegments mergeSegments, Map<String, Object> paramNameValuePairs, MergeSegments mergeSegments,
SharedString lastSql, SharedString sqlComment, SharedString sqlFirst, SharedString lastSql, SharedString sqlComment, SharedString sqlFirst,
int rUid, List<SelectColumn> selectColumns, List<SubTable> classList) { int rUid, List<MyJoinLambdaQueryWrapper.SelectColumn> selectColumns, List<MyJoinLambdaQueryWrapper.SubTable> classList) {
super.setEntity(entity); super.setEntity(entity);
super.setEntityClass(entityClass); super.setEntityClass(entityClass);
this.paramNameSeq = paramNameSeq; this.paramNameSeq = paramNameSeq;
this.paramNameValuePairs = paramNameValuePairs; this.paramNameValuePairs = paramNameValuePairs;
this.expression = mergeSegments; this.expression = mergeSegments;
this.sqlSelect = sqlSelect; this.wrapper.sqlSelect = sqlSelect;
this.lastSql = lastSql; this.lastSql = lastSql;
this.sqlComment = sqlComment; this.sqlComment = sqlComment;
this.sqlFirst = sqlFirst; this.sqlFirst = sqlFirst;
this.rUid = rUid;
this.selectColumnList = selectColumns; wrapper.rUid = rUid;
this.classList = classList; wrapper.selectColumnList = selectColumns;
wrapper.classList = classList;
} }
@Override @Override
protected MyLambdaQueryWrapper<T> instance() { protected MyLambdaQueryWrapper<T> instance() {
return new MyLambdaQueryWrapper<>(getEntity(), getEntityClass(), null, paramNameSeq, paramNameValuePairs, return new MyLambdaQueryWrapper<>(getEntity(), getEntityClass(), null, paramNameSeq, paramNameValuePairs,
new MergeSegments(), SharedString.emptyString(), SharedString.emptyString(), SharedString.emptyString(), new MergeSegments(), SharedString.emptyString(), SharedString.emptyString(), SharedString.emptyString(),
rUid, selectColumnList, classList); wrapper.rUid, wrapper.selectColumnList, wrapper.classList);
} }
@Override @Override
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) { public <R, TE, RE> MyLambdaQueryWrapper<T> join(boolean condition,
return join(condition, alias, Constant.LEFT_JOIN, leftCondition, rightCondition, rightWrapper); String alias,
} String keyWord,
MySFunction<T, TE> leftCondition,
@Override MySFunction<R, RE> rightCondition,
public <R, TE, RE> MyLambdaQueryWrapper<T> leftJoin(MySFunction<T, TE> leftCondition, MySFunction<R, RE> rightCondition, Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) { Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
return this.leftJoin(true, null, leftCondition, rightCondition, rightWrapper);
}
@Override
public <R, TE, RE> MyLambdaQueryWrapper<T> leftJoin(String alias, MySFunction<T, TE> leftCondition, MySFunction<R, RE> rightCondition, Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
return this.leftJoin(true, alias, leftCondition, rightCondition, rightWrapper);
}
@Override
public <R, TE, RE> MyLambdaQueryWrapper<T> leftJoin(boolean condition, MySFunction<T, TE> leftCondition, MySFunction<R, RE> rightCondition, Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
return this.leftJoin(condition, null, leftCondition, rightCondition, rightWrapper);
}
public <R, TE, RE> MyLambdaQueryWrapper<T> rightJoin(boolean condition, String alias, MySFunction<T, TE> leftCondition, MySFunction<R, RE> rightCondition, Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
return join(condition, alias, Constant.RIGHT_JOIN, leftCondition, rightCondition, rightWrapper);
}
@Override
public <R, TE, RE> MyLambdaQueryWrapper<T> rightJoin(MySFunction<T, TE> leftCondition, MySFunction<R, RE> rightCondition, Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
return this.rightJoin(true, null, leftCondition, rightCondition, rightWrapper);
}
@Override
public <R, TE, RE> MyLambdaQueryWrapper<T> rightJoin(String alias, MySFunction<T, TE> leftCondition, MySFunction<R, RE> rightCondition, Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
return this.rightJoin(true, alias, leftCondition, rightCondition, rightWrapper);
}
@Override
public <R, TE, RE> MyLambdaQueryWrapper<T> rightJoin(boolean condition, MySFunction<T, TE> leftCondition, MySFunction<R, RE> rightCondition, Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
return this.rightJoin(condition, null, leftCondition, rightCondition, rightWrapper);
}
public <R, TE, RE> MyLambdaQueryWrapper<T> innerJoin(boolean condition, String alias, MySFunction<T, TE> leftCondition, MySFunction<R, RE> rightCondition, Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
return join(condition, alias, Constant.INNER_JOIN, leftCondition, rightCondition, rightWrapper);
}
@Override
public <R, TE, RE> MyLambdaQueryWrapper<T> innerJoin(MySFunction<T, TE> leftCondition, MySFunction<R, RE> rightCondition, Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
return this.innerJoin(true, null, leftCondition, rightCondition, rightWrapper);
}
@Override
public <R, TE, RE> MyLambdaQueryWrapper<T> innerJoin(String alias, MySFunction<T, TE> leftCondition, MySFunction<R, RE> rightCondition, Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
return this.innerJoin(true, alias, leftCondition, rightCondition, rightWrapper);
}
@Override
public <R, TE, RE> MyLambdaQueryWrapper<T> innerJoin(boolean condition, MySFunction<T, TE> leftCondition, MySFunction<R, RE> rightCondition, Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper) {
return this.innerJoin(condition, null, leftCondition, rightCondition, rightWrapper);
}
private <R, 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));
Class<R> clazz = MyLambdaUtils.getEntityClass(rightCondition); Class<R> clazz = MyLambdaUtils.getEntityClass(rightCondition);
TableInfo info = TableInfoHelper.getTableInfo(clazz); TableInfo info = TableInfoHelper.getTableInfo(clazz);
Assert.notNull(info, "can not find table to entity %s", 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())); wrapper.classList.add(new MyJoinLambdaQueryWrapper.SubTable(alias,
MyJoinLambdaQueryWrapper<R> apply = rightWrapper.apply(new MyJoinLambdaQueryWrapper<>(classList.size())); keyWord,
classList.addAll(apply.classList); wrapper.rUid,
this.selectColumnList.addAll(apply.selectColumnList); MyLambdaUtils.getColumn(leftCondition),
wrapper.classList.size() + 1,
MyLambdaUtils.getColumn(rightCondition),
info.getTableName()));
MyJoinLambdaQueryWrapper<R> apply = rightWrapper.apply(new MyJoinLambdaQueryWrapper<>(wrapper.classList.size()));
wrapper.classList.addAll(apply.classList);
wrapper.selectColumnList.addAll(apply.selectColumnList);
} }
return this; return this;
} }
@ -166,77 +127,39 @@ public class MyLambdaQueryWrapper<T> extends MyJoinLambdaQueryWrapper<T>
@SafeVarargs @SafeVarargs
@Override @Override
public final MyLambdaQueryWrapper<T> select(SFunction<T, ?>... columns) { public final MyLambdaQueryWrapper<T> select(SFunction<T, ?>... columns) {
super.select(columns); wrapper.select(columns);
return this;
}
@Override
public MyLambdaQueryWrapper<T> selectAll(Class<T> clazz) {
super.selectAll(clazz);
return this;
}
@Override
public MyLambdaQueryWrapper<T> selectDistinct() {
super.selectDistinct();
return this; return this;
} }
@Override @Override
public MyLambdaQueryWrapper<T> select(Predicate<TableFieldInfo> predicate) { public MyLambdaQueryWrapper<T> select(Predicate<TableFieldInfo> predicate) {
super.select(predicate); wrapper.select(predicate);
return this; return this;
} }
@Override @Override
public MyLambdaQueryWrapper<T> select(Class<T> entityClass, Predicate<TableFieldInfo> predicate) { public MyLambdaQueryWrapper<T> select(Class<T> entityClass, Predicate<TableFieldInfo> predicate) {
super.select(entityClass, predicate); wrapper.select(entityClass, predicate);
return this; return this;
} }
@Override
public <DTO> MyLambdaQueryWrapper<T> as(SFunction<T, ?> entityColumn, SFunction<DTO, ?> DTOColumn) { public MyLambdaQueryWrapper<T> selectAll(Class<T> clazz) {
super.as(entityColumn, DTOColumn); wrapper.selectAll(clazz);
return this; return this;
} }
public <DTO> MyLambdaQueryWrapper<T> asCount(MySFunction<T, ?> entityColumn, SFunction<DTO, ?> DTOColumn) { public MyLambdaQueryWrapper<T> selectDistinct() {
super.asCount(entityColumn, DTOColumn); wrapper.selectDistinct();
return this; return this;
} }
public <DTO> MyLambdaQueryWrapper<T> asSum(MySFunction<T, ?> entityColumn, SFunction<DTO, ?> DTOColumn) {
super.asSum(entityColumn, DTOColumn);
return this;
}
public <DTO> MyLambdaQueryWrapper<T> asAvg(MySFunction<T, ?> entityColumn, SFunction<DTO, ?> DTOColumn) {
super.asAvg(entityColumn, DTOColumn);
return this;
}
public <DTO> MyLambdaQueryWrapper<T> asMax(MySFunction<T, ?> entityColumn, SFunction<DTO, ?> DTOColumn) {
super.asMax(entityColumn, DTOColumn);
return this;
}
public <DTO> MyLambdaQueryWrapper<T> asMin(MySFunction<T, ?> entityColumn, SFunction<DTO, ?> DTOColumn) {
super.asMin(entityColumn, DTOColumn);
return this;
}
public <DTO> MyLambdaQueryWrapper<T> asDateFormat(MySFunction<T, ?> entityColumn, SFunction<DTO, ?> DTOColumn) {
super.asDateFormat(entityColumn, DTOColumn);
return this;
}
@Override @Override
public String getSqlSelect() { public String getSqlSelect() {
if (StringUtils.isBlank(sqlSelect.getStringValue()) && CollectionUtils.isNotEmpty(selectColumnList)) { if (StringUtils.isBlank(wrapper.sqlSelect.getStringValue()) && CollectionUtils.isNotEmpty(wrapper.selectColumnList)) {
List<String> collect = new ArrayList<>(); List<String> collect = new ArrayList<>();
selectColumnList.forEach(c -> { wrapper.selectColumnList.forEach(c -> {
String s = Constant.TABLE_ALIAS + c.getUid() + StringPool.DOT + c.getColumn(); String s = Constant.TABLE_ALIAS + (c.getUid() == TABLE_ALIAS_INDEX ? "" : c.getUid()) + StringPool.DOT + c.getColumn();
if (c.getFunction() != null) { if (c.getFunction() != null) {
s = String.format(c.getFunction().getSql(), s); s = String.format(c.getFunction().getSql(), s);
} }
@ -246,9 +169,9 @@ public class MyLambdaQueryWrapper<T> extends MyJoinLambdaQueryWrapper<T>
collect.add(s + Constant.AS + c.getAs()); collect.add(s + Constant.AS + c.getAs());
} }
}); });
this.sqlSelect.setStringValue(String.join(StringPool.COMMA, collect)); wrapper.sqlSelect.setStringValue(String.join(StringPool.COMMA, collect));
} }
return sqlSelect.getStringValue(); return wrapper.sqlSelect.getStringValue();
} }
@Override @Override
@ -257,29 +180,29 @@ public class MyLambdaQueryWrapper<T> extends MyJoinLambdaQueryWrapper<T>
} }
public String getFrom() { public String getFrom() {
if (StringUtils.isNotBlank(from.getStringValue())) { if (StringUtils.isNotBlank(wrapper.from.getStringValue())) {
return from.getStringValue(); return wrapper.from.getStringValue();
} }
StringBuilder sb = new StringBuilder(); StringBuilder sb = new StringBuilder();
this.classList.forEach(right -> wrapper.classList.forEach(right ->
sb.append(right.getKeyWord()).append(right.getRightTableName()) sb.append(right.getKeyWord()).append(right.getRightTableName())
.append(StringPool.SPACE) .append(StringPool.SPACE)
.append(Constant.TABLE_ALIAS) .append(Constant.TABLE_ALIAS)
.append(right.getRightUid()) .append(right.getRightUid() == TABLE_ALIAS_INDEX ? StringPool.EMPTY : right.getRightUid())
.append(Constant.ON) .append(Constant.ON)
.append(Constant.TABLE_ALIAS) .append(Constant.TABLE_ALIAS)
.append(right.getLeftUid()) .append(right.getLeftUid() == TABLE_ALIAS_INDEX ? StringPool.EMPTY : right.getLeftUid())
.append(StringPool.DOT) .append(StringPool.DOT)
.append(right.getLeftColumn()) .append(right.getLeftColumn())
.append(Constant.EQUALS) .append(Constant.EQUALS)
.append(Constant.TABLE_ALIAS) .append(Constant.TABLE_ALIAS)
.append(right.getRightUid()) .append(right.getRightUid() == TABLE_ALIAS_INDEX ? StringPool.EMPTY : right.getRightUid())
.append(StringPool.DOT) .append(StringPool.DOT)
.append(right.getRightColumn()) .append(right.getRightColumn())
.append(StringPool.SPACE) .append(StringPool.SPACE)
); );
this.from.setStringValue(sb.toString()); wrapper.from.setStringValue(sb.toString());
return this.from.getStringValue(); return wrapper.from.getStringValue();
} }
/** /**
@ -287,12 +210,12 @@ public class MyLambdaQueryWrapper<T> extends MyJoinLambdaQueryWrapper<T>
*/ */
private String getClassTablePrefix(Class<?> clazz) { private String getClassTablePrefix(Class<?> clazz) {
if (getEntityClass() == clazz) { if (getEntityClass() == clazz) {
return Constant.TABLE_ALIAS + rUid; return Constant.TABLE_ALIAS;
} else { } else {
TableInfo info = TableInfoHelper.getTableInfo(clazz); TableInfo info = TableInfoHelper.getTableInfo(clazz);
Assert.notNull(info, "can not find table to entity %s", clazz); Assert.notNull(info, "can not find table to entity %s", clazz);
String tableName = info.getTableName(); String tableName = info.getTableName();
for (SubTable sub : classList) { for (MyJoinLambdaQueryWrapper.SubTable sub : wrapper.classList) {
if (sub.getRightTableName().equals(tableName)) { if (sub.getRightTableName().equals(tableName)) {
return Constant.TABLE_ALIAS + sub.getRightUid(); return Constant.TABLE_ALIAS + sub.getRightUid();
} }
@ -306,10 +229,10 @@ public class MyLambdaQueryWrapper<T> extends MyJoinLambdaQueryWrapper<T>
*/ */
private <E, 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(Constant.TABLE_ALIAS)) {
return Constant.TABLE_ALIAS + rUid + StringPool.DOT + column2String(column, true); return Constant.TABLE_ALIAS + StringPool.DOT + column2String(column, true);
} }
for (SubTable sub : classList) { for (MyJoinLambdaQueryWrapper.SubTable sub : wrapper.classList) {
if (alias.equals(sub.getAlias())) { if (alias.equals(sub.getAlias())) {
return Constant.TABLE_ALIAS + sub.getRightUid() + StringPool.DOT + column2String(column, true); return Constant.TABLE_ALIAS + sub.getRightUid() + StringPool.DOT + column2String(column, true);
} }
@ -440,10 +363,50 @@ public class MyLambdaQueryWrapper<T> extends MyJoinLambdaQueryWrapper<T>
return doIt(condition, AND); return doIt(condition, AND);
} }
private MyLambdaQueryWrapper<T> or(boolean condition) { @Override
public MyLambdaQueryWrapper<T> or(boolean condition) {
return doIt(condition, OR); return doIt(condition, OR);
} }
@Override
public MyLambdaQueryWrapper<T> apply(boolean condition, String applySql, Object... value) {
return doIt(condition, APPLY, () -> formatSql(applySql, value));
}
@Override
public MyLambdaQueryWrapper<T> last(boolean condition, String lastSql) {
if (condition) {
this.lastSql.setStringValue(StringPool.SPACE + lastSql);
}
return typedThis;
}
@Override
public MyLambdaQueryWrapper<T> comment(boolean condition, String comment) {
if (condition) {
this.sqlComment.setStringValue(comment);
}
return typedThis;
}
@Override
public MyLambdaQueryWrapper<T> first(boolean condition, String firstSql) {
if (condition) {
this.sqlFirst.setStringValue(firstSql);
}
return typedThis;
}
@Override
public MyLambdaQueryWrapper<T> exists(boolean condition, String existsSql) {
return doIt(condition, EXISTS, () -> String.format("(%s)", existsSql));
}
@Override
public MyLambdaQueryWrapper<T> notExists(boolean condition, String existsSql) {
return not(condition).exists(condition, existsSql);
}
private MyLambdaQueryWrapper<T> not(boolean condition) { private MyLambdaQueryWrapper<T> not(boolean condition) {
return doIt(condition, NOT); return doIt(condition, NOT);
} }
@ -455,11 +418,11 @@ public class MyLambdaQueryWrapper<T> extends MyJoinLambdaQueryWrapper<T>
return this; return this;
} }
private <E, F> MyLambdaQueryWrapper<T> likeValue(boolean condition, SqlKeyword keyword, String column, Object val, SqlLike sqlLike) { private 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, F> MyLambdaQueryWrapper<T> addCondition(boolean condition, String column, SqlKeyword sqlKeyword, Object val) { protected 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));
} }
@ -529,12 +492,12 @@ public class MyLambdaQueryWrapper<T> extends MyJoinLambdaQueryWrapper<T>
} }
@Override @Override
public <E, F> MyLambdaQueryWrapper<T> having(boolean condition, String alias, String sqlHaving, Object... params) { public 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, F> MyLambdaQueryWrapper<T> func(boolean condition, String alias, Consumer<MyLambdaQueryWrapper<T>> consumer) { public MyLambdaQueryWrapper<T> func(boolean condition, String alias, Consumer<MyLambdaQueryWrapper<T>> consumer) {
if (condition) { if (condition) {
consumer.accept(this); consumer.accept(this);
} }

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

@ -183,31 +183,31 @@ public interface MyFunc<Children> extends Serializable {
<E, 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, F> Children having(String sqlHaving, Object... params) { default Children having(String sqlHaving, Object... params) {
return having(true, null, sqlHaving, params); return having(true, null, sqlHaving, params);
} }
default <E, F> Children having(boolean condition, String sqlHaving, Object... params) { default Children having(boolean condition, String sqlHaving, Object... params) {
return having(condition, null, sqlHaving, params); return having(condition, null, sqlHaving, params);
} }
default <E, F> Children having(String alias, String sqlHaving, Object... params) { default Children having(String alias, String sqlHaving, Object... params) {
return having(true, alias, sqlHaving, params); return having(true, alias, sqlHaving, params);
} }
<E, F> Children having(boolean condition, String alias, String sqlHaving, Object... params); Children having(boolean condition, String alias, String sqlHaving, Object... params);
default <E, F> Children func(Consumer<Children> consumer) { default Children func(Consumer<Children> consumer) {
return func(true, null, consumer); return func(true, null, consumer);
} }
default <E, F> Children func(boolean condition, Consumer<Children> consumer) { default Children func(boolean condition, Consumer<Children> consumer) {
return func(condition, null, consumer); return func(condition, null, consumer);
} }
default <E, F> Children func(String alias, Consumer<Children> consumer) { default Children func(String alias, Consumer<Children> consumer) {
return func(true, alias, consumer); return func(true, alias, consumer);
} }
<E, F> Children func(boolean condition, String alias, Consumer<Children> consumer); Children func(boolean condition, String alias, Consumer<Children> consumer);
} }

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

@ -1,6 +1,7 @@
package com.github.mybatisplus.wrapper.interfaces; package com.github.mybatisplus.wrapper.interfaces;
import com.github.mybatisplus.func.MySFunction; import com.github.mybatisplus.func.MySFunction;
import com.github.mybatisplus.toolkit.Constant;
import com.github.mybatisplus.wrapper.MyJoinLambdaQueryWrapper; import com.github.mybatisplus.wrapper.MyJoinLambdaQueryWrapper;
import java.util.function.Function; import java.util.function.Function;
@ -11,11 +12,13 @@ import java.util.function.Function;
public interface MyJoin<Children, T> { public interface MyJoin<Children, T> {
<R, TE, RE> Children leftJoin(boolean condition, default <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) {
return join(condition, alias, Constant.LEFT_JOIN, leftCondition, rightCondition, rightWrapper);
}
default <R, TE, RE> Children leftJoin(MySFunction<T, TE> leftCondition, default <R, TE, RE> Children leftJoin(MySFunction<T, TE> leftCondition,
@ -24,7 +27,10 @@ public interface MyJoin<Children, T> {
return leftJoin(true, null, leftCondition, rightCondition, rightWrapper); return leftJoin(true, null, leftCondition, rightCondition, rightWrapper);
} }
default <R, 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);
} }
@ -36,11 +42,13 @@ public interface MyJoin<Children, T> {
} }
<R, TE, RE> Children rightJoin(boolean condition, default <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) {
return join(condition, alias, Constant.RIGHT_JOIN, leftCondition, rightCondition, rightWrapper);
}
default <R, TE, RE> Children rightJoin(MySFunction<T, TE> leftCondition, default <R, TE, RE> Children rightJoin(MySFunction<T, TE> leftCondition,
@ -49,7 +57,10 @@ public interface MyJoin<Children, T> {
return rightJoin(true, null, leftCondition, rightCondition, rightWrapper); return rightJoin(true, null, leftCondition, rightCondition, rightWrapper);
} }
default <R, 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);
} }
@ -61,11 +72,13 @@ public interface MyJoin<Children, T> {
} }
<R, TE, RE> Children innerJoin(boolean condition, default <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) {
return join(condition, alias, Constant.INNER_JOIN, leftCondition, rightCondition, rightWrapper);
}
default <R, TE, RE> Children innerJoin(MySFunction<T, TE> leftCondition, default <R, TE, RE> Children innerJoin(MySFunction<T, TE> leftCondition,
@ -74,7 +87,10 @@ public interface MyJoin<Children, T> {
return innerJoin(true, null, leftCondition, rightCondition, rightWrapper); return innerJoin(true, null, leftCondition, rightCondition, rightWrapper);
} }
default <R, 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);
} }
@ -86,4 +102,10 @@ public interface MyJoin<Children, T> {
} }
<R, TE, RE> Children join(boolean condition,
String alias,
String keyWord,
MySFunction<T, TE> leftCondition,
MySFunction<R, RE> rightCondition,
Function<MyJoinLambdaQueryWrapper<R>, MyJoinLambdaQueryWrapper<R>> rightWrapper);
} }