MybatisPlus条件查询方法全解
1、是什么？
MybatisPlus通过条件构造器可以组装复杂的查询条件，写一些复杂的SQL语句，从而简化我们的开发提升我们的开发效率
# 可以简单的理解为就是我们写SQL语句时where后面的条件
where xxx...
2、怎么玩？
(1) 获取条件构造器的几种方式
/**
* 获取普通条件构造器的几种方式
*/
@Test
public void testGetWrapper() {
Wrapper<Employee> wrapper = new QueryWrapper<Employee>();
Wrapper<Employee> query = Wrappers.<Employee>query();
}
/**
* 获取Lambda条件构造器的几种方式
*/
@Test
public void testGetLambdaWrapper() {
Wrapper<Employee> wrapper = new LambdaQueryWrapper<>();
Wrapper<Employee> query = Wrappers.<Employee>lambdaQuery();
}
(2) eq 等于 =
例如：我想查询姓名为张三的员工信息
- mysql
select * from employee where name = '张三';
- MP
/**
* 等于条件，可以存在多个，多个条件之间默认使用and连接
* eq(R column, Object val) : select * from employee where name = '张三';
* <p>
*/
@Test
public void testEq() {
Wrapper<Employee> wrapper = Wrappers
.<Employee>lambdaQuery()
.eq(Employee::getName, "张三");
List<Employee> employees = employeeService.list(wrapper);
log.info("employees:{}", employees);
}
/**
* 在eq基础上，满足condition为true的情况，才会拼接条件
* eq(boolean condition, R column, Object val);
*/
@Test
public void testEqCondition() {
// String keyword = "张三";
String keyword = "";
Wrapper<Employee> wrapper = Wrappers.<Employee>lambdaQuery()
.eq(StringUtils.isNotBlank(keyword), Employee::getName, keyword);
List<Employee> employees = employeeService.list(wrapper);
log.info("employees:{}", employees);
}
(3) ne 不等于 <>
例如：我想查询姓名不为张三的员工信息
- mysql
select * from employee where name <> '张三';
- MP
/**
* 不等于条件，可以存在多个，多个条件之间默认使用and连接
* ne(R column, Object val)
*/
@Test
public void testNe() {
Wrapper<Employee> wrapper = Wrappers.<Employee>lambdaQuery()
.ne(Employee::getName, "张三");
List<Employee> employees = employeeService.list(wrapper);
log.info("employees:{}", employees);
}
/**
* 在ne基础上，满足condition为true的情况，才会拼接条件
* ne(boolean condition, R column, Object val);
*/
@Test
public void testNeCondition() {
String keyword = "张三";
Wrapper<Employee> wrapper = Wrappers.<Employee>lambdaQuery()
.ne(StringUtils.isNotBlank(keyword), Employee::getName, keyword);
List<Employee> employees = employeeService.list(wrapper);
log.info("employees:{}", employees);
}
(4) gt 大于 >
例如：我想查询id大于3的员工信息
- mysql
select * from employee where id > 3;
- MP
/**
* 大于条件，可以存在多个，多个条件之间默认使用and连接
* gt(R column, Object val)
*/
@Test
public void testGt() {
Wrapper<Employee> wrapper = Wrappers.<Employee>lambdaQuery()
.gt(Employee::getId, 3);
List<Employee> employees = employeeService.list(wrapper);
log.info("employees:{}", employees);
}
/**
* 在gt基础上，满足condition为true的情况，才会拼接条件
* gt(boolean condition, R column, Object val)
*/
@Test
public void testGtCondition() {
Integer keyword = 3;
Wrapper<Employee> wrapper = Wrappers.<Employee>lambdaQuery()
.gt(keyword < 5, Employee::getId, keyword);
List<Employee> employees = employeeService.list(wrapper);
log.info("employees:{}", employees);
}
(5) ge 大于等于 >=
例如：我想查询id大于等于3的员工信息
- mysql
select * from employee where id > 3;
- MP
/**
* 大于等于条件，可以存在多个，多个条件之间默认使用and连接
* ge(R column, Object val)
*/
@Test
public void testGe() {
Wrapper<Employee> wrapper = Wrappers.<Employee>lambdaQuery()
.ge(Employee::getId, 3);
List<Employee> employees = employeeService.list(wrapper);
log.info("employees:{}", employees);
}
/**
* 在ge基础上，满足condition为true的情况，才会拼接条件
* ge(boolean condition, R column, Object val)
*/
@Test
public void testGeCondition() {
Integer keyword = 3;
Wrapper<Employee> wrapper = Wrappers.<Employee>lambdaQuery()
.ge(keyword < 5, Employee::getId, keyword);
List<Employee> employees = employeeService.list(wrapper);
log.info("employees:{}", employees);
}
(6) lt 小于 <
例如：我想查询id小于3员工信息
- mysql
select * from employee where id < 3;
- MP
/**
* 小于条件，可以存在多个，多个条件之间默认使用and连接
* lt(R column, Object val)
*/
@Test
public void testLt() {
Wrapper<Employee> wrapper = Wrappers.<Employee>lambdaQuery()
.lt(Employee::getId, 3);
List<Employee> employees = employeeService.list(wrapper);
log.info("employees:{}", employees);
}
/**
* 在lt基础上，满足condition为true的情况，才会拼接条件
* lt(boolean condition, R column, Object val)
*/
@Test
public void testLtCondition() {
Integer keyword = 3;
Wrapper<Employee> wrapper = Wrappers.<Employee>lambdaQuery()
.lt(keyword < 5, Employee::getId, keyword);
List<Employee> employees = employeeService.list(wrapper);
log.info("employees:{}", employees);
}
(7) le 小于等于 <=
例如：我想查询id小于等于3的员工信息
- mysql
select * from employee where id <= 3;
- MP
/**
* 小于等于条件，可以存在多个，多个条件之间默认使用and连接
* le(R column, Object val)
*/
@Test
public void testLe() {
Wrapper<Employee> wrapper = Wrappers.<Employee>lambdaQuery()
.le(Employee::getId, 3);
List<Employee> employees = employeeService.list(wrapper);
log.info("employees:{}", employees);
}
/**
* 在le基础上，满足condition为true的情况，才会拼接条件
* le(boolean condition, R column, Object val)
*/
@Test
public void testLeCondition() {
Integer keyword = 3;
Wrapper<Employee> wrapper = Wrappers.<Employee>lambdaQuery()
.le(keyword < 5, Employee::getId, keyword);
List<Employee> employees = employeeService.list(wrapper);
log.info("employees:{}", employees);
}
(8) between 范围条件 BETWEEN xxx and xxx
例如：我想查询id在2-4的员工信息
- mysql
select * from employee WHERE id BETWEEN 2 and 4;
- MP
/**
* 范围条件，可以存在多个，多个条件之间默认使用and连接(但是没有意义)；可以使用or连接
* between(R column, Object val1, Object val2)
*/
@Test
public void testBetween() {
Wrapper<Employee> wrapper = Wrappers.<Employee>lambdaQuery()
.between(Employee::getId, 2, 4)
.or()
.between(Employee::getId, 2, 4);
List<Employee> employees = employeeService.list(wrapper);
log.info("employees:{}", employees);
}
/**
* 在between基础上，满足condition为true的情况，才会拼接条件
* between(boolean condition, R column, Object val1, Object val2)
*/
@Test
public void testBetweenCondition() {
Integer keyword1 = 2;
Integer keyword2 = 4;
Wrapper<Employee> wrapper = Wrappers.<Employee>lambdaQuery()
.between(keyword1 < 3 || keyword2 > 5, Employee::getId, keyword1, keyword2);
List<Employee> employees = employeeService.list(wrapper);
log.info("employees:{}", employees);
}
(9) notBetween 范围条件 NOT BETWEEN xxx and xxx
例如：我想查询id不在2-4的员工信息
- mysql
select * from employee WHERE id NOT BETWEEN 2 and 4;
- MP
/**
* 不在范围条件中，可以存在多个，多个条件之间默认使用and连接(但是没有意义)；可以使用or连接
* notBetween(R column, Object val1, Object val2)
*/
@Test
public void testNotBetween() {
Wrapper<Employee> wrapper = Wrappers.<Employee>lambdaQuery()
.notBetween(Employee::getId, 2, 4);
List<Employee> employees = employeeService.list(wrapper);
log.info("employees:{}", employees);
}
/**
* 在notBetween基础上，满足condition为true的情况，才会拼接条件
* notBetween(boolean condition, R column, Object val1, Object val2)
*/
@Test
public void testNotBetweenCondition() {
Integer keyword1 = 2;
Integer keyword2 = 4;
Wrapper<Employee> wrapper = Wrappers.<Employee>lambdaQuery()
.notBetween(keyword1 < 3 || keyword2 > 5, Employee::getId, keyword1, keyword2);
List<Employee> employees = employeeService.list(wrapper);
log.info("employees:{}", employees);
}
(10) like 全模糊查询条件 like %xxx%
例如：我想查询姓名包含张的员工信息
- mysql
select * from employee where name like '%张%';
- MP
/**
* 全模糊查询，可以存在多个，多个条件之间默认使用and连接
* like(R column, Object val)
*/
@Test
public void testLike() {
Wrapper<Employee> wrapper = Wrappers.<Employee>lambdaQuery()
.like(Employee::getName, "张");
List<Employee> employees = employeeService.list(wrapper);
log.info("employees:{}", employees);
}
/**
* 在like基础上，满足condition为true的情况，才会拼接条件
* like(boolean condition, R column, Object val)
*/
@Test
public void testLikeCondition() {
String keyword = "张";
Wrapper<Employee> wrapper = Wrappers.<Employee>lambdaQuery()
.like(StringUtils.isNotBlank(keyword), Employee::getName, keyword);
List<Employee> employees = employeeService.list(wrapper);
log.info("employees:{}", employees);
}
(11) like 不在全模糊查询条件中 not like %xxx%
例如：我想查询姓名不包含张的员工信息
- mysql
select * from employee where name not like '%张%';
- MP
/**
* 不在全模糊查询条件中，可以存在多个，多个条件之间默认使用and连接
* notLike(R column, Object val)
*/
@Test
public void testNotLike() {
Wrapper<Employee> wrapper = Wrappers.<Employee>lambdaQuery()
.notLike(Employee::getName, "张");
List<Employee> employees = employeeService.list(wrapper);
log.info("employees:{}", employees);
}
/**
* 在notLike基础上，满足condition为true的情况，才会拼接条件
* notLike(boolean condition, R column, Object val)
*/
@Test
public void testNotLikeCondition() {
String keyword = "张";
Wrapper<Employee> wrapper = Wrappers.<Employee>lambdaQuery()
.notLike(StringUtils.isNotBlank(keyword), Employee::getName, keyword);
List<Employee> employees = employeeService.list(wrapper);
log.info("employees:{}", employees);
}
(12) likeLife 左模糊查询条件 like %xxx
例如：我想查询姓名以张结尾的员工信息
- mysql
select * from employee where name like '%张';
- MP
/**
* 左模糊查询，可以存在多个，多个条件之间默认使用and连接
* likeLife(R column, Object val)
*/
@Test
public void testLikeLife() {
Wrapper<Employee> wrapper = Wrappers.<Employee>lambdaQuery()
.likeLeft(Employee::getName, "张");
List<Employee> employees = employeeService.list(wrapper);
log.info("employees:{}", employees);
}
/**
* 在likeLeft基础上，满足condition为true的情况，才会拼接条件
* likeLeft(boolean condition, R column, Object val)
*/
@Test
public void testLikeLifeCondition() {
String keyword = "张";
Wrapper<Employee> wrapper = Wrappers.<Employee>lambdaQuery()
.likeLeft(StringUtils.isNotBlank(keyword), Employee::getName, keyword);
List<Employee> employees = employeeService.list(wrapper);
log.info("employees:{}", employees);
}
(13) notLikeLife 左模糊查询条件 not like %xxx
例如：我想查询姓名不以张结尾的员工信息
- mysql
select * from employee where name not like '%张';
- MP
/**
* 不在左模糊查询条件中，可以存在多个，多个条件之间默认使用and连接
* notLikeLeft(R column, Object val)
*/
@Test
public void testNotLikeLife() {
Wrapper<Employee> wrapper = Wrappers.<Employee>lambdaQuery()
.notLikeLeft(Employee::getName, "张");
List<Employee> employees = employeeService.list(wrapper);
log.info("employees:{}", employees);
}
/**
* 在notLikeLeft基础上，满足condition为true的情况，才会拼接条件
* notLikeLeft(boolean condition, R column, Object val)
*/
@Test
public void testNotLikeLifeCondition() {
String keyword = "张";
Wrapper<Employee> wrapper = Wrappers.<Employee>lambdaQuery()
.notLikeLeft(StringUtils.isNotBlank(keyword), Employee::getName, keyword);
List<Employee> employees = employeeService.list(wrapper);
log.info("employees:{}", employees);
}
(14) likeRight 右模糊查询条件 like xxx%
例如：我想查询姓名以张开头的员工信息
- mysql
select * from employee where name like '张%';
- MP
/**
* 右模糊查询，可以存在多个，多个条件之间默认使用and连接
* likeRight(R column, Object val)
*/
@Test
public void testLikeRight() {
Wrapper<Employee> wrapper = Wrappers.<Employee>lambdaQuery()
.likeRight(Employee::getName, "张");
List<Employee> employees = employeeService.list(wrapper);
log.info("employees:{}", employees);
}
/**
* 在likeRight基础上，满足condition为true的情况，才会拼接条件
* likeRight(boolean condition, R column, Object val)
*/
@Test
public void testLikeRightCondition() {
String keyword = "张";
Wrapper<Employee> wrapper = Wrappers.<Employee>lambdaQuery()
.likeRight(StringUtils.isNotBlank(keyword), Employee::getName, keyword);
List<Employee> employees = employeeService.list(wrapper);
log.info("employees:{}", employees);
}
(15) notLikeRight 不在右模糊查询条件中 not like xxx%
例如：我想查询姓名不以张开头的员工信息
- mysql
select * from employee where name not like '张%';
- MP
/**
* 不在右模糊查询条件中，可以存在多个，多个条件之间默认使用and连接
* notLikeRight(R column, Object val)
*/
@Test
public void testNotLikeRight() {
Wrapper<Employee> wrapper = Wrappers.<Employee>lambdaQuery()
.notLikeRight(Employee::getName, "张");
List<Employee> employees = employeeService.list(wrapper);
log.info("employees:{}", employees);
}
/**
* 在notLikeRight基础上，满足condition为true的情况，才会拼接条件
* notLikeRight(boolean condition, R column, Object val)
*/
@Test
public void testNotLikeRightCondition() {
String keyword = "张";
Wrapper<Employee> wrapper = Wrappers.<Employee>lambdaQuery()
.notLikeRight(StringUtils.isNotBlank(keyword), Employee::getName, keyword);
List<Employee> employees = employeeService.list(wrapper);
log.info("employees:{}", employees);
}
(16) isNull field为nul查询条件 is null
例如：我想查询姓名为null的员工信息
- mysql
select * from employee where name is null;
- MP
/**
* 查询field为null，可以存在多个，多个条件之间默认使用and连接
* isNull(R column, Object val)
*/
@Test
public void testIsNull() {
Wrapper<Employee> wrapper = Wrappers.<Employee>lambdaQuery()
.isNull(Employee::getName);
List<Employee> employees = employeeService.list(wrapper);
log.info("employees:{}", employees);
}
/**
* 在isNull基础上，满足condition为true的情况，才会拼接条件
* isNull(boolean condition, R column)
*/
@Test
public void testIsNullCondition() {
String keyword = "张";
Wrapper<Employee> wrapper = Wrappers.<Employee>lambdaQuery()
.isNull(StringUtils.isNotBlank(keyword), Employee::getName);
List<Employee> employees = employeeService.list(wrapper);
log.info("employees:{}", employees);
}
(17) isNotNull field不为nul查询条件 is not null
例如：我想查询姓名不为null的员工信息
- mysql
select * from employee where name is not null;
- MP
/**
* 查询field不为null，可以存在多个，多个条件之间默认使用and连接
* isNotNull(R column, Object val) : select * from employee where name is not null;
*/
@Test
public void testIsNotNull() {
Wrapper<Employee> wrapper = Wrappers.<Employee>lambdaQuery()
.isNotNull(Employee::getName);
List<Employee> employees = employeeService.list(wrapper);
log.info("employees:{}", employees);
}
/**
* 在IsNotNull基础上，满足condition为true的情况，才会拼接条件
* IsNotNull(boolean condition, R column)
*/
@Test
public void testIsNotNullCondition() {
String keyword = "刘";
Wrapper<Employee> wrapper = Wrappers.<Employee>lambdaQuery()
.isNotNull(StringUtils.isNotBlank(keyword), Employee::getName);
List<Employee> employees = employeeService.list(wrapper);
log.info("employees:{}", employees);
}
(18) inSql in操作 in (xxx,xxx,xxx)
例如：我想查询id在1,3,5中的员工信息
- mysql
select * from employee where id in(1,3,5);
- MP
/**
* in操作，可以存在多个，多个条件之间默认使用and连接
* inSql(R column, String inValue)
*/
@Test
public void testInSql() {
Wrapper<Employee> wrapper = Wrappers.<Employee>lambdaQuery()
.inSql(Employee::getId, "1,3,5");
List<Employee> employees = employeeService.list(wrapper);
log.info("employees:{}", employees);
}
/**
* 在inSql基础上，满足condition为true的情况，才会拼接条件
* inSql(boolean condition, R column, String inValue)
*/
@Test
public void testInSqlCondition() {
// String str = Arrays.asList(1,3,5).toString();
// String ids = str.substring(1, str.length() - 1);
String ids = StringUtils.joinWith(",",1,3,5);
Wrapper<Employee> wrapper = Wrappers.<Employee>lambdaQuery()
.inSql(StringUtils.isNotBlank(ids), Employee::getId, ids);
List<Employee> employees = employeeService.list(wrapper);
log.info("employees:{}", employees);
}
(19) notInSql not in操作 not in (xxx,xxx,xxx)
例如：我想查询id不在1,3,5中的员工信息
- mysql
select * from employee where id not in(1,3,5);
- MP
/**
* not in操作，可以存在多个，多个条件之间默认使用and连接
* notInSql(R column, String inValue)
*/
@Test
public void testNotInSql() {
Wrapper<Employee> wrapper = Wrappers.<Employee>lambdaQuery()
.notInSql(Employee::getId, "1,3,5");
List<Employee> employees = employeeService.list(wrapper);
log.info("employees:{}", employees);
}
/**
* 在notInSql基础上，满足condition为true的情况，才会拼接条件
* notInSql(boolean condition, R column, String inValue)
*/
@Test
public void testNotInSqlCondition() {
String ids = StringUtils.joinWith(",", 1,3,5);
Wrapper<Employee> wrapper = Wrappers.<Employee>lambdaQuery()
.notInSql(StringUtils.isNotBlank(ids), Employee::getId, ids);
List<Employee> employees = employeeService.list(wrapper);
log.info("employees:{}", employees);
}
(20) groupBy 分组操作 groupBy xxx
例如：我想按照性别分组统计员工个数
- mysql
select COUNT(*) AS emp_count from employee GROUP BY `sex`;
- MP
/**
* 分组操作，可以存在多个，多个条件之间默认使用and连接
* groupBy(R column)
*/
@Test
public void testGroupBy() {
Wrapper<Employee> wrapper = Wrappers.<Employee>query()
.select("count(id) as emp_count")
.groupBy("sex");
List<Map<String, Object>> listMaps = employeeService.listMaps(wrapper);
log.info("listMaps:{}", listMaps);
}
/**
* 在groupBy基础上，满足condition为true的情况，才会拼接条件
* groupBy(boolean condition, R column)
*/
@Test
public void testGroupByCondition() {
String keyword = "ly";
Wrapper<Employee> wrapper = Wrappers.<Employee>query()
.select("count(id) as emp_count")
.groupBy(StringUtils.isNotBlank(keyword), "sex");
List<Map<String, Object>> listMaps = employeeService.listMaps(wrapper);
log.info("listMaps:{}", listMaps);
}
注意我用的是普通的条件构造器
(21) orderByAsc 排序操作: 升序 order by xxx asc
例如：我想按照员工编号升序查询员工信息
- mysql
select * from employee order by id asc;
- MP
/**
* 排序操作: 升序
* orderByAsc(R column)
*/
@Test
public void testOrderByAsc() {
Wrapper<Employee> wrapper = Wrappers.<Employee>lambdaQuery()
.orderByAsc(Employee::getId);
List<Employee> employees = employeeService.list(wrapper);
log.info("employees:{}", employees);
}
/**
* 在orderByAsc基础上，满足condition为true的情况，才会拼接条件
* orderByAsc(boolean condition, R column)
*/
@Test
public void testOrderByAscCondition() {
String keyword = "ly";
Wrapper<Employee> wrapper = Wrappers.<Employee>lambdaQuery()
.orderByAsc(StringUtils.isNotBlank(keyword), Employee::getId);
List<Employee> employees = employeeService.list(wrapper);
log.info("employees:{}", employees);
}
(22) orderByDesc 排序操作: 降序 order by xxx desc
例如：我想按照员工编号降序查询员工信息
- mysql
select * from employee order by id desc;
- MP
/**
* 排序操作: 降序
* orderByDesc(R column)
*/
@Test
public void testOrderByDesc() {
Wrapper<Employee> wrapper = Wrappers.<Employee>lambdaQuery()
.orderByDesc(Employee::getId);
List<Employee> employees = employeeService.list(wrapper);
log.info("employees:{}", employees);
}
/**
* 在orderByDesc基础上，满足condition为true的情况，才会拼接条件
* orderByDesc(boolean condition, R column)
*/
@Test
public void testOrderByDescCondition() {
String keyword = "ly";
Wrapper<Employee> wrapper = Wrappers.<Employee>lambdaQuery()
.orderByDesc(StringUtils.isNotBlank(keyword), Employee::getId);
List<Employee> employees = employeeService.list(wrapper);
log.info("employees:{}", employees);
}
(23) orderBy 排序操作: 自定义升、降序 order by xxx asc,xxx desc
例如：我想按照姓名升序，员工编号降序查询员工信息
- mysql
select * from employee order by name asc , id desc;
- MP
/**
* 排序操作: 自定义升、降序
* orderBy(boolean condition, boolean isAsc, R column) : select * from employee ORDER BY id DESC ;
* 参数解释:
* param1: 满足condition为true的情况，才会拼接条件
* param2: 是否升序 true:升序 false:降序
* param3: 排序字段
* <p>
* 排序字段是可以为多个的
*/
@Test
public void testOrder() {
String keyword = "ly";
Wrapper<Employee> wrapper = Wrappers.<Employee>lambdaQuery()
.orderBy(StringUtils.isNotBlank(keyword), true, Employee::getId)
.orderBy(StringUtils.isNotBlank(keyword), false, Employee::getName);
List<Employee> employees = employeeService.list(wrapper);
log.info("employees:{}", employees);
}
(24) having 分组后操作 having xxx ...
例如：我想查询姓名为张三的员工信息
- mysql
select sex , COUNT(*) as emp_count from employee GROUP BY sex HAVING emp_count >=3;
- MP
/**
* 分组后操作
* orderBy(boolean condition, boolean isAsc, R column)
*/
@Test
public void testHaving() {
String keyword = "ly";
Wrapper<Employee> wrapper = Wrappers.<Employee>query()
.select("sex,count(*) as emp_count")
.groupBy("sex")
.having("emp_count >= 3");
List<Employee> employees = employeeService.list(wrapper);
log.info("employees:{}", employees);
}
(25) func 内嵌逻辑 类似于在mysql中做条件判断
例如：如果条件存在查询id为1的员工信息，否则查询id不等于2的员工信息;
当然这个是可以多重判断的
- MP
/**
* 内嵌逻辑：可以在满足某些条件|不满足某些条件时，添加查询条件
* func(Consumer<Children> consumer)
* 类似于MySQL中的If语句
* IF search_condition THEN
* statement_list
* ELSE
* statement_list
* END IF;
*/
@Test
public void testFunc() {
String keyword = "ly";
Wrapper<Employee> wrapper = Wrappers.<Employee>lambdaQuery().func(w -> {
if (StringUtils.isNotBlank(keyword)) {
w.eq(Employee::getId, 1);
} else {
w.ne(Employee::getId, 2);
}
});
List<Employee> employees = employeeService.list(wrapper);
log.info("employees:{}", employees);
}
(26) or 或操作
- MP
/**
* 或操作
* or SELECT * FROM employee WHERE (name = ? OR id = ?)
*/
@Test
public void testOr() {
String keyword = "ly";
Wrapper<Employee> wrapper = Wrappers.<Employee>lambdaQuery()
.eq(Employee::getName, "张三")
.or()
.eq(Employee::getId, 2);
List<Employee> employees = employeeService.list(wrapper);
log.info("employees:{}", employees);
}
(27) and 与操作
- MP
/**
* 与操作
* and SELECT * FROM employee WHERE (name = ? AND id = ?)
*/
@Test
public void testAnd() {
String keyword = "ly";
Wrapper<Employee> wrapper = Wrappers.<Employee>lambdaQuery()
.eq(Employee::getName, "张三")
.and(e -> {
e.eq(Employee::getId,2);
});
List<Employee> employees = employeeService.list(wrapper);
log.info("employees:{}", employees);
}
(28) nested 正常嵌套 不带 AND 或者 OR
- MP
/**
* 正常嵌套 不带 AND 或者 OR
* nested(Consumer<Param> consumer) SELECT * FROM employee WHERE ((id = ? OR id = ?))
*/
@Test
public void testNested() {
Wrapper<Employee> wrapper = Wrappers.<Employee>lambdaQuery()
.nested(w -> {
w.eq(Employee::getId, 1)
.or()
.eq(Employee::getId, 2);
});
List<Employee> employees = employeeService.list(wrapper);
log.info("employees:{}", employees);
}
(29) apply 自定义查询条件
- MP
/**
* 自定义查询条件
* apply(String applySql, Object... values) SELECT * FROM employee WHERE (id = ?)
*/
@Test
public void testApply() {
Wrapper<Employee> wrapper = Wrappers.<Employee>lambdaQuery()
.apply("id = {0}", 2);
List<Employee> employees = employeeService.list(wrapper);
log.info("employees:{}", employees);
}
(30) last 无视优化规则直接拼接到 sql 的最后
- MP
/**
* 无视优化规则直接拼接到 sql 的最后
* last(String lastSql) SELECT * FROM employee limit 0 , 1
*/
@Test
public void testLast() {
Wrapper<Employee> wrapper = Wrappers.<Employee>lambdaQuery()
.last("limit 0,1");
List<Employee> employees = employeeService.list(wrapper);
log.info("employees:{}", employees);
}
(31) exists mysql中的exists 语句,当子查询中的存在查询结果时,我们的主查询结果才会显示
- MP
/**
* exists 语句,当子查询中的存在查询结果时,我们的主查询结果才会显示
* exists(String existsSql, Object... values) SELECT id,name,password,sex,birthday,address,email FROM employee WHERE (EXISTS (select id from employee where id = 10))
*/
@Test
public void testExists() {
Wrapper<Employee> wrapper = Wrappers.<Employee>lambdaQuery()
.exists("select id from employee where id = {0}", 10);
List<Employee> employees = employeeService.list(wrapper);
log.info("employees:{}", employees);
}
(32) notExists mysql中的notExists 语句,当子查询中的不存在查询结果时,我们的主查询结果才会显示
- MP
/**
* notExists 语句,当子查询中的不存在查询结果时,我们的主查询结果才会显示
* notExists(String existsSql, Object... values) SELECT id,name,password,sex,birthday,address,email FROM employee WHERE (EXISTS (select id from employee where id = 10))
*/
@Test
public void testNotExists() {
Wrapper<Employee> wrapper = Wrappers.<Employee>lambdaQuery()
.notExists("select id from employee where id = {0} or id = {1}", 10, 1);
List<Employee> employees = employeeService.list(wrapper);
log.info("employees:{}", employees);
}
MybatisPlus条件查询方法全解的更多相关文章
- laravel操作Redis排序/删除/列表/随机/Hash/集合等方法全解
Song • 3563 次浏览 • 0 个回复 • 2017年10月简介 Redis模块负责与Redis数据库交互,并提供Redis的相关API支持: Redis模块提供redis与redis.con ...
- Java main方法全解
1.main方法的重载 package cn.nxl2018; public class Main_test { public static void main(String args[]) { Sy ...
- Mysql高手系列 - 第7篇：玩转select条件查询，避免踩坑
这是Mysql系列第7篇. 环境:mysql5.7.25,cmd命令中进行演示. 电商中:我们想查看某个用户所有的订单,或者想查看某个用户在某个时间段内所有的订单,此时我们需要对订单表数据进行筛选,按 ...
- 七、玩转select条件查询
前言: 电商中:我们想查看某个用户所有的订单,或者想查看某个用户在某个时间段内所有的订单,此时我们需要对订单表数据进行筛选,按照用户.时间进行过滤,得到我们期望的结果. 此时我们需要使用条件查询来对指 ...
- Java开发学习(四十二)----MyBatisPlus查询语句之条件查询
一.条件查询的类 MyBatisPlus将书写复杂的SQL查询条件进行了封装,使用编程的形式完成查询条件的组合. 这个我们在前面都有见过,比如查询所有和分页查询的时候,都有看到过一个Wrapper类, ...
- 【mybatis-plus】条件查询
用mp也可以方便的实现稍复杂点的条件查询,当然了很复杂的就还是要xml编写sql了. 一.wapper介绍 先看下mp的条件构造抽象类的结构: Wrapper: 条件构造抽象类,最顶端父类 Abstr ...
- MongoDB各种查询操作详解
这篇文章主要介绍了MongoDB各种查询操作详解,包括比较查询.关联查询.数组查询等,需要的朋友可以参考下 一.find操作 MongoDB中使用find来进行查询,通过指定find的第一个参数可 ...
- EasyUI ComboGrid的绑定，上下键和回车事件，输入条件查询
首先我们先看一下前台的绑定事件 1.先定义标签 <input id="cmbXm" type="text" style="width: 100p ...
- hibernate(七) hibernate中查询方式详解
序言 之前对hibernate中的查询总是搞混淆,不明白里面具体有哪些东西.就是因为缺少总结.在看这篇文章之前,你应该知道的是数据库的一些查询操作,多表查询等,如果不明白,可以先去看一下 MySQL数 ...
- 【Solr】索引库查询界面详解
目录 索引库查询界面详解 回到顶部 索引库查询界面详解 q:主查询条件.完全支持lucene语法.还进行了扩展. fq:过滤查询.是在主查询条件查询结果的基础上进行过滤.例如:product_pric ...
随机推荐
- ELK环境部署-LogStash数据收集(二)
一.安装JAVA环境 1.解压jdk压缩包 abc@elk:~$ sudo tar -zxvf jdk-11.0.18_linux-x64_bin.tar.gz -c jdk11 2.添加环境变量 a ...
- chatglm2-6b在P40上做LORA微调
背景: 目前,大模型的技术应用已经遍地开花.最快的应用方式无非是利用自有垂直领域的数据进行模型微调.chatglm2-6b在国内开源的大模型上,效果比较突出.本文章分享的内容是用chatglm2-6b ...
- 弹性数据库连接池探活策略调研(二)——Druid
前言 在上一篇文章中,我们介绍了弹性数据库连接失效的背景,并探讨了HikariCP连接池探活策略的相关内容.在本文中,我们将会继续探讨另一个线上常用的连接池--Druid,并为您介绍如何在使用Drui ...
- 使用HTML一键打包APK工具打包KRPANO全景项目
"HMTL一键打包APK工具"可以把本地HTML项目或者网站打包为一个安卓应用APK文件,无需编写任何代码,支持在安卓设备上安装运行. 打包工具群:429338543 下载地址: ...
- 【krpano】图文案例
KRPano图文案例可以展示图片和文字,并支持图片放大浏览,以及文本拖动等操作. 具体截图如下: 下载地址:http://pan.baidu.com/s/1qXQnPes 感谢群内小伙伴 快乐分享 本 ...
- 3-MySQL基本数据类型介绍
数据类型的介绍: 数据类型(data_type)是指系统中所允许的数据的类型.数据库中的每个列都应有适当的数据类型,用于限制或允许该列中存储的数据.例如,列中存储的为数字,则相应的数据类型应该为数值类 ...
- 每日一库：Prometheus
什么是 Prometheus Prometheus 是一个开源的系统监控和警报工具,最初由 SoundCloud 开发,并于 2012 年发布为开源项目.它是一个非常强大和灵活的工具,用于监控应用程序 ...
- Codechef - Longest AND Subarray（位运算）
题目大意 给定一个正整数N,其序列为[1, 2, 3, ..., N],找到一个长度最大的连续子列,使得其所有元素取与运算的结果为正(最终输出只需要输出最大长度即可). 思路 刚开始可能并不好 ...
- PHP-FFMpeg 操作音视频
目录 安装PHP-FFMpeg 视频中提取一张图片 视频中提取多张图片 调整视频大小 视频添加水印 生成音频波形 音频转换 给音频添加元数据 拼接多个音视频 截取音视频 提取 gif 动图 裁剪视频 ...
- es6(1)
1.var let const var---变量,重复定义不报错,没有块级作用域,不能限制修改 if(12>5){ var a=12; } alert(a); //弹出12 let---变量,重 ...