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 ...
随机推荐
- 如何调用api接口获取到商品数据
要调用API接口获取商品数据,需要进行以下步骤: 确定API接口 首先需要确定要使用的API接口,可以通过搜索引擎或者相关文档来查找适合的API接口.以淘宝开放平台为例,可以使用淘宝的商品信息查询AP ...
- Andrew Ng 机器学习&深度学习课程 代码作业解答 集合
写在最前 2018年是对自己来说是崭新的一年,在过去的3个多月里,从最基础的lr, 学到现在的LSTM, GAN..感觉第一次追上了计算机科学飞速发展的浪潮.虽然很多地方都仍是一知半解,但时间还长 ...
- 拓展kmp
Smiling & Weeping ---- 我从不觉得暗恋是苦涩的, 对一个人的喜欢藏在眼睛里, 透过它, 世界都变得更好看了. 题目:P5410 [模板]扩展 KMP(Z 函数) - 洛谷 ...
- POWERBI_1分钟学会_连续上升或下降指标监控
一:数据源 模拟数据为三款奶茶销量的日销售数据源,日期是23.8.24-23.8.31.A产品为连续7天,日环比下降,B产品为连续3天,日环比下降,C产品为连续2天,日环比下降. 二:建立基础度量值 ...
- 关于Async、Await的一些知识点
在ASP.NET Core中,当一个HTTP请求到达服务器时,它会被分配给线程池中的一个线程来处理.该线程会执行相应的Controller方法. 如果这个方法是一个异步方法并且使用了await关键字, ...
- Mind2Web: Towards a Generalist Agent for the Web 论文解读
主页:https://osu-nlp-group.github.io/Mind2Web 训练集:https://huggingface.co/datasets/osunlp/Mind2Web 概要 本 ...
- DHorse v1.4.2 发布，基于 k8s 的发布平台
版本说明 优化特性 在集群列表增加集群版本: 修改Jvm的GC指标名: 解决问题 解决shell脚本换行符的问题: 解决部署历史列表页,环境名展示错误的问题: 解决指标收集功能的异常: 升级指南 升级 ...
- mybatis-plus使用心得
mybatis-plus是一款基于mybatis的持久层框架,在mybatis上只做增强不做改变.基本使用流程: 导入依赖坐标: <dependency> <groupId>c ...
- 机器学习实战1-kNN最近邻算法
目录 机器学习基础 机器学习的关键术语 k-近邻算法(KNN) 准备:使用python导入数据 实施kNN分类算法 示例:使用kNN改进约会网站的配对效果 准备数据:从文本文件中解析数据 分析数据 准 ...
- CF48C [The Race]
Problem 题目简述 现有 \(n\) 个已经加过油的加油站,如果当前剩余油量 \(< 10\) 升,则会加 \(x\) 升的油. 初始状态下,有 \(x\) 升油.每个加油站之间的距离为 ...