文章目录
- 前言
- 一、功能详解
- 1. allEq
- 2. eq
- 3. ne
- 4. gt
- 5. ge
- 6. lt
- 7. le
- 8. between
- 9. notBetween
- 10. like
- 11. notLike
- 12. likeLeft
- 13. likeRight
- 14. notLikeLeft
- 15. notLikeRight
- 16. isNull
- 17. in
- 18. notIn
- 19. inSql
- 20. notInSql
- 21. eqSqlSince 3.5.6
- 22. gtSql Since 3.4.3.2
- 23. geSql Since 3.4.3.2
- 24. ltSql Since 3.4.3.2
- 25. leSql Since 3.4.3.2
- 26. groupBy
- 27. orderByAsc
- 28. orderByDesc
- 29. orderBy
- 30. having
- 31. func
- 32. or
- 33. and
- 34. nested
- 35. apply
- 36. last
- 37. exists
- 38. notExists
- 39. select
- 40. set
- 41. setSql
- 42. setIncrBy Since 3.5.6
- 43. setDecrBy
- 44. lambda
- 总结
前言
MyBatis-Plus 提供了一套强大的条件构造器(Wrapper),用于构建复杂的数据库查询条件。Wrapper 类允许开发者以链式调用的方式构造查询条件,无需编写繁琐的 SQL 语句,从而提高开发效率并减少 SQL 注入的风险。
在 MyBatis-Plus 中,Wrapper 类是构建查询和更新条件的核心工具。以下是主要的 Wrapper 类及其功能:
-
AbstractWrapper:这是一个抽象基类,提供了所有 Wrapper 类共有的方法和属性。它定义了条件构造的基本逻辑,包括字段(column)、值(value)、操作符(condition)等。所有的 - - - - QueryWrapper、UpdateWrapper、LambdaQueryWrapper 和 LambdaUpdateWrapper 都继承自 AbstractWrapper。
-
QueryWrapper:专门用于构造查询条件,支持基本的等于、不等于、大于、小于等各种常见操作。它允许你以链式调用的方式添加多个查询条件,并且可以组合使用 and 和 or 逻辑。
-
UpdateWrapper:用于构造更新条件,可以在更新数据时指定条件。与 QueryWrapper 类似,它也支持链式调用和逻辑组合。使用 UpdateWrapper 可以在不创建实体对象的情况下,直接设置更新字段和条件。
-
LambdaQueryWrapper:这是一个基于 Lambda 表达式的查询条件构造器,它通过 Lambda 表达式来引用实体类的属性,从而避免了硬编码字段名。这种方式提高了代码的可读性和可维护性,尤其是在字段名可能发生变化的情况下。
-
LambdaUpdateWrapper:类似于 LambdaQueryWrapper,LambdaUpdateWrapper 是基于 Lambda 表达式的更新条件构造器。它允许你使用 Lambda 表达式来指定更新字段和条件,同样避免了硬编码字段名的问题。
一、功能详解
MyBatis-Plus 的 Wrapper 类是构建复杂查询和更新条件的关键工具。它允许开发者以链式调用的方式构造 SQL 的 WHERE 子句,提供了极大的灵活性和便利性。
以下是对 Wrapper 功能的提示和注意事项。
1. allEq
allEq
方法是 MyBatis-Plus 中用于构建查询条件的方法之一,它允许我们通过一个 Map 来设置多个字段的相等条件。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置所有字段的相等条件,如果字段值为null,则根据null2IsNull参数决定是否设置为IS NULL
allEq(Map<String, Object> params)
allEq(Map<String, Object> params, boolean null2IsNull)
allEq(boolean condition, Map<String, Object> params, boolean null2IsNull)
// 设置所有字段的相等条件,通过filter过滤器决定哪些字段应该被包含,如果字段值为null,则根据null2IsNull参数决定是否设置为IS NULL
allEq(BiPredicate<String, Object> filter, Map<String, Object> params)
allEq(BiPredicate<String, Object> filter, Map<String, Object> params, boolean null2IsNull)
allEq(boolean condition, BiPredicate<String, Object> filter, Map<String, Object> params, boolean null2IsNull)
参数说明
params
:一个Map
,其中 key 是数据库字段名,value
是对应的字段值。null2IsNull
:如果设置为true
,当Map
中的value
为null
时,会调用isNull
方法;如果设置为false
,则会忽略value
为null
的键值对。filter
:一个BiPredicate
,用于过滤哪些字段应该被包含在查询条件中。condition
:一个布尔值,用于控制是否应用这些条件。
示例
普通 Wrapper (QueryWrapper):
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.allEq(Map.of("id", 1, "name", "老王")).eq("age", null);
at java.base/java.util.Objects.requireNonNull(Objects.java:208)
at java.base/java.util.ImmutableCollections$MapN.(ImmutableCollections.java:1186)
at java.base/java.util.Map.of(Map.java:1395)
jdk17中Map.of不能传递null值,这里我们把null值参数拆到了后面使用eq处理,以达到同等效果
Lambda Wrapper (LambdaQueryWrapper):
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.allEq(Map.of(User::getId, 1, User::getName, "老王")).eq(User::getAge, null);
带过滤器的普通 Wrapper (QueryWrapper):
QueryWrapper<User> queryWrapper1 = new QueryWrapper<>();
queryWrapper1.allEq((field, value) -> field.contains("a"), Map.of("id", 1, "name", "老王")).eq( "age", null);
带过滤器的 Lambda Wrapper (LambdaQueryWrapper):
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.allEq((field, value) -> {
LambdaMeta meta = LambdaUtils.extract(field);
String fieldName = PropertyNamer.methodToProperty(meta.getImplMethodName());
System.out.println(fieldName+","+value);
return fieldName.contains("a");
},Map.of(User::getId, 1, User::getName, "老王")).eq(User::getAge, null);
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE id = 1 AND name = '老王' AND age IS NULL
-- 带过滤器的普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE name = '老王' AND age IS NULL
2. eq
eq
方法是 MyBatis-Plus 中用于构建查询条件的基本方法之一,它用于设置单个字段的相等条件。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置指定字段的相等条件
eq(R column, Object val)
// 根据条件设置指定字段的相等条件
eq(boolean condition, R column, Object val)
参数说明
column
:数据库字段名或使用Lambda
表达式的字段名。val
:与字段名对应的值。condition
:一个布尔值,用于控制是否应用这个相等条件。
示例
普通 Wrapper (QueryWrapper):
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("name", "老王");
Lambda Wrapper (LambdaQueryWrapper):
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.eq(User::getName, "老王");
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE name = '老王'
3. ne
ne
方法是 MyBatis-Plus 中用于构建查询条件的基本方法之一,它用于设置单个字段的不相等条件。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置指定字段的不相等条件
ne(R column, Object val)
// 根据条件设置指定字段的不相等条件
ne(boolean condition, R column, Object val)
参数说明
column
:数据库字段名或使用Lambda
表达式的字段名。val
:与字段名对应的值。condition
:一个布尔值,用于控制是否应用这个不相等条件。
示例
普通 Wrapper (QueryWrapper):
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.ne("name", "老王");
Lambda Wrapper (LambdaQueryWrapper):
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.ne(User::getName, "老王");
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE name <> '老王'
4. gt
gt
方法是 MyBatis-Plus 中用于构建查询条件的基本方法之一,它用于设置单个字段的大于条件。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置指定字段的大于条件
gt(R column, Object val)
// 根据条件设置指定字段的大于条件
gt(boolean condition, R column, Object val)
参数说明
column
:数据库字段名或使用 Lambda 表达式的字段名。val
:与字段名对应的值。condition
:一个布尔值,用于控制是否应用这个大于条件。
示例
普通 Wrapper (QueryWrapper):
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.gt("age", 18);
Lambda Wrapper (LambdaQueryWrapper):
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.gt(User::getAge, 18);
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE age > 18
注意事项
gt
方法适用于数值型字段,对于字符串等非数值型字段,使用gt
可能会导致不期望的结果或错误。- 在使用
gt
方法时,确保val
参数的类型与字段类型相匹配,以避免类型转换错误。- 如果需要根据某些条件动态添加大于条件,可以使用带有
condition
参数的重载方法。
5. ge
ge
方法是 MyBatis-Plus 中用于构建查询条件的基本方法之一,它用于设置单个字段的大于等于条件。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置指定字段的大于等于条件
ge(R column, Object val)
// 根据条件设置指定字段的大于等于条件
ge(boolean condition, R column, Object val)
参数说明
column
:数据库字段名或使用Lambda
表达式的字段名。val
:与字段名对应的值。condition
:一个布尔值,用于控制是否应用这个大于等于条件。
示例
普通 Wrapper (QueryWrapper):
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.ge("age", 18);
Lambda Wrapper (LambdaQueryWrapper):
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.ge(User::getAge, 18);
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE age >= 18
注意事项
ge
方法适用于数值型字段,对于字符串等非数值型字段,使用ge
可能会导致不期望的结果或错误。- 在使用
ge
方法时,确保val
参数的类型与字段类型相匹配,以避免类型转换错误。- 如果需要根据某些条件动态添加大于等于条件,可以使用带有
condition
参数的重载方法。
6. lt
lt
方法是 MyBatis-Plus 中用于构建查询条件的基本方法之一,它用于设置单个字段的小于条件。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置指定字段的小于条件
lt(R column, Object val)
// 根据条件设置指定字段的小于条件
lt(boolean condition, R column, Object val)
参数说明
column
:数据库字段名或使用Lambda
表达式的字段名。val
:与字段名对应的值。condition
:一个布尔值,用于控制是否应用这个小于条件。
示例
普通 Wrapper (QueryWrapper):
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.lt("age", 18);
Lambda Wrapper (LambdaQueryWrapper):
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.lt(User::getAge, 18);
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE age < 18
注意事项
lt
方法适用于数值型字段,对于字符串等非数值型字段,使用lt
可能会导致不期望的结果或错误。- 在使用
lt
方法时,确保val
参数的类型与字段类型相匹配,以避免类型转换错误。- 如果需要根据某些条件动态添加小于条件,可以使用带有
condition
参数的重载方法。
7. le
le
方法是 MyBatis-Plus 中用于构建查询条件的基本方法之一,它用于设置单个字段的小于等于条件。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置指定字段的小于等于条件
le(R column, Object val)
// 根据条件设置指定字段的小于等于条件
le(boolean condition, R column, Object val)
参数说明
column
:数据库字段名或使用Lambda
表达式的字段名。val
:与字段名对应的值。condition
:一个布尔值,用于控制是否应用这个小于等于条件。
示例
普通 Wrapper (QueryWrapper):
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.le("age", 18);
Lambda Wrapper (LambdaQueryWrapper):
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.le(User::getAge, 18);
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE age <= 18
注意事项
le
方法适用于数值型字段,对于字符串等非数值型字段,使用le
可能会导致不期望的结果或错误。- 在使用
le
方法时,确保val
参数的类型与字段类型相匹配,以避免类型转换错误。- 如果需要根据某些条件动态添加小于等于条件,可以使用带有
condition
参数的重载方法。
8. between
between
方法是 MyBatis-Plus 中用于构建查询条件的基本方法之一,它用于设置单个字段的 BETWEEN 条件。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置指定字段的 BETWEEN 条件
between(R column, Object val1, Object val2)
// 根据条件设置指定字段的 BETWEEN 条件
between(boolean condition, R column, Object val1, Object val2)
参数说明
column
:数据库字段名或使用Lambda
表达式的字段名。val1
:与字段名对应的第一个值,表示 BETWEEN 条件的起始值。val2
:与字段名对应的第二个值,表示 BETWEEN 条件的结束值。condition
:一个布尔值,用于控制是否应用这个 BETWEEN 条件。
示例
普通 Wrapper (QueryWrapper):
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.between("age", 18, 30);
Lambda Wrapper (LambdaQueryWrapper):
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.between(User::getAge, 18, 30);
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE age BETWEEN 18 AND 30
注意事项
between
方法适用于数值型字段,对于字符串等非数值型字段,使用between
可能会导致不期望的结果或错误。- 在使用
between
方法时,确保val1
和val2
参数的类型与字段类型相匹配,以避免类型转换错误。- 如果需要根据某些条件动态添加 BETWEEN 条件,可以使用带有
condition
参数的重载方法。
9. notBetween
notBetween
方法是 MyBatis-Plus 中用于构建查询条件的另一个基本方法,它用于设置单个字段的 NOT BETWEEN 条件。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置指定字段的 NOT BETWEEN 条件
notBetween(R column, Object val1, Object val2)
// 根据条件设置指定字段的 NOT BETWEEN 条件
notBetween(boolean condition, R column, Object val1, Object val2)
参数说明
column
:数据库字段名或使用Lambda
表达式的字段名。val1
:与字段名对应的第一个值,表示 NOT BETWEEN 条件的起始值。val2
:与字段名对应的第二个值,表示 NOT BETWEEN 条件的结束值。condition
:一个布尔值,用于控制是否应用这个 NOT BETWEEN 条件。
示例
普通 Wrapper (QueryWrapper):
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.notBetween("age", 18, 30);
Lambda Wrapper (LambdaQueryWrapper):
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.notBetween(User::getAge, 18, 30);
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE age NOT BETWEEN 18 AND 30
注意事项
notBetween
方法同样适用于数值型字段,对于字符串等非数值型字段,使用notBetween
可能会导致不期望的结果或错误。- 在使用
notBetween
方法时,确保val1
和val2
参数的类型与字段类型相匹配,以避免类型转换错误。- 如果需要根据某些条件动态添加 NOT BETWEEN 条件,可以使用带有
condition
参数的重载方法。
10. like
like
方法是 MyBatis-Plus 中用于构建模糊查询条件的基本方法之一,它用于设置单个字段的 LIKE 条件。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置指定字段的 LIKE 条件
like(R column, Object val)
// 根据条件设置指定字段的 LIKE 条件
like(boolean condition, R column, Object val)
参数说明
column
:数据库字段名或使用Lambda
表达式的字段名。val
:与字段名对应的值,表示 LIKE 条件中的搜索值。condition
:一个布尔值,用于控制是否应用这个 LIKE 条件。
示例
普通 Wrapper (QueryWrapper):
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.like("name", "王");
Lambda Wrapper (LambdaQueryWrapper):
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.like(User::getName, "王");
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE name LIKE '%王%'
注意事项
like
方法适用于字符串类型的字段,用于模糊匹配。- 默认情况下,
like
方法会在搜索值前后添加%
,实现全模糊匹配。如果需要左模糊或右模糊匹配,可以使用likeLeft
或likeRight
方法。- 在使用
like
方法时,确保val
参数的类型是字符串,以避免类型转换错误。- 如果需要根据某些条件动态添加 LIKE 条件,可以使用带有
condition
参数的重载方法。
11. notLike
notLike
方法是 MyBatis-Plus 中用于构建模糊查询条件的另一个基本方法,它用于设置单个字段的 NOT LIKE 条件。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置指定字段的 NOT LIKE 条件
notLike(R column, Object val)
// 根据条件设置指定字段的 NOT LIKE 条件
notLike(boolean condition, R column, Object val)
参数说明
column
:数据库字段名或使用Lambda
表达式的字段名。val
:与字段名对应的值,表示 NOT LIKE 条件中的搜索值。condition
:一个布尔值,用于控制是否应用这个 NOT LIKE 条件。
示例
普通 Wrapper (QueryWrapper):
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.notLike("name", "王");
Lambda Wrapper (LambdaQueryWrapper):
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.notLike(User::getName, "王");
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE name NOT LIKE '%王%'
注意事项
notLike
方法适用于字符串类型的字段,用于排除特定的模糊匹配。- 默认情况下,
notLike
方法会在搜索值前后添加%
,实现全模糊排除。如果需要排除左模糊或排除右模糊匹配,可以使用notLikeLeft
或notLikeRight
方法。- 在使用
notLike
方法时,确保val
参数的类型是字符串,以避免类型转换错误。- 如果需要根据某些条件动态添加 NOT LIKE 条件,可以使用带有
condition
参数的重载方法。
12. likeLeft
likeLeft
方法是 MyBatis-Plus 中用于构建模糊查询条件的基本方法之一,它用于设置单个字段的左模糊匹配条件。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置指定字段的左模糊匹配条件
likeLeft(R column, Object val)
// 根据条件设置指定字段的左模糊匹配条件
likeLeft(boolean condition, R column, Object val)
参数说明
column
:数据库字段名或使用Lambda
表达式的字段名。val
:与字段名对应的值,表示左模糊匹配条件中的搜索值。condition
:一个布尔值,用于控制是否应用这个左模糊匹配条件。
示例
普通 Wrapper (QueryWrapper):
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.likeLeft("name", "王");
Lambda Wrapper (LambdaQueryWrapper):
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.likeLeft(User::getName, "王");
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE name LIKE '%王'
注意事项
likeLeft
方法适用于字符串类型的字段,用于左模糊匹配,即匹配以指定字符串开头的记录。- 默认情况下,
likeLeft
方法会在搜索值前添加%
,实现左模糊匹配。如果需要全模糊或右模糊匹配,可以使用like
或likeRight
方法。- 在使用
likeLeft
方法时,确保val
参数的类型是字符串,以避免类型转换错误。- 如果需要根据某些条件动态添加左模糊匹配条件,可以使用带有
condition
参数的重载方法。
通过上述优化,likeLeft
方法的文档更加清晰地展示了其用法、参数说明、示例以及注意事项,使得开发者能够更容易理解和正确使用该方法。
13. likeRight
likeRight
方法是 MyBatis-Plus 中用于构建模糊查询条件的基本方法之一,它用于设置单个字段的右模糊匹配条件。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置指定字段的右模糊匹配条件
likeRight(R column, Object val)
// 根据条件设置指定字段的右模糊匹配条件
likeRight(boolean condition, R column, Object val)
参数说明
column
:数据库字段名或使用Lambda
表达式的字段名。val
:与字段名对应的值,表示右模糊匹配条件中的搜索值。condition
:一个布尔值,用于控制是否应用这个右模糊匹配条件。
示例
普通 Wrapper (QueryWrapper):
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.likeRight("name", "王");
Lambda Wrapper (LambdaQueryWrapper):
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.likeRight(User::getName, "王");
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE name LIKE '王%'
注意事项
likeRight
方法适用于字符串类型的字段,用于右模糊匹配,即匹配以指定字符串结尾的记录。- 默认情况下,
likeRight
方法会在搜索值后添加%
,实现右模糊匹配。如果需要全模糊或左模糊匹配,可以使用like
或likeLeft
方法。- 在使用
likeRight
方法时,确保val
参数的类型是字符串,以避免类型转换错误。- 如果需要根据某些条件动态添加右模糊匹配条件,可以使用带有
condition
参数的重载方法。
14. notLikeLeft
notLikeLeft
方法是 MyBatis-Plus 中用于构建模糊查询条件的另一个基本方法,它用于设置单个字段的非左模糊匹配条件。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置指定字段的非左模糊匹配条件
notLikeLeft(R column, Object val)
// 根据条件设置指定字段的非左模糊匹配条件
notLikeLeft(boolean condition, R column, Object val)
参数说明
column
:数据库字段名或使用Lambda
表达式的字段名。val
:与字段名对应的值,表示非左模糊匹配条件中的搜索值。condition
:一个布尔值,用于控制是否应用这个非左模糊匹配条件。
示例
普通 Wrapper (QueryWrapper):
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.notLikeLeft("name", "王");
Lambda Wrapper (LambdaQueryWrapper):
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.notLikeLeft(User::getName, "王");
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE name NOT LIKE '%王'
注意事项
notLikeLeft
方法适用于字符串类型的字段,用于排除以指定字符串开头的记录。- 默认情况下,
notLikeLeft
方法会在搜索值前添加%
,实现非左模糊匹配。如果需要排除全模糊或右模糊匹配,可以使用notLike
或notLikeRight
方法。- 在使用
notLikeLeft
方法时,确保val
参数的类型是字符串,以避免类型转换错误。- 如果需要根据某些条件动态添加非左模糊匹配条件,可以使用带有
condition
参数的重载方法。
15. notLikeRight
notLikeRight
方法是 MyBatis-Plus 中用于构建模糊查询条件的另一个基本方法,它用于设置单个字段的非右模糊匹配条件。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置指定字段的非右模糊匹配条件
notLikeRight(R column, Object val)
// 根据条件设置指定字段的非右模糊匹配条件
notLikeRight(boolean condition, R column, Object val)
参数说明
column
:数据库字段名或使用Lambda
表达式的字段名。val
:与字段名对应的值,表示非右模糊匹配条件中的搜索值。condition
:一个布尔值,用于控制是否应用这个非右模糊匹配条件。
示例
普通 Wrapper (QueryWrapper):
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.notLikeRight("name", "王");
Lambda Wrapper (LambdaQueryWrapper):
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.notLikeRight(User::getName, "王");
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE name NOT LIKE '王%'
注意事项
notLikeRight
方法适用于字符串类型的字段,用于排除以指定字符串结尾的记录。- 默认情况下,
notLikeRight
方法会在搜索值后添加%
,实现非右模糊匹配。如果需要排除全模糊或左模糊匹配,可以使用notLike
或notLikeLeft
方法。- 在使用
notLikeRight
方法时,确保val
参数的类型是字符串,以避免类型转换错误。- 如果需要根据某些条件动态添加非右模糊匹配条件,可以使用带有
condition
参数的重载方法。
通过上述优化,notLikeRight
方法的文档更加清晰地展示了其用法、参数说明、示例以及注意事项,使得开发者能够更容易理解和正确使用该方法。
16. isNull
isNull
方法是 MyBatis-Plus 中用于构建查询条件的基本方法之一,它用于设置单个字段的 IS NULL 条件。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置指定字段的 IS NULL 条件
isNull(R column)
// 根据条件设置指定字段的 IS NULL 条件
isNull(boolean condition, R column)
参数说明
column
:数据库字段名或使用Lambda
表达式的字段名。condition
:一个布尔值,用于控制是否应用这个 IS NULL 条件。
示例
普通 Wrapper (QueryWrapper):
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.isNull("name");
Lambda Wrapper (LambdaQueryWrapper):
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.isNull(User::getName);
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE name IS NULL
注意事项
isNull
方法适用于所有类型的字段,用于查询字段值为 NULL 的记录。- 在使用
isNull
方法时,确保column
参数正确指向了数据库中的字段名或使用Lambda
表达式的字段名。- 如果需要根据某些条件动态添加 IS NULL 条件,可以使用带有
condition
参数的重载方法。
17. in
in
方法是 MyBatis-Plus 中用于构建查询条件的基本方法之一,它用于设置单个字段的 IN 条件,即字段的值在给定的集合中。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置指定字段的 IN 条件,使用集合、
in(R column, Collection<?> value)
in(boolean condition, R column, Collection<?> value)
// 设置指定字段的 IN 条件,使用可变参数
in(R column, Object... values)
in(boolean condition, R column, Object... values)
参数说明
column
:数据库字段名或使用Lambda
表达式的字段名。value
:一个集合,包含 IN 条件中字段可能的值。values
:一个可变参数列表,包含 IN 条件中字段可能的值。condition
:一个布尔值,用于控制是否应用这个 IN 条件。
示例
普通 Wrapper (QueryWrapper):
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.in("age", Arrays.asList(1, 2, 3));
Lambda Wrapper (LambdaQueryWrapper):
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.in(User::getAge, Arrays.asList(1, 2, 3));
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE age IN (1, 2, 3)
注意事项
in
方法适用于所有类型的字段,用于查询字段值在给定集合中的记录。- 在使用
in
方法时,确保column
参数正确指向了数据库中的字段名或使用Lambda
表达式的字段名。- 如果需要根据某些条件动态添加 IN 条件,可以使用带有
condition
参数的重载方法。
18. notIn
notIn
方法是 MyBatis-Plus 中用于构建查询条件的基本方法之一,它用于设置单个字段的 NOT IN 条件,即字段的值不在给定的集合中。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置指定字段的 NOT IN 条件,使用集合
notIn(R column, Collection<?> value)
notIn(boolean condition, R column, Collection<?> value)
// 设置指定字段的 NOT IN 条件,使用可变参数
notIn(R column, Object... values)
notIn(boolean condition, R column, Object... values)
参数说明
column
:数据库字段名或使用Lambda
表达式的字段名。value
:一个集合,包含 NOT IN 条件中字段可能的值。values
:一个可变参数列表,包含 NOT IN 条件中字段可能的值。condition
:一个布尔值,用于控制是否应用这个 NOT IN 条件。
示例
普通 Wrapper (QueryWrapper):
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.notIn("age", Arrays.asList(1, 2, 3));
Lambda Wrapper (LambdaQueryWrapper):
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.notIn(User::getAge, Arrays.asList(1, 2, 3));
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE age NOT IN (1, 2, 3)
注意事项
notIn
方法适用于所有类型的字段,用于查询字段值不在给定集合中的记录。- 在使用
notIn
方法时,确保column
参数正确指向了数据库中的字段名或使用Lambda
表达式的字段名。- 如果需要根据某些条件动态添加 NOT IN 条件,可以使用带有
condition
参数的重载方法。
19. inSql
inSql
方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一,它用于设置单个字段的 IN 条件,但与 in
方法不同的是,inSql
允许你直接使用 SQL 语句来生成 IN 子句中的值集合。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置指定字段的 IN 条件,使用 SQL 语句
inSql(R column, String sqlValue)
inSql(boolean condition, R column, String sqlValue)
参数说明
column
:数据库字段名或使用Lambda
表达式的字段名。sqlValue
:一个字符串,包含用于生成 IN 子句中值集合的 SQL 语句。condition
:一个布尔值,用于控制是否应用这个 IN 条件。
示例
普通 Wrapper (QueryWrapper):
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.inSql("age", "1,2,3,4,5,6");
Lambda Wrapper (LambdaQueryWrapper):
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.inSql(User::getAge, "1,2,3,4,5,6");
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE age IN (1, 2, 3, 4, 5, 6)
使用子查询的示例:
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.inSql("id", "select id from other_table where id < 3");
生成的 SQL
SELECT * FROM user WHERE id IN (select id from other_table where id < 3)
注意事项
inSql
方法允许你使用 SQL 语句来生成 IN 子句中的值集合,这为复杂的查询条件提供了灵活性。- 在使用
inSql
方法时,确保column
参数正确指向了数据库中的字段名或使用Lambda
表达式的字段名。sqlValue
参数应该是一个有效的 SQL 语句,它将直接嵌入到生成的 SQL 中,因此需要确保其安全性和正确性,应避免 SQL 由前端动态参数传入并直接引用。- 如果需要根据某些条件动态添加 IN 条件,可以使用带有
condition
参数的重载方法。
20. notInSql
notInSql
方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一,它用于设置单个字段的 NOT IN 条件,但与 notIn
方法不同的是,notInSql
允许你直接使用 SQL 语句来生成 NOT IN 子句中的值集合。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置指定字段的 NOT IN 条件,使用 SQL 语句
notInSql(R column, String sqlValue)
notInSql(boolean condition, R column, String sqlValue)
参数说明
column
:数据库字段名或使用Lambda
表达式的字段名。sqlValue
:一个字符串,包含用于生成 NOT IN 子句中值集合的 SQL 语句。condition
:一个布尔值,用于控制是否应用这个 NOT IN 条件。
示例
普通 Wrapper (QueryWrapper):
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.notInSql("age", "1,2,3,4,5,6");
Lambda Wrapper (LambdaQueryWrapper):
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.notInSql(User::getAge, "1,2,3,4,5,6");
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE age NOT IN (1, 2, 3, 4, 5, 6)
使用子查询的示例:
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.notInSql("id", "select id from other_table where id < 3");
生成的 SQL
SELECT * FROM user WHERE id NOT IN (select id from user where id < 3)
注意事项
notInSql
方法允许你使用 SQL 语句来生成 NOT IN 子句中的值集合,这为复杂的查询条件提供了灵活性。- 在使用
notInSql
方法时,确保column
参数正确指向了数据库中的字段名或使用Lambda
表达式的字段名。sqlValue
参数应该是一个有效的 SQL 语句,它将直接嵌入到生成的 SQL 中,因此需要确保其安全性和正确性,应避免 SQL 由前端动态参数传入并直接引用。- 如果需要根据某些条件动态添加 NOT IN 条件,可以使用带有
condition
参数的重载方法。
21. eqSqlSince 3.5.6
eqSql
方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一,允许你设置一个字段等于(EQ)某个 SQL 语句的结果。这个方法特别适用于需要将字段值与子查询结果进行比较的场景。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置指定字段等于 SQL 语句的结果
eqSql(R column, String inValue)
// 在条件满足时设置指定字段等于 SQL 语句的结果
eqSql(boolean condition, R column, String inValue)
参数说明
column
:数据库字段名或使用Lambda
表达式的字段名。inValue
:一个字符串,包含用于生成等于条件的 SQL 语句。condition
:一个布尔值,用于控制是否应用这个等于条件。
示例
普通 Wrapper (QueryWrapper):
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.eqSql("id", "select MAX(id) from user");
Lambda Wrapper (LambdaQueryWrapper):
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.eqSql(User::getId, "select MAX(id) from user");
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE id = (select MAX(id) from user)
注意事项
eqSql
方法允许你将字段值与 SQL 语句的结果进行比较,这为复杂的查询条件提供了灵活性。- 在使用
eqSql
方法时,确保column
参数正确指向了数据库中的字段名或使用Lambda
表达式的字段名。inValue
参数应该是一个有效的 SQL 语句,它将直接嵌入到生成的 SQL 中,因此需要确保其安全性和正确性,应避免 SQL 由前端动态参数传入并直接引用。- 如果需要根据某些条件动态添加等于条件,可以使用带有
condition
参数的重载方法。
22. gtSql Since 3.4.3.2
gtSql
方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一,允许你设置一个字段大于(GT)某个 SQL 语句的结果。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置指定字段大于 SQL 语句的结果
gtSql(R column, String inValue)
// 在条件满足时设置指定字段大于 SQL 语句的结果
gtSql(boolean condition, R column, String inValue)
参数说明
column
:数据库字段名或使用Lambda
表达式的字段名。inValue
:一个字符串,包含用于生成大于条件的 SQL 语句。condition
:一个布尔值,用于控制是否应用这个大于条件。
示例
普通 Wrapper (QueryWrapper):
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.gtSql("id", "select id from user where name = 'xx'");
Lambda Wrapper (LambdaQueryWrapper):
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.gtSql(User::getId, "select id from user where name = 'xx'");
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE id > (select id from user where name = 'xx')
注意事项
gtSql
方法允许你将字段值与 SQL 语句的结果进行比较,这为复杂的查询条件提供了灵活性。- 在使用
gtSql
方法时,确保column
参数正确指向了数据库中的字段名或使用Lambda
表达式的字段名。inValue
参数应该是一个有效的 SQL 语句,它将直接嵌入到生成的 SQL 中,因此需要确保其安全性和正确性,应避免 SQL 由前端动态参数传入并直接引用。- 如果需要根据某些条件动态添加大于条件,可以使用带有
condition
参数的重载方法。
23. geSql Since 3.4.3.2
geSql
方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一,允许你设置一个字段大于等于(GE)某个 SQL 语句的结果。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置指定字段大于等于 SQL 语句的结果
geSql(R column, String inValue)
// 在条件满足时设置指定字段大于等于 SQL 语句的结果
geSql(boolean condition, R column, String inValue)
参数说明
column
:数据库字段名或使用Lambda
表达式的字段名。inValue
:一个字符串,包含用于生成大于等于条件的 SQL 语句。condition
:一个布尔值,用于控制是否应用这个大于等于条件。
示例
普通 Wrapper (QueryWrapper):
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.geSql("id", "select id from user where name = 'xx'");
Lambda Wrapper (LambdaQueryWrapper):
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.geSql(User::getId, "select id from user where name = 'xx'");
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE id >= (select id from user where name = 'xx')
注意事项
geSql
方法允许你将字段值与 SQL 语句的结果进行比较,这为复杂的查询条件提供了灵活性。- 在使用
geSql
方法时,确保column
参数正确指向了数据库中的字段名或使用Lambda
表达式的字段名。inValue
参数应该是一个有效的 SQL 语句,它将直接嵌入到生成的 SQL 中,因此需要确保其安全性和正确性,应避免 SQL 由前端动态参数传入并直接引用。- 如果需要根据某些条件动态添加大于等于条件,可以使用带有
condition
参数的重载方法。
24. ltSql Since 3.4.3.2
ltSql
方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一,允许你设置一个字段小于(LT)某个 SQL 语句的结果。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置指定字段小于 SQL 语句的结果
ltSql(R column, String inValue)
// 在条件满足时设置指定字段小于 SQL 语句的结果
ltSql(boolean condition, R column, String inValue)
参数说明
column
:数据库字段名或使用Lambda
表达式的字段名。inValue
:一个字符串,包含用于生成小于条件的 SQL 语句。condition
:一个布尔值,用于控制是否应用这个小于条件。
示例
普通 Wrapper (QueryWrapper):
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.ltSql("id", "select id from user where name = 'xx'");
Lambda Wrapper (LambdaQueryWrapper):
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.ltSql(User::getId, "select id from user where name = 'xx'");
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE id < (select id from user where name = 'xx')
注意事项
ltSql
方法允许你将字段值与 SQL 语句的结果进行比较,这为复杂的查询条件提供了灵活性。- 在使用
ltSql
方法时,确保column
参数正确指向了数据库中的字段名或使用Lambda
表达式的字段名。inValue
参数应该是一个有效的 SQL 语句,它将直接嵌入到生成的 SQL 中,因此需要确保其安全性和正确性,应避免 SQL 由前端动态入并直接引用。- 如果需要根据某些条件动态添加小于条件,可以使用带有
condition
参数的重载方法。
25. leSql Since 3.4.3.2
leSql
方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一,允许你设置一个字段小于等于(LE)某个 SQL 语句的结果。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置指定字段小于等于 SQL 语句的结果
leSql(R column, String inValue)
// 在条件满足时设置指定字段小于等于 SQL 语句的结果
leSql(boolean condition, R column, String inValue)
参数说明
column
:数据库字段名或使用Lambda
表达式的字段名。inValue
:一个字符串,包含用于生成小于等于条件的 SQL 语句。condition
:一个布尔值,用于控制是否应用这个小于等于条件。
示例
普通 Wrapper (QueryWrapper):
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.leSql("id", "select id from user where name = 'xx'");
Lambda Wrapper (LambdaQueryWrapper):
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.leSql(User::getId, "select id from user where name = 'xx'");
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE id <= (select id from user where name = 'xx')
注意事项
leSql
方法允许你将字段值与 SQL 语句的结果进行比较,这为复杂的查询条件提供了灵活性。- 在使用
leSql
方法时,确保column
参数正确指向了数据库中的字段名或使用Lambda
表达式的字段名。inValue
参数应该是一个有效的 SQL 语句,它将直接嵌入到生成的 SQL 中,因此需要确保其安全性和正确性,应避免 SQL 由前端动态参数传入并直接引用。- 如果需要根据某些条件动态添加小于等于条件,可以使用带有
condition
参数的重载方法。
26. groupBy
groupBy
方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一,它用于设置查询结果的分组条件。通过指定一个或多个字段,groupBy 方法可以生成 SQL 语句中的 GROUP BY 子句。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置分组条件,使用字段名
groupBy(R... columns)
groupBy(boolean condition, R... columns)
参数说明
columns
:一个可变参数列表,包含用于分组的字段名。condition
:一个布尔值,用于控制是否应用这个分组条件。
示例
普通 Wrapper (QueryWrapper):
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.groupBy("id", "name");
Lambda Wrapper (LambdaQueryWrapper):
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.groupBy(User::getId, User::getName);
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user GROUP BY id, name
注意事项
groupBy
方法适用于需要对查询结果进行分组的场景。- 在使用
groupBy
方法时,确保columns
参数正确指向了数据库中的字段名或使用Lambda
表达式的字段名。- 如果需要根据某些条件动态添加分组条件,可以使用带有
condition
参数的重载方法。
27. orderByAsc
orderByAsc
方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一,它用于设置查询结果的升序排序条件。通过指定一个或多个字段,orderByAsc
方法可以生成 SQL 语句中的 ORDER BY 子句,并指定升序排序。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置升序排序条件,使用字段名
orderByAsc(R... columns)
orderByAsc(boolean condition, R... columns)
参数说明
columns
:一个可变参数列表,包含用于排序的字段名。condition
:一个布尔值,用于控制是否应用这个排序条件。
示例
普通 Wrapper (QueryWrapper):
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.orderByAsc("id", "name");
Lambda Wrapper (LambdaQueryWrapper):
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.orderByAsc(User::getId, User::getName);
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user ORDER BY id ASC, name ASC
注意事项
orderByAsc
方法适用于需要对查询结果进行升序排序的场景。- 在使用
orderByAsc
方法时,确保columns
参数正确指向了数据库中的字段名或使用Lambda
表达式的字段名。- 如果需要根据某些条件动态添加排序条件,可以使用带有
condition
参数的重载方法。
28. orderByDesc
orderByDesc
方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一,它用于设置查询结果的降序排序条件。通过指定一个或多个字段,orderByDesc
方法可以生成 SQL 语句中的 ORDER BY 子句,并指定降序排序。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置降序排序条件,使用字段名
orderByDesc(R... columns)
orderByDesc(boolean condition, R... columns)
参数说明
columns
:一个可变参数列表,包含用于排序的字段名。condition
:一个布尔值,用于控制是否应用这个排序条件。
示例
普通 Wrapper (QueryWrapper):
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.orderByDesc("id", "name");
Lambda Wrapper (LambdaQueryWrapper):
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.orderByDesc(User::getId, User::getName);
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user ORDER BY id DESC, name DESC
注意事项
orderByDesc
方法适用于需要对查询结果进行降序排序的场景。- 在使用
orderByDesc
方法时,确保columns
参数正确指向了数据库中的字段名或使用Lambda
表达式的字段名。- 如果需要根据某些条件动态添加排序条件,可以使用带有
condition
参数的重载方法。
29. orderBy
orderBy
方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一,它用于设置查询结果的排序条件。通过指定一个或多个字段以及排序方向(升序或降序),orderBy
方法可以生成 SQL 语句中的 ORDER BY 子句。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置排序条件,使用字段名和排序方向
orderBy(boolean condition, boolean isAsc, R... columns)
参数说明
condition
:一个布尔值,用于控制是否应用这个排序条件。isAsc
:一个布尔值,表示排序方向。true 表示升序(ASC),false 表示降序(DESC)。columns
:一个可变参数列表,包含用于排序的字段名。
示例
普通 Wrapper (QueryWrapper):
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.orderBy(true, true, "id", "name");
Lambda Wrapper (LambdaQueryWrapper):
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.orderBy(true, true, User::getId, User::getName);
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user ORDER BY id ASC, name ASC
注意事项
orderBy
方法提供了更灵活的排序设置,允许开发者指定排序方向。- 在使用
orderBy
方法时,确保columns
参数正确指向了数据库中的字段名或使用Lambda
表达式的字段名。- 如果需要根据某些条件动态添加排序条件,可以使用带有
condition
参数的重载方法。- 排序可以应用于查询结果的展示,也可以用于优化查询性能,例如通过排序来减少需要扫描的数据量。
30. having
having
方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一,它用于设置 HAVING 子句,通常与 GROUP BY 一起使用,用于对分组后的数据进行条件筛选。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置 HAVING 子句,使用 SQL 语句和参数
having(String sqlHaving, Object... params)
having(boolean condition, String sqlHaving, Object... params)
参数说明
sqlHaving
:一个字符串,包含用于生成 HAVING 子句的 SQL 语句。params
:一个可变参数列表,包含 SQL 语句中占位符的替换值。condition
:一个布尔值,用于控制是否应用这个 HAVING 条件。
示例
普通 Wrapper (QueryWrapper):
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.groupBy("age").having("sum(age) > 10");
Lambda Wrapper (LambdaQueryWrapper):
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.groupBy(User::getAge).having("sum(age) > {0}", 10);
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user GROUP BY age HAVING sum(age) > 10
注意事项
having
方法通常与groupBy
方法一起使用,用于对分组后的数据进行进一步的筛选。- 在使用
having
方法时,确保sqlHaving
参数是一个有效的 SQL 语句,它将直接嵌入到生成的 SQL 中,因此需要确保其安全性和正确性,应避免 SQL 由前端动态参数传入并直接引用。params
参数用于替换sqlHaving
中的占位符,确保提供的参数类型和数量与占位符匹配。- 如果需要根据某些条件动态添加 HAVING 条件,可以使用带有
condition
参数的重载方法。
31. func
func
方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一,它提供了一种在链式调用中根据条件执行不同查询操作的机制。通过传入一个 Consumer 函数式接口,func
方法允许你在不中断链式调用的情况下,根据条件执行不同的查询构建逻辑。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 根据条件执行不同的查询构建逻辑
func(Consumer<Children> consumer)
func(boolean condition, Consumer<Children> consumer)
参数说明
consumer
:一个Consumer
函数式接口,它接受一个Children
类型的参数,并可以调用Children
对象上的方法来构建查询条件。condition
:一个布尔值,用于控制是否应用这个Consumer
逻辑。
示例
普通 Wrapper (QueryWrapper):
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.func(i -> {
if (true) {
i.eq("id", 1);
} else {
i.ne("id", 1);
}
});
Lambda Wrapper (LambdaQueryWrapper):
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.func(i -> {
if (true) {
i.eq(User::getId, 1);
} else {
i.ne(User::getId, 1);
}
});
生成的 SQL
-- 根据条件生成的 SQL 会有所不同
-- 如果条件为 true,则生成的 SQL 为:
SELECT * FROM user WHERE id = 1
-- 如果条件为 false,则生成的 SQL 为:
SELECT * FROM user WHERE id != 1
注意事项
func
方法提供了一种灵活的方式来根据条件动态构建查询条件,而不需要中断链式调用。- 在使用
func
方法时,确保Consumer
函数式接口中的逻辑正确构建了所需的查询条件。condition
参数用于控制是否应用Consumer
逻辑,这允许你根据某些条件动态添加查询条件。- 由于
func
方法允许执行复杂的逻辑,因此在使用时需要特别注意代码的可读性和维护性。
32. or
or
方法是 MyBatis-Plus 中用于构建查询条件的基本方法之一,它用于在查询条件中添加 OR 逻辑。通过调用 or
方法,可以改变后续查询条件的连接方式,从默认的 AND 连接变为 OR 连接。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 改变后续查询条件的连接方式为 OR
or()
or(boolean condition)
// 添加 OR 嵌套条件
or(Consumer<Param> consumer)
or(boolean condition, Consumer<Param> consumer)
参数说明
condition
:一个布尔值,用于控制是否应用这个 OR 逻辑。consumer
:一个Consumer
函数式接口,它接受一个Param
类型的参数,并可以调用Param
对象上的方法来构建 OR 嵌套条件。
示例
普通 Wrapper (QueryWrapper):
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("id", 1).or().eq("name", "老王");
Lambda Wrapper (LambdaQueryWrapper):
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.eq(User::getId, 1).or().eq(User::getName, "老王");
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE id = 1 OR name = '老王'
OR 嵌套示例:
// 普通 Wrapper
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.or(i -> i.and(j -> j.eq("name", "李白").eq("status", "alive"))
.or(j -> j.eq("name", "杜甫").eq("status", "alive")));
// Lambda Wrapper
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.or(i -> i.and(j -> j.eq(User::getName, "李白").eq(User::getStatus, "alive"))
.or(j -> j.eq(User::getName, "杜甫").eq(User::getStatus, "alive")));
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE (name = '李白' AND status = 'alive') OR (name = '杜甫' AND status = 'alive')
注意事项
- 主动调用
or
方法表示紧接着下一个查询条件方法不是用and
连接,而是用or
连接。- 如果不调用
or
方法,则默认使用and
连接查询条件。or
方法可以嵌套使用,通过传入Consumer
函数式接口来构建复杂的 OR 嵌套条件。- 在使用
or
方法时,确保condition
参数正确控制了 OR 逻辑的应用。or
方法的嵌套使用可以构建复杂的查询逻辑,但需要注意代码的可读性和维护性。
33. and
and
方法是 MyBatis-Plus 中用于构建查询条件的基本方法之一,它用于在查询条件中添加 AND 逻辑。通过调用 and
方法,可以创建 AND 嵌套条件,即在一个 AND 逻辑块中包含多个查询条件。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 添加 AND 嵌套条件
and(Consumer<Param> consumer)
and(boolean condition, Consumer<Param> consumer)
参数说明
consumer
:一个Consumer
函数式接口,它接受一个Param
类型的参数,并可以调用Param
对象上的方法来构建 AND 嵌套条件。condition
:一个布尔值,用于控制是否应用这个 AND 嵌套逻辑。
示例
普通 Wrapper (QueryWrapper):
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.and(i -> i.and(j -> j.eq("name", "李白").eq("status", "alive"))
.and(j -> j.eq("name", "杜甫").eq("status", "alive")));
Lambda Wrapper (LambdaQueryWrapper):
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.and(i -> i.and(j -> j.eq(User::getName, "李白").eq(User::getStatus, "alive"))
.and(j -> j.eq(User::getName, "杜甫").eq(User::getStatus, "alive")));
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE ((name = '李白' AND status = 'alive') AND (name = '杜甫' AND status = 'alive'))
注意事项
and
方法的嵌套使用可以构建复杂的查询逻辑,其中 AND 条件可以包含多个查询条件。- 在使用
and
方法的嵌套功能时,确保Consumer
函数式接口中的逻辑正确构建了所需的查询条件。condition
参数用于控制是否应用Consumer
逻辑,这允许你根据某些条件动态添加查询条件。- 由于
and
方法的嵌套使用可以执行复杂的逻辑,因此在使用时需要特别注意代码的可读性和维护性。
34. nested
nested
方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一,它用于创建一个独立的查询条件块,不带默认的 AND 或 OR 逻辑。通过调用 nested
方法,可以在查询条件中添加一个嵌套的子句,该子句可以包含多个查询条件,并且可以被外部查询条件通过 AND 或 OR 连接。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 添加一个独立的查询条件块
nested(Consumer<Param> consumer)
nested(boolean condition, Consumer<Param> consumer)
参数说明
consumer
:一个Consumer
函数式接口,它接受一个Param
类型的参数,并可以调用Param
对象上的方法来构建嵌套的查询条件。condition
:一个布尔值,用于控制是否应用这个嵌套逻辑。
示例
普通 Wrapper (QueryWrapper):
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.nested(i -> i.eq("name", "李白").ne("status", "活着"));
Lambda Wrapper (LambdaQueryWrapper):
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.nested(i -> i.eq(User::getName, "李白").ne(User::getStatus, "活着"));
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE (name = '李白' AND status <> '活着')
注意事项
nested
方法创建的查询条件块是一个独立的子句,可以被外部查询条件通过 AND 或 OR 连接。- 在使用
nested
方法时,确保Consumer
函数式接口中的逻辑正确构建了所需的查询条件。condition
参数用于控制是否应用Consumer
逻辑,这允许你根据某些条件动态添加查询条件。- 由于
nested
方法可以执行复杂的逻辑,因此在使用时需要特别注意代码的可读性和维护性。
35. apply
apply
方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一,它允许你直接拼接 SQL 片段到查询条件中。这个方法特别适用于需要使用数据库函数或其他复杂 SQL 构造的场景。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 拼接 SQL 片段
apply(String applySql, Object... params)
apply(boolean condition, String applySql, Object... params)
参数说明
applySql
:一个字符串,包含要拼接的 SQL 片段。params
:一个可变参数列表,包含 SQL 片段中占位符的替换值。condition
:一个布尔值,用于控制是否应用这个 SQL 片段。
示例
普通 Wrapper (QueryWrapper):
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.apply("id = 1");
Lambda Wrapper (LambdaQueryWrapper):
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.apply("id=1");
使用参数占位符的示例:
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper1.apply("id= {0}", "1");
生成的 SQL
-- 普通 Wrapper 生成的 SQL
SELECT * FROM user WHERE id = 1
-- Lambda Wrapper 生成的 SQL
SELECT * FROM user WHERE date_format(dateColumn, '%Y-%m-%d') = '2008-08-08'
-- 使用参数占位符生成的 SQL
SELECT * FROM user WHERE date_format(dateColumn, '%Y-%m-%d') = '2008-08-08'
注意事项
apply
方法可用于拼接包含数据库函数的 SQL 片段。- 动态入参的
params
对应applySql
内部的{index}
部分,这样是不会有 SQL 注入风险的。如果直接将参数拼接到 SQL 中,则会有 SQL 注入风险,故应避免 SQL 由前端动态参数传入并直接引用。- 在使用
apply
方法时,确保 applySql 参数是一个有效的 SQL 片段,并且params
参数正确地替换了占位符。condition
参数用于控制是否应用这个 SQL 片段,这允许你根据某些条件动态添加查询条件。
36. last
last
方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一,它允许你直接在查询的最后添加一个 SQL 片段,而不受 MyBatis-Plus 的查询优化规则影响。这个方法应该谨慎使用,因为它可能会绕过 MyBatis-Plus 的查询优化。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 在查询的最后添加一个 SQL 片段
last(String lastSql)
last(boolean condition, String lastSql)
参数说明
lastSql
:一个字符串,包含要添加到查询最后的 SQL 片段。condition
:一个布尔值,用于控制是否应用这个 SQL 片段。
示例
普通 Wrapper (QueryWrapper):
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.last("limit 1");
Lambda Wrapper (LambdaQueryWrapper):
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.last("limit 1");
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user LIMIT 1
注意事项
last
方法只能调用一次,多次调用将以最后一次为准。- 使用
last
方法会绕过 MyBatis-Plus 的查询优化规则,可能会导致查询效率降低。- 因为
lastSql
参数直接拼接到 SQL 中,所以必须确保输入的 SQL 片段是安全的,即保障lastSql
应该是后端自行控制,而不是动态参数由前端传入。- 在使用
last
方法时,确保 lastSql 参数是一个安全的 SQL 片段,并且condition
参数正确地控制了 SQL 片段的应用。
37. exists
exists
方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一,它用于在查询中添加一个 EXISTS 子查询。通过调用 exists
方法,可以将一个完整的 SQL 子查询作为 EXISTS 条件添加到主查询中。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 添加 EXISTS 子查询
exists(String existsSql)
exists(boolean condition, String existsSql)
参数说明
existsSql
:一个字符串,包含要作为 EXISTS 条件的 SQL 子查询。condition
:一个布尔值,用于控制是否应用这个 EXISTS 条件。
示例
普通 Wrapper (QueryWrapper):
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.exists("select id from user where age = 1");
Lambda Wrapper (LambdaQueryWrapper):
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.exists("select id from user where age = 1");
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE EXISTS (select id from user where age = 1)
注意事项
exists
方法用于添加一个 EXISTS 子查询,这通常用于检查子查询是否返回任何行。- 在使用
exists
方法时,确保existsSql
参数是一个有效的 SQL 子查询,它将直接嵌入到生成的 SQL 中,因此需要确保其安全性和正确性,应避免 SQL 由前端动态参数传入并直接引用。condition
参数用于控制是否应用 EXISTS 条件,这允许你根据某些条件动态添加查询条件。- 由于
exists
方法允许执行复杂的逻辑,因此在使用时需要特别注意代码的可读性和维护性。
38. notExists
notExists
方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一,它用于在查询中添加一个 NOT EXISTS 子查询。通过调用 notExists
方法,可以将一个完整的 SQL 子查询作为 NOT EXISTS 条件添加到主查询中。
使用范围
- QueryWrapper
- LambdaQueryWrapper
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 添加 NOT EXISTS 子查询
notExists(String notExistsSql)
notExists(boolean condition, String notExistsSql)
参数说明
notExistsSql
:一个字符串,包含要作为 NOT EXISTS 条件的 SQL 子查询。condition
:一个布尔值,用于控制是否应用这个 NOT EXISTS 条件。
示例
普通 Wrapper (QueryWrapper):
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.notExists("select id from user where age = 1");
Lambda Wrapper (LambdaQueryWrapper):
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.notExists("select id from user where age = 1");
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE NOT EXISTS (select id from user where age = 1)
注意事项
notExists
方法用于添加一个 NOT EXISTS 子查询,这通常用于检查子查询是否不返回任何行。- 在使用
notExists
方法时,确保notExistsSql
参数是一个有效的 SQL 子查询,它将直接嵌入到生成的 SQL 中,因此需要确保其安全性和正确性,应避免 SQL 由前端动态参数传入并直接引用。condition
参数用于控制是否应用 NOT EXISTS 条件,这允许你根据某些条件动态添加查询条件。- 由于
notExists
方法允许执行复杂的逻辑,因此在使用时需要特别注意代码的可读性和维护性。
39. select
select
方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一,它用于设置查询的字段。通过调用 select
方法,可以指定在查询结果中包含哪些字段,从而实现字段级别的查询定制。
使用范围
- QueryWrapper
- LambdaQueryWrapper
方法签名
// 设置查询字段
select(String... sqlSelect)
// 过滤查询字段(主键除外)
select(Predicate<TableFieldInfo> predicate)
select(Class<T> entityClass, Predicate<TableFieldInfo> predicate)
参数说明
sqlSelect
:一个字符串数组,包含要查询的字段名。predicate
:一个Predicate
函数式接口,用于过滤查询字段。它接受一个TableFieldInfo
类型的参数,并返回一个布尔值,表示是否选择该字段。entityClass
:实体类的类型,用于获取字段信息。
示例
普通 Wrapper (QueryWrapper):
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.select("id", "name", "age");
Lambda Wrapper (LambdaQueryWrapper):
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.select(User::getId, User::getName, User::getAge);
使用 Predicate 过滤字段的示例:
QueryWrapper<User> queryWrapper1 = new QueryWrapper<>(User.class);
queryWrapper.select(i -> i.getProperty().startsWith("test"));
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT id, name, age FROM user
-- 使用 Predicate 过滤字段生成的 SQL
SELECT testField1, testField2 FROM user
注意事项
select
方法分为两类:第一类直接指定要查询的字段名,第二类通过Predicate
过滤字段。- 第二类方法用于过滤查询字段(主键除外),如果入参不包含
entityClass
,则在调用前需要确保wrapper
内的entit
y 属性有值。- 这两类方法重复调用时,以最后一次调用为准。
- 在使用
select
方法时,确保指定的字段名或过滤条件正确,以避免查询结果不符合预期。
40. set
set
方法是 MyBatis-Plus 中用于构建更新操作的高级方法之一,它用于设置更新语句中的 SET 字段。通过调用 set
方法,可以指定在更新操作中要修改的字段及其新值。
使用范围
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置更新语句中的 SET 字段
set(String column, Object val)
set(boolean condition, String column, Object val)
参数说明
column
:一个字符串,表示要更新的字段名。val
:一个对象,表示要更新到字段的新值。condition
:一个布尔值,用于控制是否应用这个 SET 字段。
示例
普通 Wrapper (QueryWrapper):
UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
updateWrapper.set("name", "老李头");
Lambda Wrapper (LambdaQueryWrapper):
LambdaUpdateWrapper<User> lambdaUpdateWrapper = new LambdaUpdateWrapper<>();
lambdaUpdateWrapper.set(User::getName, "老李头");
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
UPDATE user SET name = '老李头'
使用条件控制的示例:
UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
updateWrapper.set(true, "name", "");
生成的 SQL
-- 使用条件控制的 SQL
UPDATE user SET name = ''
注意事项
set
方法用于设置更新语句中的 SET 字段,可以指定要更新的字段及其新值。- 当
val
参数为空字符串时,数据库字段值将变为空字符串。- 当
val
参数为null
时,数据库字段值将变为null
。condition
参数用于控制是否应用这个 SET 字段,这允许你根据某些条件动态添加更新字段。- 在使用
set
方法时,确保column
参数是一个有效的字段名,并且val
参数是一个合适的新值。
41. setSql
setSql
方法是 MyBatis-Plus 中用于构建更新操作的高级方法之一,它允许你直接设置更新语句中的 SET 部分 SQL。通过调用 setSql
方法,可以将一个自定义的 SQL 片段作为 SET 子句添加到更新语句中。
使用范围
- UpdateWrapper
- LambdaUpdateWrapper
方法签名
// 设置更新语句中的 SET 部分 SQL
setSql(String sql)
参数说明
sql
:一个字符串,包含要作为 SET 子句的 SQL 片段。
示例
普通 Wrapper (QueryWrapper):
UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
updateWrapper.setSql("name = '老李头'");
Lambda Wrapper (LambdaQueryWrapper):
LambdaUpdateWrapper<User> lambdaUpdateWrapper = new LambdaUpdateWrapper<>();
lambdaUpdateWrapper.setSql("name = '老李头'");
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
UPDATE user SET name = '老李头'
注意事项
setSql
方法用于设置更新语句中的 SET 部分 SQL,这通常用于需要使用复杂 SQL 构造的场景。- 在使用
setSql
方法时,确保sql
参数是一个有效的 SQL 片段,它将直接嵌入到生成的 SQL 中,因此需要确保其安全性和正确性,应避免 SQL 由前端动态参数传入并直接引用- 由于
setSql
方法允许执行复杂的逻辑,因此在使用时需要特别注意代码的可读性和维护性。
42. setIncrBy Since 3.5.6
setIncrBy
方法是 MyBatis-Plus 中用于更新操作的高级方法之一,它允许你指定一个字段,并使其在数据库中的值增加指定的数值。这个方法特别适用于需要对数值字段进行增量操作的场景。
使用范围
- LambdaUpdateWrapper
方法签名
// 字段自增指定数值
setIncrBy(SFunction<T, ?> column, Number val)
// 在条件满足时字段自增指定数值
setIncrBy(boolean condition, SFunction<T, ?> column, Number val)
参数说明
column
:一个SFunction
对象,表示要自增的字段。val
:一个Number
对象,表示要增加的数值。condition
(可选):一个布尔值,表示是否在满足条件时执行自增操作。
示例
Lambda Wrapper (LambdaQueryWrapper):
LambdaUpdateWrapper<User> lambdaUpdateWrapper = new LambdaUpdateWrapper<>();
lambdaUpdateWrapper.setIncrBy(User::getAge, 1);
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
UPDATE product SET num = num + 1
注意事项
setIncrBy
方法用于对指定字段进行自增操作,这通常用于需要对数值字段进行增量更新的场景。- 在使用
setIncrBy
方法时,确保column
参数是一个有效的字段表达式,val
参数是一个有效的数值。- 如果提供了
condition
参数,则只有在条件为true
时才会执行自增操作。
43. setDecrBy
setDecrBy
方法是 MyBatis-Plus 中用于更新操作的高级方法之一,它允许你指定一个字段,并使其在数据库中的值减少指定的数值。这个方法特别适用于需要对数值字段进行减量操作的场景。
使用范围
- LambdaUpdateWrapper
方法签名
// 字段自减指定数值
setDecrBy(SFunction<T, ?> column, Number val)
// 在条件满足时字段自减指定数值
setDecrBy(boolean condition, SFunction<T, ?> column, Number val)
参数说明
column
:一个SFunction
对象,表示要自减的字段。val
:一个Number
对象,表示要减少的数值。condition
(可选):一个布尔值,表示是否在满足条件时执行自减操作。
示例
Lambda Wrapper (LambdaQueryWrapper):
LambdaUpdateWrapper<User> lambdaUpdateWrapper = new LambdaUpdateWrapper<>();
lambdaUpdateWrapper.setDecrBy(User::getAge, 1);
生成的 SQL
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
UPDATE product SET num = num - 1
注意事项
setDecrBy
方法用于对指定字段进行自减操作,这通常用于需要对数值字段进行减量更新的场景。- 在使用
setDecrBy
方法时,确保column
参数是一个有效的字段表达式,val
参数是一个有效的数值。- 如果提供了
condition
参数,则只有在条件为true
时才会执行自减操作。
44. lambda
lambda
方法是一个便捷的方法,它允许你从 QueryWrapper
或 UpdateWrapper
对象中获取对应的 LambdaQueryWrapper
或 LambdaUpdateWrapper
对象。这样,你就可以使用 Lambda
表达式来构建查询或更新条件,使得代码更加简洁和类型安全。
使用范围
- QueryWrapper
- UpdateWrapper
方法签名
// 获取 Lamdba Wrapper
lambda();
示例
从 QueryWrapper 获取 LambdaQueryWrapper:
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
LambdaQueryWrapper<User> lambdaQueryWrapper = queryWrapper.lambda();
// 使用 Lambda 表达式构建查询条件
lambdaQueryWrapper.eq(User::getName, "张三");
从 UpdateWrapper 获取 LambdaUpdateWrapper:
UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
LambdaUpdateWrapper<User> lambdaUpdateWrapper = updateWrapper.lambda();
// 使用 Lambda 表达式构建更新条件
lambdaUpdateWrapper.set(User::getName, "李四");
说明
lambda
方法返回一个LambdaWrapper
对象,具体类型取决于调用它的Wrapper
类型。- 在
QueryWrapper
上调用lambda
方法将返回一个LambdaQueryWrapper
。 - 在
UpdateWrapper
上调用 lambda
方法将返回一个LambdaUpdateWrapper
。 - 使用
Lambda
表达式可以避免直接使用字符串来指定字段名,从而减少错误并提高代码的可读性。
注意事项
- 在使用
lambda
方法时,确保你已经正确地初始化了QueryWrapper
或UpdateWrapper
对象。- 一旦获取了
LambdaWrapper
对象,你就可以使用Lambda
表达式来构建查询或更新条件,这将使得代码更加类型安全和易于维护。
总结
大家不要看内容很多就学不下去了,其实很多都是相关联的,你会了一个,再看其他的可能看一眼就明白它的作用了;
比如说:like、notLike、likeLeft、likeRight、notLikeLeft、notLikeRight,这一系列的api都是模糊匹配衍生出来的,用法基本相似,你能用到的场景Mybatis-Plus团队都帮你考虑到了。
种一棵树,最好的时间是十年前,其次,就是当下。