import com.baomidou.mybatisplus.core.conditions.Wrapper;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;

import com.baomidou.mybatisplus.core.toolkit.Wrappers;

import com.mp.dao.UserMapper;

import com.mp.entity.User;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.boot.test.context.SpringBootTest;

import org.springframework.test.context.junit4.SpringRunner;

import java.util.Arrays;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

/**

 * @Description

 * @auther mohuani

 * @create 2019-12-25 11:37

 */

@RunWith(SpringRunner.class)

@SpringBootTest

public class RetrieveTest {

    @Autowired

    private UserMapper userMapper;

    @Test

    public void selectById() {

        User user = userMapper.selectById(1088250446457389058L);

        System.out.println(user);

    }

    @Test

    public void selectBatchIds() {

        List<Long> list = Arrays.asList(1088248166370832385L, 1094590409767661570L, 1209509417456001025L);

        List<User> userList = userMapper.selectBatchIds(list);

        userList.forEach(System.out::println);

    }

    @Test

    public void selectByMap() {

    //where name='李艺伟' and age = 28

        Map<String, Object> columnMap = new HashMap<>();

        columnMap.put("name", "李艺伟");

        columnMap.put("age", 28);

        List<User> userList = userMapper.selectByMap(columnMap);

        userList.forEach(System.out::println);

    }

    /**

     * 1、名字中包含雨并且年龄小于40

     *     name like '%雨%' and age<40

     */

    @Test

    public void selectByWrapper() {

        QueryWrapper<User> queryWrapper = new QueryWrapper<>();

        //QueryWrapper<User> queryWrapper = Wrappers.<User>query();

        queryWrapper.like("name", "雨").lt("age", 40);

        List<User> userList = userMapper.selectList(queryWrapper);

        userList.forEach(System.out::println);

    }

    /**

     * 2、名字中包含雨年并且龄大于等于20且小于等于40并且email不为空

     *    name like '%雨%' and age between 20 and 40 and email is not null

     */

    @Test

    public void selectByWrapper2() {

        QueryWrapper<User> queryWrapper = new QueryWrapper<>();

        queryWrapper.like("name", "雨").between("age" ,20 ,40).isNotNull("email");

        List<User> userList = userMapper.selectList(queryWrapper);

        userList.forEach(System.out::println);

    }

    /**

     * 3、名字为王姓或者年龄大于等于25，按照年龄降序排列，年龄相同按照id升序排列

     *    name like '王%' or age>=25 order by age desc,id asc

     */

    @Test

    public void selectByWrapper3() {

        QueryWrapper<User> queryWrapper = new QueryWrapper<>();

        queryWrapper.likeRight("name", "王").or().gt("age", 25).orderByDesc("age").orderByAsc("id");

        List<User> userList = userMapper.selectList(queryWrapper);

        userList.forEach(System.out::println);

    }

    /**

    *

    * 创建时间为2019年2月14日并且直属上级为名字为王姓:

    * date_format(create_time,'%Y-%m-%d') and manager_id in (select id from user where name like '王%')

    *

    */

    @Test

public void selectByWrapper4(){

QueryWrapper<User> queryWrapper = new QueryWrapper<User>();

        //动态条件构造器：apply。范围条件构造器：insql。

        //注意：如果{0}替换为实际值，可能会造成sql注入。

queryWrapper.apply("date_format(create_time,'%Y-%m-%d') = {0}","2019-02-14").inSql("manager_id","select id from user where name like '王%' ");

//queryWrapper.apply("date_format(create_time,'%Y-%m-%d') = '2019-02-14'").inSql("manager_id","select id from user where name like '王%' ");  //此种写法存在SQL注入的风险

List<User> userList = userMapper.selectList(queryWrapper);

userList.forEach(System.out::println);

}

    /**

    * 5.名字为王姓并且（年龄小于40或邮箱不为空）

    * name like '王%' and (age < 40 or email is not null)

    *

    */

@Test

public void selectByWrapper5(){

QueryWrapper<User> queryWrapper = new QueryWrapper<User>();

queryWrapper.likeRight("name","王").and(wq->wq.lt("age", 40).or().isNotNull("email"));

        List<User> userList = userMapper.selectList(queryWrapper);

userList.forEach(System.out::println);

}

    /**

    * 6. 名字为王姓或者(年龄小于40并且年龄大于20并且邮箱不为空)

    * name like '王%' or (age < 40 and ang > 20 and email is not null)

    *

    */

@Test

public void selectByWrapper6(){

QueryWrapper<User> queryWrapper = new QueryWrapper<User>();

queryWrapper.likeRight("name", "王").or(wq -> wq.lt("age", 40).gt("age", 20).isNotNull("email"));

        List<User> userList = userMapper.selectList(queryWrapper);

userList.forEach(System.out::println);

}

     /**

    * 7. (年龄小于40或邮箱不为空)并且名字为王姓

    * (age < 40 or email is not null) and name like '王%'

    *

    */

@Test

public void selectByWrapper7(){

QueryWrapper<User> queryWrapper = new QueryWrapper<User>();

queryWrapper.nested(wq -> wq.lt("age", 40).or().isNotNull("email")).likeRight("name", "王");

        List<User> userList = userMapper.selectList(queryWrapper);

userList.forEach(System.out::println);

}

/**

    * 8. 年龄为30,31,34,35

    * age in (30,31,34,35)

    *

    */

@Test

public void selectByWrapper8(){

QueryWrapper<User> queryWrapper = new QueryWrapper<User>();

queryWrapper.in("age". Arrays.asList(30,31,34,35));

        List<User> userList = userMapper.selectList(queryWrapper);

userList.forEach(System.out::println);

}

/**

    * 9. 值返回满足条件的其中一条语句即可

    * limit 1

    *

    */

@Test

public void selectByWrapper9(){

QueryWrapper<User> queryWrapper = new QueryWrapper<User>();

//last函数 无视优化规则直接拼接到sql的最后，只能调用一次，调用多次以最后一次为准，有sql注入风险

queryWrapper.in("age". Arrays.asList(30,31,34,35)).last("limit 1");

        List<User> userList = userMapper.selectList(queryWrapper);

userList.forEach(System.out::println);

}

/**

* select中字段不全部出现的查询

    * 10. 名字中包含雨且年龄小于40

    * （1）select id,name from user where name like '%雨%' and age < 40

    * （2）select id,name,age, email from user where name like '%雨%' and age < 40

    */

@Test

public void selectByWrapper10(){

QueryWrapper<User> queryWrapper = new QueryWrapper<User>();

//在select函数中指定需要查询的字段

//select id,name from user where name like '%雨%' and age < 40

//queryWrapper.select("id", "name").like("name", "雨")lt("age", 40);

        //在select函数中排除不需要的字段

//select id,name,age, email from user where name like '%雨%' and age < 40

queryWrapper.like("name", "雨")lt("age", 40).select(User.class, info -> !info.getColumn().equals("create_time") && !info.getColumn().equals("manager_id"));

        List<User> userList = userMapper.selectList(queryWrapper);

userList.forEach(System.out::println);

}

    /**

    * 实体对象作为条件构造器方法的参数

    */

@Test

public void selectByWrapperEntity(){

        User user = new User();

        user.setName("李艺伟");

        user.setAge(28)

QueryWrapper<User> queryWrapper = new QueryWrapper<User>(user);

        List<User> userList = userMapper.selectList(queryWrapper);

userList.forEach(System.out::println);

}

    /*

    * condition 条件判断，当条件为true则查询条件加入where

    * 作用：该条件是否加入最后生成的sql中。

    * 使用方法：如果为true就加入，如果false就不加入。

    * 使用场景：类似于动态的sql拼接。

    */

@Test

public void testCondition(){

String name = "王";

String email = "";

condition(name, email);

}

private void condition(String name, String email){

QueryWrapper<User> queryWrapper = new QueryWrapper<User>();

//第一种写法

/*if(StringUtils.isNotEmpty(name)){

queryWrapper.like("name", name);

}

if(StringUtils.isNotEmpty(email)){

queryWrapper.like("email", email);

}*/

//第二种写法

queryWrapper.like(StringUtils.isNotEmpty(name), "name", name)

            .like(StringUtils.isNotEmpty(email), "email", email);

        List<User> userList = userMapper.selectList(queryWrapper);

userList.forEach(System.out::println);

}

    /**

    * allEq函数用法

    */

@Test

public void selectByWrapperAllEq(){

QueryWrapper<User> queryWrapper = new QueryWrapper<User>();

Map<String, Object> columnMap = new HashMap<>();

        columnMap.put("name", "李艺伟");

        columnMap.put("age", 28);

        //columnMap.put("age", null);

        //queryWrapper.allEq(columnMap, false);   //忽略一个值

        //queryWrapper.allEq(columnMap);

        queryWrapper.allEq((k,v) -> !k.equals("name"), columnMap);  //不等于name值的就加入条件

        List<User> userList = userMapper.selectList(queryWrapper);

userList.forEach(System.out::println);

}

    /**

    *  selectMaps()用法

    *  selectMap：List集合的泛型不再是实体，而是map集合。其中key表示字段名，value表示字段值。

    *  

    *  使用场景1：当实体类属性非常多时，不易查看。如果返回的是一个实体类，那么即使我们设定了返回字段，那么它的值为null，但是属性仍然存在。如果返回的是Map类型，当指定了返回字段时，那么没返回的就不会存在。

    *  使用场景2：当返回的不是一条一条记录时，也就是返回的字段不在实体类属性中，比如一些统计，像平均值，最大值，最小值这样的。

    */

@Test

public void selectByWrapperMaps(){

QueryWrapper<User> queryWrapper = new QueryWrapper<User>();

//queryWrapper.like("name","雨").lt("age", 40);

queryWrapper.select("id", "name").like("name", "雨").lt("age", 40);

        List<Map<String, Object>> userList = userMapper.selectMaps(queryWrapper);

userList.forEach(System.out::println);

}

/**

selectMaps用于返回自定义字段和查询特定字段时避免其他字段为null

selectObjs用于返回结果的第一个字段

selectCount不能带select，因为它查询的时记录数量，对应于sql中的count(1)

selectOne用于输出一条结果，如果多与一条报错

    */

    /**

     按照直属上级分组，查询每组的平均年龄，最大年龄，最小年龄并且只取年龄总和小于500的组

     select avg(age) AS avg_age, min(age) AS min_age,max(age) AS max_age

     from user group by manager_id

     having sum(age)  < 500

    */

@Test

public void selectByWrapperMaps2(){

QueryWrapper<User> queryWrapper = new QueryWrapper<User>();

queryWrapper.select("avg(age) avg_age", "min(age) min_age", "max(age) max_age")

            .groupBy("manager_id").having("sum(age) < {0}", 500);

        List<User> userList = userMapper.selectList(queryWrapper);

userList.forEach(System.out::println);

}

    /**

    selectObject：List集合的泛型不再是实体，而是Object，只返回第一个字段的值。其他的会被舍弃。

    使用场景：只返回一列时可以使用它。

    */

@Test

public void selectByWrapperObjs(){

QueryWrapper<User> queryWrapper = new QueryWrapper<User>();

queryWrapper.select("id", "name").like("name", "雨").lt("age", 40);

        List<Object> userList = userMapper.selectObjs(queryWrapper);

userList.forEach(System.out::println);

}

    /**

    selectCount：查询符合条件的总记录数的。

    注意：使用它时，就不能指定返回的列了，因为它会在后面拼接COUNT(1)。

    */

@Test

public void selectByWrapperCount(){

QueryWrapper<User> queryWrapper = new QueryWrapper<User>();

queryWrapper.like("name", "雨").lt("age", 40);

        Integer count = userMapper.selectCount(queryWrapper);

System.out.println("总记录数 = " + count);

}

    /**

    selectOne：查询符合条件的数据，只会返回一条数据。

    注意：查询的结果必须是一条或者查不到（多于1条就会报错）。

    */

    @Test

public void selectByWrapperOne(){

QueryWrapper<User> queryWrapper = new QueryWrapper<User>();

queryWrapper.like("name", "雨").lt("age", 40);

User user = userMapper.selectOne(queryWrapper);

        System.out.println(user);

}

    /**

     lambda条件构造器

     lambda条件构造器的创建有3种方式

1、通过查询构造器QueryWrapper创建

2、通过new直接创建lambda条件构造器

3、通过构造器工具类Wrappers创建（此时需要泛型）

    */

@Test

public void selectLambda(){

    //方式1

//LambdaQueryWrapper<User> lambda = new QueryWrapper<User>().lambda();

    //方式二

    //LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<User>();

//方式三

    LambdaQueryWrapper<User> lambdaQuery = Wrappers.<User>lambdaQuery();

    //where name like '%雨%' and age < 40

    lambdaQuery.like(User::getName, "雨").lt(User::getAge, 40);

    List<User> userList = userMapper.selectList(lambdaQuery);

    userList.forEach(System.out::println);

}

    /**

    * 5.名字为王姓并且（年龄小于40或邮箱不为空）

    * name like '王%' and (age < 40 or email is not null)

    */

@Test

public void selectLambda2(){

    //方式1

//LambdaQueryWrapper<User> lambda = new QueryWrapper<User>().lambda();

    //方式二

    //LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<User>();

//方式三

    LambdaQueryWrapper<User> lambdaQuery = Wrappers.<User>lambdaQuery();

    //where name like '%雨%' and age < 40

    lambdaQuery.likeRight(User::getName, "王").and(lqw -> lqw.lt(User::getAge, 40)

    .or().isNotNull(User::getEmail));

    List<User> userList = userMapper.selectList(lambdaQuery);

    userList.forEach(System.out::println);

}

@Test

public void selectLambda3(){

    //新版本

    List<User> userList = new LambdaQueryChainWrapper<User>(userMapper).like(User::getName, "雨")

                          .ge(User::getAge, 20).list();

    userList.forEach(System.out::println);

}

}

lambda条件构造器

 lambda条件构造器

lambda表达式方式

lambda表达式方式

通过lambdaWrapper进行构造，能够防止误写，其有三种普通的构造方法，推荐使用Wrappers.lambda...

还可以通过lambdaWrapperChain构造，直接可以调用Mapper的方法（方便）。

select lambda 构造器3

select lambda 构造器2

select lambda 构造器

lambdaQuery

lambda条件构造器（类似mp条件构造器，防误写）

lambda条件构造器使用场景：

不需要我们手动在构造条件时去书写字段名称。

lambda条件构造器使用方法：

lambda条件构造器的创建有3种方式

1、通过查询构造器QueryWrapper创建

2、通过new直接创建lambda条件构造器

3、通过构造器工具类Wrappers创建（此时需要泛型）

例2：

4、3.0.7新增的创建lambda条件构造器，通过LambdaQueryChainWrapper，并且需要一个Mapper接口作为参数（通过源码可以，它是对普通查询构造器的再次封装，源码中仍然是通过Mapper接口去调用）。

lambda最新构造器使用例子

lambda条件构造器例子

lambda条件构造器

lambda

lambda3

lambda2

lambda条件构造器，防止编译的错误

LambdaQueryChainWrapper

使用Lambda查询多条件

使用lambda表达式进行like和lt的搜索

Lambda表达式查询方式
三种Lambda表达式创建方式

ggfrrrrrrrrrrr

/**名字为王姓并且（年龄小于40或邮箱不为空）

name like '王%' and （age<40 or email is not null）

**/

LambdaQueryWrapper<User> lambdaQuery = Wrapper<User> lambdaQuery();

lambdaQuery.likeRight(User::getName,"王").and(lqw->lqw.lt(User::getAge,40).or().isNotNull(User::getEmail))；

List<User> userList = userMapper.selectList(lambdaQuery);

userList.forEach(System.out::println);

List<User> userList = new LambdaQueryChainWrapper<User>(userMapper).like(User::getName,"雨").ge(User::getAge,20)list();

userList.forEach(System.out::println);