MybatisPlus條件查詢方法全解

本文轉載自查看原文 2022-03-30 20:23 2712 7、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 = '張三';

/**
     * 等於條件，可以存在多個，多個條件之間默認使用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 <> '張三';

 /**
     * 不等於條件，可以存在多個，多個條件之間默認使用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;

/**
     * 大於條件，可以存在多個，多個條件之間默認使用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;

/**
     * 大於等於條件，可以存在多個，多個條件之間默認使用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;

 /**
     * 小於條件，可以存在多個，多個條件之間默認使用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;

/**
     * 小於等於條件，可以存在多個，多個條件之間默認使用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;

/**
     * 范圍條件，可以存在多個，多個條件之間默認使用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;

/**
     * 不在范圍條件中，可以存在多個，多個條件之間默認使用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 '%張%';

/**
     * 全模糊查詢，可以存在多個，多個條件之間默認使用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 '%張%';

/**
     * 不在全模糊查詢條件中，可以存在多個，多個條件之間默認使用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 '%張';

/**
     * 左模糊查詢，可以存在多個，多個條件之間默認使用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 '%張';

/**
     * 不在左模糊查詢條件中，可以存在多個，多個條件之間默認使用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 '張%';

/**
     * 右模糊查詢，可以存在多個，多個條件之間默認使用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 '張%';

/**
     * 不在右模糊查詢條件中，可以存在多個，多個條件之間默認使用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;

/**
     * 查詢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;

/**
     * 查詢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);

/**
     * 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);

/**
     * 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`;

/**
     * 分組操作，可以存在多個，多個條件之間默認使用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;

/**
     * 排序操作: 升序
     * 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;

/**
     * 排序操作: 降序
     * 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;

 /**
     * 排序操作: 自定義升、降序
     * 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;

/**
     * 分組后操作
     * 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的員工信息;
當然這個是可以多重判斷的

/**
     * 內嵌邏輯：可以在滿足某些條件|不滿足某些條件時，添加查詢條件
     * 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 或操作

/**
     * 或操作
     * 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 與操作

/**
     * 與操作
     * 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

/**
     * 正常嵌套 不帶 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 自定義查詢條件

/**
     * 自定義查詢條件
     * 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 的最后

/**
     * 無視優化規則直接拼接到 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 語句,當子查詢中的存在查詢結果時,我們的主查詢結果才會顯示

/**
     * 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 語句,當子查詢中的不存在查詢結果時,我們的主查詢結果才會顯示

/**
     * 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);
    }

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 mybatis-plus 條件查詢方法全解 MybatisPlus的各種查詢方法 SpringBoot整合Mybatisplus的常用查詢方法 MyBatisPlus---query各種查詢方法 SpringBoot整合MybatisPlus有關條件構造器的相關查詢方法 MybatisPlus分頁條件查詢卡的查詢方法 MySQL —— 基本查詢方法 Mysql多對多查詢方法 mongodb查詢方法