Skip to content

灵活的 QueryWrapper

增删改查询和分页 章节中,我们随时能看到 QueryWrapper 的身影,QueryWrapper 是用于构造 Sql 的 强有力工具,也是 MyBatis-Flex 的亮点和特色。

提示

QueryWrapper 可以被序列化通过 RPC 进行传输,因此,在微服务项目中,我们可以在客户端(网关、Controller 层等)构造出 QueryWrapper,传给 Provider 层进行查询返回数据。

QueryWrapper 的使用

以下代码是一个完整 Spring Controller 的示例:

java
@RestController
public class AccountController {

    @Autowired
    AccountMapper accountMapper;

    @GetMapping("/accounts")
    List<Account> selectList() {

        //构造 QueryWrapper,也支持使用 QueryWrapper.create() 构造,效果相同
        QueryWrapper query = new QueryWrapper();
        query.where(ACCOUNT.ID.ge(100));

        //通过 query 查询数据列表返回
        return accountMapper.selectListByQuery(query);
    }
}

在以上的示例中,其核心代码如下所示:

java
//构造 QueryWrapper
QueryWrapper query = new QueryWrapper();
query.where(ACCOUNT.ID.ge(100));

//通过 query 查询数据列表
accountMapper.selectListByQuery(query);

以上代码执行的 Sql 如下:

sql
select * from tb_account
where id >= 100

问题:以上示例中,ACCOUNT.ID.ge(100) 中的 ACCOUNT 是怎么来的?

MyBatis-Flex 使用了 APT 技术,这个 ACCOUNT 是自动生成的。 参考:《MyBatis-Flex APT 配置》章节。

select *

java
QueryWrapper query1 = new QueryWrapper();
query1.select(ACCOUNT.ID, ACCOUNT.USER_NAME)
    .from(ACCOUNT);

QueryWrapper query2 = new QueryWrapper();
query2.select().from(ACCOUNT);

其查询生成的 Sql 如下:

sql
SELECT id, user_name FROM tb_account;

SELECT * FROM tb_account;

select ... as

java
QueryWrapper query = new QueryWrapper()
    .select(
          ACCOUNT.ID.as("accountId")
        , ACCOUNT.USER_NAME)
    .from(ACCOUNT.as("a"));

其查询生成的 Sql 如下:

sql
SELECT a.id as accountId, a.user_name
FROM tb_account AS a

select 多张表

java
QueryWrapper query = new QueryWrapper()
    .select(
          ACCOUNT.ID
        , ACCOUNT.USER_NAME
        , ARTICLE.ID.as("articleId")
        , ARTICLE.TITLE)
    .from(ACCOUNT.as("a"), ARTICLE.as("b"))
    .where(ACCOUNT.ID.eq(ARTICLE.ACCOUNT_ID));

其查询生成的 Sql 如下:

sql
SELECT a.id, a.user_name, b.id AS articleId, b.title
FROM tb_account AS a,
     tb_article AS b
WHERE a.id = b.account_id

select function(SQL 函数)

所有函数均在 QueryMethods 类中,以下示例皆为静态导入方法,省略了类名。

示例 :

java
QueryWrapper query = new QueryWrapper()
        .select(
            ACCOUNT.ID,
            ACCOUNT.USER_NAME,
            max(ACCOUNT.BIRTHDAY),
            avg(ACCOUNT.SEX).as("sex_avg")
        ).from(ACCOUNT);

其查询生成的 Sql 如下:

sql
SELECT id, user_name, MAX(birthday), AVG(sex) AS sex_avg
FROM tb_account

在使用函数时,一些数字、字符串常量需要通过特定的方法去构造,例如:

  • number():构建数字常量
  • string():构建字符串常量
  • column():构建自定义列

示例:

txt
select(number(1)) --> SELECT 1
select(string("str")) --> SELECT 'str'
select(column("abc")) --> SELECT abc

目前,MyBatis-Flex 已支持 110+ 个常见的 SQL 函数,查看已支持的 所有函数。 若还不满足,您可以参考 QueryMethods ,然后在自己的项目里进行自定义扩展。

支持的函数函数说明
count查询数据总量
distinct对指定列进行去重
sum返回指定字段值的和
avg返回指定列的平均值
min返回指定列的最小值
max返回指定列的最大值
abs返回绝对值
ceil返回大于或等于 x 的最小整数(向上取整)
ceiling返回大于或等于 x 的最小整数(向上取整)
floor返回小于或等于 x 的最大整数(向下取整)
rand返回 0~1 的随机数
sign返回 x 的符号,x 是负数、0、正数分别返回 -1、0、1
pi返回圆周率
truncate返回数值 x 保留到小数点后 y 位的值
round返回离 x 最近的整数(四舍五入)
pow返回 x 的 y 次方
power返回 x 的 y 次方
sqrt返回 x 的平方根
exp返回 e 的 x 次方
mod返回 x 除以 y 以后的余数
log返回自然对数(以 e 为底的对数)
log10返回以 10 为底的对数
radians将角度转换为弧度
degrees将弧度转换为角度
sin求正弦值
asin求反正弦值
cos求余弦值
acos求反余弦值
tan求正切值
atan求反正切值
cot求余切值
charLength返回字符串 s 的字符数
length返回字符串 s 的长度
concat将字符串 s1,s2 等多个字符串合并为一个字符串
concatWs同 CONCAT(s1, s2, ...),但是每个字符串之间要加上 x
insert将字符串 s2 替换 s1 的 x 位置开始长度为 len 的字符串
upper将字符串 s 的所有字符都变成大写字母
lower将字符串 s 的所有字符都变成小写字母
left返回字符串 s 的前 n 个字符
right返回字符串 s 的后 n 个字符
lpad字符串 s2 来填充 s1 的开始处,使字符串长度达到 len
rpad字符串 s2 来填充 s1 的结尾处,使字符串长度达到 len
trim去掉字符串 s 开始处和结尾处的空格
ltrim去掉字符串 s 开始处的空格
rtrim去掉字符串 s 结尾处的空格
repeat将字符串 s 重复 n 次
space返回 n 个空格
replace用字符串 s2 代替字符串 s 中的字符串 s1
strcmp比较字符串 s1 和 s2
substring获取从字符串 s 中的第 n 个位置开始长度为 len 的字符串
instr从字符串 s 中获取 s1 的开始位置
reverse将字符串 s 的顺序反过来
elt返回第 n 个字符串
field返回第一个与字符串 s 匹配的字符串的位置
findInSet返回在字符串 s2 中与 s1 匹配的字符串的位置
curDate返回当前日期
currentDate返回当前日期
curTime返回当前时间
currentTime返回当前时间
now返回当前日期和时间
currentTimestamp返回当前日期和时间
localTime返回当前日期和时间
sysDate返回当前日期和时间
localTimestamp返回当前日期和时间
unixTimestamp以 UNIX 时间戳的形式返回当前时间
fromUnixTime把 UNIX 时间戳的时间转换为普通格式的时间
utcDate返回 UTC(国际协调时间)日期
utcTime返回 UTC 时间
month返回日期 d 中的月份值,范围是 1~12
monthName返回日期 d 中的月份名称,如 january
dayName返回日期 d 是星期几,如 Monday
dayOfWeek返回日期 d 是星期几,1 表示星期日,2 表示星期二
weekday返回日期 d 是星期几,0 表示星期一,1 表示星期二
week计算日期 d 是本年的第几个星期,范围是 0-53
weekOfYear计算日期 d 是本年的第几个星期,范围是 1-53
dayOfYear计算日期 d 是本年的第几天
dayOfMonth计算日期 d 是本月的第几天
year返回日期 d 中的年份值
day返回日期 d 中的天数值
quarter返回日期 d 是第几季度,范围 1-4
hour返回时间 t 中的小时值
minute返回时间 t 中的分钟值
second返回时间 t 中的秒钟值
timeToSec将时间 t 转换为秒
secToTime将以秒为单位的时间 s 转换为时分秒的格式
toDays计算日期 d 到 0000 年 1 月 1 日的天数
fromDays计算从 0000 年 1 月 1 日开始 n 天后的日期
dateDiff计算日期 d1 到 d2 之间相隔的天数
addDate计算开始日期 d 加上 n 天的日期
subDate计算起始日期 d 减去 n 天的日期
addTime计算起始时间 t 加上 n 秒的时间
subTime计算起始时间 t 加上 n 秒的时间
dateFormat按照表达式 f 的要求显示日期 d
timeFormat按照表达式 f 的要求显示时间 t
getFormat根据字符串 s 获取 type 类型数据的显示格式
version返回数据库的版本号
connectionId返回服务器的连接数
database返回当前数据库名
schema返回当前数据库 schema
user返回当前用户的名称
charset返回字符串 str 的字符集
collation返回字符串 str 的字符排列方式
lastInsertId返回最后生成的 auto_increment 值
password对字符串 str 进行加密
md5对字符串 str 进行 md5 加密
encode使用字符串 pswd_str 来加密字符串 str,加密结果是一个二进制数,必须使用 BLOB 类型来保持它
decode解密函数,使用字符串 pswd_str 来为 crypt_str 解密
format格式化函数,可以将数字 x 进行格式化,将 x 保留到小数点后 n 位,这个过程需要进行四舍五入
ascii返回字符串 s 的第一个字符的 ASSCII 码
bin返回 x 的二进制编码
hex返回 x 的十六进制编码
oct返回 x 的八进制编
conv将 x 从 f1 进制数变成 f2 进制数
inetAton将 IP 地址转换为数字表示,IP 值需要加上引号
inetNtoa将数字 n 转换成 IP 的形式

select 列计算

示例 1:

java
QueryWrapper query = new QueryWrapper()
    .select(ACCOUNT.ID.add(100).as("x100"))
    .from(ACCOUNT);

String sql = query.toSQL();

列计算的 加减乘除 对应的方法分别为:add / subtract / multiply / divide

其查询生成的 Sql 如下:

sql
SELECT (`id` + 100) AS `x100` FROM `tb_account`

示例 2:

java
QueryWrapper query = new QueryWrapper()
    .select(sum(ACCOUNT.ID.multiply(ACCOUNT.AGE)).as("total_x"))
    .from(ACCOUNT);

其查询生成的 Sql 如下:

sql
SELECT SUM(`id` * `age`) AS `total_x` FROM `tb_account`

示例 3:

java
QueryWrapper query = new QueryWrapper()
    .select(ACCOUNT.ID.add(ACCOUNT.AGE.add(100)).as("x100"))
    .from(ACCOUNT);

String sql = query.toSQL();

其查询生成的 Sql 如下:

sql
SELECT (`id` + (`age` + 100)) AS `x100` FROM `tb_account`

select 取相反数

java
import static com.mybatisflex.core.query.QueryMethods.*;

QueryWrapper queryWrapper = QueryWrapper.create()
    // 负数常量需要手动加括号,不能写成 number(-1)
    .select(negative(column("(-1)")))
    .select(negative(abs(ACCOUNT.AGE)).as("opp"))
    .select(negative(ACCOUNT.ID.add(ACCOUNT.AGE)))
    .from(ACCOUNT);
sql
SELECT -(-1), -ABS(`age`) AS `opp`, -(`id` + `age`) FROM `tb_account`

select case...when

示例 1:

java
QueryWrapper wrapper = QueryWrapper.create()
        .select(
             ACCOUNT.ID
            ,case_()
                .when(ACCOUNT.ID.ge(2)).then("x2")
                .when(ACCOUNT.ID.ge(1)).then("x1")
                .else_("x100")
                .end().as("xName")
        )

其查询生成的 Sql 如下:

sql
 SELECT `id`,
        (CASE WHEN `id` >=  2  THEN 'x2'
            WHEN `id` >=  1  THEN 'x1'
            ELSE 'x100'
            END) AS `xName`
 FROM `tb_account`

SQL 执行的结果如下:

|id     |xName     |
|1      |x1        |
|2      |x2        |

示例 2:

java
QueryWrapper queryWrapper = QueryWrapper.create()
        .select(
                ACCOUNT.ALL_COLUMNS,
                case_(ACCOUNT.ID)
                    .when(100).then(100)
                    .when(200).then(200)
                    .else_(300).end().as("result")
        )
        .from(ACCOUNT)
        .where(ACCOUNT.USER_NAME.like("michael"));

其查询生成的 Sql 如下:

sql
SELECT *,
       (CASE `id`
           WHEN 100 THEN 100
           WHEN 200 THEN 200
           ELSE 300 END) AS `result`
FROM `tb_account`
WHERE `user_name` LIKE  ?

提示

在以上示例中,由于 caseelse 属于 Java 关键字,无法使用其进行方法命名,因此会添加一个下划线小尾巴 "_" 变成 case_else_,这是无奈之举。 在以后的 QueryWrapper 构建中,遇到 java 关键字也会采用类似的解决方法。

with...select

示例 1:

java
QueryWrapper query = new QueryWrapper()
        .with("CTE").asSelect(
                select().from(ARTICLE).where(ARTICLE.ID.ge(100))
        )
        .select()
        .from(ACCOUNT)
        .where(ACCOUNT.SEX.eq(1));

System.out.println(query.toSQL());

生成的 SQL 如下:

sql
WITH CTE AS (SELECT * FROM `tb_article` WHERE `id` >= 100)
SELECT * FROM `tb_account` WHERE `sex` = 1

示例 2:

java
QueryWrapper query = new QueryWrapper()
    .with("xxx", "id", "name").asValues(
        Arrays.asList("a", "b"),
        union(
            select().from(ARTICLE).where(ARTICLE.ID.ge(200))
        )
    )
    .from(ACCOUNT)
    .where(ACCOUNT.SEX.eq(1));

System.out.println(query.toSQL());

生成的 SQL 如下:

sql
WITH xxx(id, name)
    AS (VALUES (a, b) UNION (SELECT * FROM `tb_article` WHERE `id` >= 200))
SELECT * FROM `tb_account` WHERE `sex` = 1

with recursive...select

示例 1:

java
QueryWrapper query = new QueryWrapper()
    .withRecursive("CTE").asSelect(
        select().from(ARTICLE).where(ARTICLE.ID.ge(100))
    )
    .from(ACCOUNT)
    .where(ACCOUNT.SEX.eq(1));

System.out.println(query.toSQL());

生成的 SQL 如下:

sql
WITH RECURSIVE CTE AS (SELECT * FROM `tb_article` WHERE `id` >= 100)
SELECT * FROM `tb_account` WHERE `sex` = 1

示例 2:

java
QueryWrapper query = new QueryWrapper()
    .withRecursive("CTE").asSelect(
        select().from(ARTICLE).where(ARTICLE.ID.ge(100))
    )
    .with("xxx", "id", "name").asValues(
        Arrays.asList("a", "b"),
        union(
            select().from(ARTICLE).where(ARTICLE.ID.ge(200))
        )
    )
    .from(ACCOUNT)
    .where(ACCOUNT.SEX.eq(1));

System.out.println(query.toSQL());

生成的 SQL 如下:

sql
WITH RECURSIVE
     CTE AS (SELECT * FROM `tb_article` WHERE `id` >= 100),
     xxx(id, name) AS (VALUES (a, b)  UNION (SELECT * FROM `tb_article` WHERE `id` >= 200))
SELECT * FROM `tb_account` WHERE `sex` = 1

where

java
QueryWrapper queryWrapper=QueryWrapper.create()
    .select()
    .from(ACCOUNT)
    .where(ACCOUNT.ID.ge(100))
    .and(ACCOUNT.USER_NAME.like("michael"));

其查询生成的 Sql 如下:

sql
SELECT * FROM tb_account
WHERE id >=  ?
AND user_name LIKE  ?

where 动态条件

注意

QueryWrapper条件构建中,若参数为null时默认会被忽略,不会拼接查询条件

方式1:when()

java
boolean flag = false;
QueryWrapper queryWrapper = QueryWrapper.create()
    .select().from(ACCOUNT)
    .where(ACCOUNT.ID.ge(100).when(flag)) //flag为false,忽略该条件
    .and(ACCOUNT.USER_NAME.like("michael"));

其查询生成的 Sql 如下:

sql
SELECT * FROM tb_account
WHERE user_name LIKE 'michael'

方式2:使用重载方法

java
boolean flag = false;
QueryWrapper queryWrapper = QueryWrapper.create()
    .select().from(ACCOUNT)
    .and(ACCOUNT.USER_NAME.like("michael", flag)); //flag为false,忽略该条件

对当前条件参数进行判断:

java
String name = "";
QueryWrapper queryWrapper = QueryWrapper.create()
    .select().from(ACCOUNT)
    .where(ACCOUNT.USER_NAME.like(name, StringUtil::isNotBlank)); //name为空字符串,忽略该条件

框架提供了工具类If,包含常用的判断方法(如非空、非空集合、非空字符串等),供开发者简化代码:

java
String name = "";
QueryWrapper queryWrapper = QueryWrapper.create()
    .select().from(ACCOUNT)
    .where(ACCOUNT.USER_NAME.like(name, If::hasText)); //name是否有文本

上述代码生成的 Sql 如下:

sql
SELECT * FROM tb_account;

where 使用 SQL 函数

你可以通过使用 QueryMethods 类下的函数实现 where 对指定列运算后作为条件进行查询(QueryMethods 位于 mybatisflex.core.query 下)。

java
QueryWrapper qw = QueryWrapper.create();
qw.select(USER.ID,
    USER.USER_ALIAS,
    USER.PASSWORD,
    USER.USER_NAME.as("userName"))
    .where(
           QueryMethods.abs(USER.ID).eq(1)
    )
    .from(USER);

其查询生成的 Sql 如下:

sql
SELECT `id`, `alias`, `pwd`, `name` AS `userName`
FROM `user` WHERE ABS(`id`) = 1

where select

java
QueryWrapper queryWrapper = QueryWrapper.create()
    .select()
    .from(ACCOUNT)
    .where(ACCOUNT.ID.ge(
        select(ARTICLE.ACCOUNT_ID).from(ARTICLE).where(ARTICLE.ID.ge(100))
    ));

其查询生成的 Sql 如下:

sql
SELECT * FROM tb_account
WHERE id >=
(SELECT account_id FROM tb_article WHERE id >=  ? )

where exists, not exists

java
QueryWrapper queryWrapper=QueryWrapper.create()
    .select()
    .from(ACCOUNT)
    .where(ACCOUNT.ID.ge(100))
    .and(
        exists(  // or notExists(...)
            selectOne().from(ARTICLE).where(ARTICLE.ID.ge(100))
        )
    );

其查询生成的 Sql 如下:

sql
SELECT * FROM tb_account
WHERE id >=  ?
AND EXISTS (
    SELECT 1 FROM tb_article WHERE id >=  ?
)

and (...) or (...)

java
QueryWrapper queryWrapper=QueryWrapper.create()
    .select()
    .from(ACCOUNT)
    .where(ACCOUNT.ID.ge(100))
    .and(ACCOUNT.SEX.eq(1).or(ACCOUNT.SEX.eq(2)))
    .or(ACCOUNT.AGE.in(18,19,20).and(ACCOUNT.USER_NAME.like("michael")));

其查询生成的 Sql 如下:

sql
SELECT * FROM tb_account
WHERE id >=  ?
AND (sex =  ? OR sex =  ? )
OR (age IN (?,?,?) AND user_name LIKE ? )

自定义字符串列名

java
// 静态导入 QueryMethods.column 方法
QueryColumn a1 = column("a1");

QueryWrapper queryWrapper = QueryWrapper.create()
    .select()
    .from(ACCOUNT)
    .where(a1.ge(100))
    .and(a1.ne(200))

其查询生成的 Sql 如下:

sql
SELECT * FROM tb_account
WHERE a1 >=  100
AND a1 != 200

以上 SQL 的 Java 代码也可以简写为:

java
QueryWrapper queryWrapper = QueryWrapper.create()
    .from(ACCOUNT)
    .where(column("a1").ge(100))
    .and(column("a1").ne(200))

注意,以上代码需要静态导入 QueryMethods.column 方法:

java
import static com.mybatisflex.core.query.QueryMethods.*;

group by

java
QueryWrapper queryWrapper=QueryWrapper.create()
    .select()
    .from(ACCOUNT)
    .groupBy(ACCOUNT.USER_NAME);

其查询生成的 Sql 如下:

sql
SELECT * FROM tb_account
GROUP BY user_name

having

java
QueryWrapper queryWrapper=QueryWrapper.create()
    .select()
    .from(ACCOUNT)
    .groupBy(ACCOUNT.USER_NAME)
    .having(ACCOUNT.AGE.between(18,25));

其查询生成的 Sql 如下:

sql
SELECT * FROM tb_account
GROUP BY user_name
HAVING age BETWEEN  ? AND ?

orderBy

java
QueryWrapper queryWrapper=QueryWrapper.create()
    .select()
    .from(ACCOUNT)
    .orderBy(ACCOUNT.AGE.asc(), ACCOUNT.USER_NAME.desc().nullsLast());

其查询生成的 Sql 如下:

sql
SELECT * FROM tb_account
ORDER BY age ASC, user_name DESC NULLS LAST

orderBy 动态排序

java
QueryWrapper queryWrapper = QueryWrapper.create()
    .select()
    .from(ACCOUNT)
    // 动态条件取值:true 升序 false 降序 null 不排序。
    .orderBy(ACCOUNT.ID, true)
    .orderBy(ACCOUNT.BIRTHDAY, false)
    .orderBy(ACCOUNT.USER_NAME, null);

其查询生成的 Sql 如下:

sql
SELECT *
FROM `tb_account`
ORDER BY `id` ASC, `birthday` DESC

hint

Hint 是数据库厂商(比如 Oracle、MySQL、达梦等)提供的一种 SQL语法,它允许用户在 SQL 语句中插入相关的语法,从而影响 SQL 的执行方式。 它是一种【非常规】的直接影响优化器、指定执行计划的 SQL 优化手段。

java
QueryWrapper queryWrapper=QueryWrapper.create()
    .select().hint("INDEX_DESC")
    .from(ACCOUNT)
    .orderBy(ACCOUNT.AGE.asc(), ACCOUNT.USER_NAME.desc().nullsLast());

其查询生成的 Sql 如下:

sql
SELECT /*+ INDEX_DESC */  * FROM tb_account
ORDER BY age ASC, user_name DESC NULLS LAST

join(left join,inner join...)

java
QueryWrapper queryWrapper=QueryWrapper.create()
    .select()
    .from(ACCOUNT)
    .leftJoin(ARTICLE).on(ACCOUNT.ID.eq(ARTICLE.ACCOUNT_ID))
    .innerJoin(ARTICLE).on(ACCOUNT.ID.eq(ARTICLE.ACCOUNT_ID))
    .where(ACCOUNT.AGE.ge(10));

其查询生成的 Sql 如下:

sql
SELECT * FROM tb_account
LEFT JOIN tb_article ON tb_account.id = tb_article.account_id
INNER JOIN tb_article ON tb_account.id = tb_article.account_id
WHERE tb_account.age >=  ?

join on 多个条件

java
QueryWrapper queryWrapper = QueryWrapper.create()
    .select()
    .from(ACCOUNT)
    .leftJoin(ARTICLE).on(
        ACCOUNT.ID.eq(ARTICLE.ACCOUNT_ID).and(ACCOUNT.AGE.eq(18))
    )
    .where(ACCOUNT.AGE.ge(10));

其查询生成的 Sql 如下:

sql
SELECT * FROM tb_account LEFT JOIN tb_article
ON tb_account.id = tb_article.account_id AND tb_account.age =  ?
WHERE tb_account.age >=  ?

join select

java
QueryWrapper queryWrapper = QueryWrapper.create()
    .select()
    .from(ACCOUNT)
    .leftJoin(
        select().from(ARTICLE).where(ARTICLE.ID.ge(100))
    ).as("a").on(
        ACCOUNT.ID.eq(raw("a.id"))
    )
    .where(ACCOUNT.AGE.ge(10));

其查询生成的 Sql 如下:

sql
SELECT * FROM tb_account
LEFT JOIN (SELECT * FROM tb_article WHERE id >=  ? ) AS a
ON tb_account.id = a.id
WHERE tb_account.age >=  ?

join 自己

java
QueryWrapper queryWrapper = QueryWrapper.create();
queryWrapper.from(ACCOUNT)
    .leftJoin(ACCOUNT).as("a1").on(ACCOUNT.ID.eq(ACCOUNT.PARENT_ID))
    .leftJoin(ACCOUNT).as("a2").on(ACCOUNT.ID.eq(ACCOUNT.PARENT_ID))
    .where(ACCOUNT.ID.ge(1));

其查询生成的 Sql 如下:

sql
SELECT * FROM `tb_account`
    LEFT JOIN `tb_account` AS `a1`
        ON `a1`.`id` = `tb_account`.`parent_id`
    LEFT JOIN `tb_account` AS `a2`
        ON `a2`.`id` = `tb_account`.`parent_id`
WHERE `tb_account`.`id` >= ?

tb_account 表带有逻辑删除,那么其生成的 SQL 如下:

sql
SELECT * FROM `tb_account`
    LEFT JOIN `tb_account` AS `a1`
        ON `a1`.`id` = `tb_account`.`parent_id` AND `a1`.`is_delete` = ?
    LEFT JOIN `tb_account` AS `a2`
        ON `a2`.`id` = `tb_account`.`parent_id` AND `a2`.`is_delete` = ?
WHERE `tb_account`.`id` >= ?
  AND `tb_account`.`is_delete` = ?

关于逻辑删除更多文档请参考 这里

union, union all

java
QueryWrapper query = new QueryWrapper()
    .select(ACCOUNT.ID)
    .from(ACCOUNT)
    .orderBy(ACCOUNT.ID.desc())
    .union(select(ARTICLE.ID).from(ARTICLE))
    .unionAll(select(ARTICLE.ID).from(ARTICLE));

其查询生成的 Sql 如下:

sql
(SELECT id FROM tb_account ORDER BY id DESC)
UNION (SELECT id FROM tb_article)
UNION ALL (SELECT id FROM tb_article)

limit... offset

提示

在 "limit... offset" 的示例中,MyBatis-Flex 能够自动识别当前数据库👍,并根据数据库的类型生成不同的 SQL,用户也可以很轻易的通过 DialectFactory 注册(新增或改写)自己的实现方言。

java
QueryWrapper queryWrapper = QueryWrapper.create()
    .select()
    .from(ACCOUNT)
    .orderBy(ACCOUNT.ID.desc())
    .limit(10)
    .offset(20);

MySQL 下执行的代码如下:

sql
SELECT * FROM `tb_account` ORDER BY `id` DESC LIMIT 20, 10

PostgreSQL 下执行的代码如下:

sql
SELECT * FROM "tb_account" ORDER BY "id" DESC LIMIT 20 OFFSET 10

Informix 下执行的代码如下:

sql
SELECT SKIP 20 FIRST 10 * FROM "tb_account" ORDER BY "id" DESC

Oracle 下执行的代码如下:

sql
SELECT * FROM (SELECT TEMP_DATAS.*,
    ROWNUM RN FROM (
        SELECT * FROM "tb_account" ORDER BY "id" DESC)
    TEMP_DATAS WHERE  ROWNUM <=30)
WHERE RN >20

Db2 下执行的代码如下:

sql
SELECT * FROM "tb_account" ORDER BY "id" DESC
OFFSET 20 ROWS FETCH NEXT 10 ROWS ONLY

Sybase 下执行的代码如下:

sql
SELECT TOP 10 START AT 21 * FROM "tb_account" ORDER BY "id" DESC

Firebird 下执行的代码如下:

sql
SELECT * FROM "tb_account" ORDER BY "id" DESC ROWS 20 TO 30

Lambda 扩展

简单示例:

java
QueryWrapper query = QueryWrapper.create();
query.where(Account::getId).ge(100)
        .and(Account::getUserName).like("michael")
        .or(Account::getUserName).like(" ", If::hasText);
System.out.println(query.toSQL());

SQL 输入内容如下:

sql
SELECT * FROM  WHERE `id` >=  100  AND `user_name` LIKE  '%michael%'

稍微复杂点的示例:

java
QueryWrapper query = QueryWrapper.create()
    .from(Article.class)
    .leftJoin(Account.class).as("a").on(
        wrapper -> wrapper.where(Account::getId).eq(Article::getAccountId)
    )
    .where(Account::getId).ge(100, If::notEmpty)
    .and(wrapper -> {
        wrapper.where(Account::getId).ge(100)
                .or(Account::getAge).gt(200)
                .and(Article::getAccountId).eq(200)
                .or(wrapper1 -> {
                    wrapper1.where(Account::getId).like("a", If::notEmpty);
                })
        ;
    });
System.out.println(query.toSQL());

SQL 输入内容如下:

sql
SELECT * FROM `tb_article`
    LEFT JOIN `tb_account` AS `a` ON `a`.`id` = `tb_article`.`account_id`
WHERE `a`.`id` >=  100  AND
      (`a`.`id` >=  100
           OR `a`.`age` >  200
           AND `tb_article`.`account_id` =  200
           OR (`a`.`id` LIKE  '%a%' )
      )

MyBatis-Plus 兼容 API ^ v1.7.2

从 MyBatis-Flex v1.7.2 开始,QueryWrapper 添加了一系列对 MyBatis-Plus 兼容的 API,方便喜欢 MyBatis-Flex 用户从 MyBatis-Plus 迁移到 MyBatis-Flex。

示例代码如下:

java
QueryWrapper queryWrapper = new QueryWrapper();
queryWrapper.from("tb_account")
    .eq("column1", "value1")
    .ge(Account::getAge, 18)
    .or(wrapper -> {
        wrapper.eq("column2", "value2")
            .ge(Account::getSex, 0);
    });

System.out.println(queryWrapper.toSQL());

以上代码内容,输出的 SQL 如下:

sql
SELECT * FROM `tb_account`
WHERE column1 = 'value1' AND `age` >= 18
OR (column2 = 'value2' AND `sex` >= 0)

以上的 API 虽然尽量兼容 MyBatis-Plus,但也有所不同,需要用户注意以下几点:

注意点 1:

对于 eq()ne()... 等方法的忽略条件判断,MyBatis-Plus 在第一个参数,而 MyBatis-Flex 在 最后一个 参数。例如:

MyBatis-Plus 的写法:

java
QueryWrapper qw = new QueryWrapper();
qw.eq(false, "column1", 0); // MyBatis-Plus 在第一个参数

MyBatis-Flex 的写法:

java
QueryWrapper qw = new QueryWrapper();
qw.eq("column1", 0, false); // MyBatis-Flex 在最后一个参数

注意点 2:

对于 likeLeftlikeRightnotLikeLeftnotLikeRight 这 4 个方法,MyBatis-Flex 和 MyBatis-Plus 是相反的。

例如:

java
QueryWrapper qw = new QueryWrapper();
qw.likeLeft("name", "3");

MyBatis-Plus 生成的 where 条件是:

sql
where name like '%3'

而 MyBatis-Flex 生成的 where 条件是:

sql
where name like '3%'

因此,假设数据表的内容如下:

shell
name
————
123
345

相同的代码 qw.likeLeft("name", "3"),MyBatis-Flex 匹配到的内容是 345,而 MyBatis-Plus 匹配到的内容是 123

Entity 转化为 QueryWrapper

QueryWrapper 提供了 create() 方法帮助用户把 entity 转化为 QueryWrapper。

简单示例:

java
Account account = new Account();
account.setAge(18);
account.setUserName("michael");

QueryWrapper qw = QueryWrapper.create(account);
System.out.println(qw.toSQL());

输出的 SQL 内容如下:

sql
SELECT `id`, `user_name`, `birthday`, `sex`, `age`, `is_normal`
FROM `tb_account`
WHERE `user_name` = 'michael' and `age` = 18

自定义 Entity 字段的 SQL 操作符示例:

java
Account account = new Account();
account.setAge(18);
account.setUserName("michael");

SqlOperators operators = SqlOperators.of()
  .set(Account::getUserName, SqlOperator.LIKE)
  .set(Account::getAge, SqlOperator.GE);

QueryWrapper qw = QueryWrapper.create(account, operators);
System.out.println(qw.toSQL());

输出的 SQL 内容如下:

sql
SELECT `id`, `user_name`, `birthday`, `sex`, `age`, `is_normal`
FROM `tb_account`
WHERE `user_name` LIKE '%michael%' AND `age` >= 18

Map 转化为 QueryWrapper

方法同 Entity 转化为 QueryWrapper 类似,只需要把 entity 变量替换为 map 即可。

QueryWrapper 序列化

QueryWrapper 中,由于其定义了 循环引用 的一些数据结构,同时,其很多属性都是 private 或者 protected 修饰且没有 getter setter 方法, 这会导致使用一些 json 库在序列化的过程中,出现问题;但这些问题并非 QueryWrapper 的问题,而是序列化框架的问题。

因此,我们在使用序列化框架时,需要注意其是否支持这些特征,比如在使用 FastJson2 序列化时,需要添加以下配置:

序列化:

java
String json = JSON.toJSONString(queryWrapper
        , JSONWriter.Feature.FieldBased // 基于 field,而非 getter 方法
        , JSONWriter.Feature.ReferenceDetection);

反序列化:

java
QueryWrapper query  = JSON.parseObject(json, QueryWrapper.class
, JSONReader.Feature.FieldBased);

GsonJackson 等其他框架需要自行参考其文档添加相关配置;另外,我们更加建议使用专业的序列化工具去进行序列化,而非使用 json,比如使用 JDK Serial 或者 fst 等。 以下是相关的序列化示例代码:

JDK Serial 序列化:

java
QueryWrapper queryWrapper = ...
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos);
oos.writeObject(queryWrapper);

JDK Serial 反序列化:

java
byte[] bytes = ....
ByteArrayInputStream bis = new ByteArrayInputStream(bytes);
ObjectInputStream ois = new ObjectInputStream(bis);
QueryWrapper queryWrapper = (QueryWrapper) ois.readObject();

fst 序列化 和 反序列化:

java
FSTConfiguration fst = FSTConfiguration.createDefaultConfiguration();

//序列化得到 bytes 进行存储或者传输
byte[] bytes = fst.asByteArray(wrapper);

//反序列化得到 QueryWrapper
QueryWrapper newWrapper = (QueryWrapper) fst.asObject(bytes);

QueryWrapper 克隆

当我们想对 QueryWrapper 进行改造而不想影响之前构建出来的 QueryWrapper 时,可以使用 clone() 方法,克隆出来一份 QueryWrapper 进行操作,示例:

java
QueryWrapper queryWrapper = QueryWrapper.create()
    .from(ACCOUNT)
    .select(ACCOUNT.DEFAULT_COLUMNS)
    .where(ACCOUNT.ID.eq(1));

QueryWrapper clone = queryWrapper.clone();

// 清空 SELECT 语句
CPI.setSelectColumns(clone, null);
// 重新设置 SELECT 语句
clone.select(ACCOUNT.ID, ACCOUNT.USER_NAME);

System.out.println(queryWrapper.toSQL());
System.out.println(clone.toSQL());

特别注意事项!!!

在 QueryWrapper 的条件构建中,如果传入 null 值,则自动忽略该条件,这有许多的好处,不需要额外的通过 when() 方法判断。但是也带来一些额外的知识记忆点, 因此,正对这一点需要特别注意一下。

例如:

java
String userName = null;
Integer id = null;
QueryWrapper query1 = QueryWrapper.create()
    .where(ACCOUNT.AGE.ge(18))
    .and(ACCOUNT.USER_NAME.like(userName))
    .and(ACCOUNT.ID.ge(id));

QueryWrapper query2 = QueryWrapper.create()
    .where(ACCOUNT.AGE.ge(18));

在以上的 query1 中,由于 userNameid 都为 null,MyBatis-Flex 会自动忽略 null 值的条件,因此,它们构建出来的 SQL 条件是和 query2 完全一致的 。

QueryColumnBehavior ^ v1.5.7

在以上的内容中,我们知道 MyBatis-Flex 会自动忽略 null 值的条件,但是在实际开发中,有的开发者希望除了自动忽略 null 值以外,还可以自动忽略其他值,内置的规则有null(默认) 、空字符串空白字符串 ,当然也可以自定义。

此时,我们可以通过配置 QueryColumnBehavior 来自定义忽略的值。

java
// 使用内置规则自动忽略 null 和 空字符串
QueryColumnBehavior.setIgnoreFunction(QueryColumnBehavior.IGNORE_EMPTY);
// 使用内置规则自动忽略 null 和 空白字符串
QueryColumnBehavior.setIgnoreFunction(QueryColumnBehavior.IGNORE_BLANK);
// 其他自定义规则
QueryColumnBehavior.setIgnoreFunction(o -> {...});

另外,在某些场景下,开发者希望在构建 QueryWrapper 中,如果传入的值是集合或数组,则使用 in 逻辑,否则使用 =(等于) 逻辑:

java
QueryColumnBehavior.setSmartConvertInToEquals(true);

当添加以上配置时,我们在构建 QueryWrapper 的 in 的 SQL 时,逻辑如下:

java
// ids 有多个值
List<Integer> ids = Arrays.asList(1, 2, 3);
QueryWrapper qw = new QueryWrapper();
qw.where(ACCOUNT.ID.in(ids))

System.out.println(qw.toSQL());

输出的 SQL 如下:

sql
select * from tb_account where id in (1,2,3);

ids 只有 1 个值时,逻辑如下:

java
// ids 只有 1 个值
List<Integer> ids = Arrays.asList(1);
QueryWrapper qw = new QueryWrapper();
qw.where(ACCOUNT.ID.in(ids))

System.out.println(qw.toSQL());

输出的 SQL 如下:

sql
select * from tb_account where id = 1;

存在疑问?

疑问1:示例代码中的 QueryWrapper 所需要的 "ACCOUNT" 从哪里来的?

答:MyBatis-Flex 使用了 APT(Annotation Processing Tool)在项目编译的时候, 会自动根据 Entity 类定义的字段生成 "ACCOUNT" 类以及 Entity 对应的 Mapper 类, 通过开发工具构建项目(如下图), 或者执行 maven 编译命令: mvn clean package 都可以自动生成。这个原理和 lombok 一致。

更多关于 APT 的配置,请进入 APT 配置章节 了解。