mybatis-flex笔记

深林中的书海

已于 2024-01-05 18:09:12 修改

阅读量1.2k

点赞数 21

分类专栏： springboot 架构文章标签： mybatis 笔记 java mybatis-flex springboot

于 2024-01-02 10:46:47 首次发布

本文链接：https://blog.csdn.net/weixin_43247803/article/details/135333254

版权

springboot 同时被 2 个专栏收录

10 篇文章 15 订阅

订阅专栏

架构

1 篇文章 0 订阅

订阅专栏

MyBatis-Flex 的增删改功能 - MyBatis-Flex 官方网站https://mybatis-flex.com/zh/base/add-delete-update.html

代码https://gitee.com/hntianshu/mybatis-flex-test

一新增数据

不忽略 null 值。就是允许有null

忽略null 就是不允许有null

BaseMapper 的接口提供了 insert 和 insertBatch 方法，用于新增数据；

insert(entity)：插入实体类数据，不忽略 null 值。
insertSelective(entity)：插入实体类数据，但是忽略 null 的数据，只对有值的内容进行插入。这样的好处是数据库已经配置了一些默认值，这些默认值才会生效。
insert(entity, ignoreNulls)：插入实体类数据。
insertWithPk(entity)：插入带有主键的实体类，不忽略 null 值。
insertSelectiveWithPk(entity)：插入带有主键的实体类，忽略 null 值。
insertWithPk(entity, ignoreNulls)：带有主键的插入，此时实体类不会经过主键生成器生成主键。
insertBatch(entities)：批量插入实体类数据，只会根据第一条数据来构建插入的字段内容。
insertBatch(entities, size)：批量插入实体类数据，按 size 切分。
insertOrUpdate(entity)：插入或者更新，若主键有值，则更新，若没有主键值，则插入，插入或者更新都不会忽略 null 值。
insertOrUpdateSelective(entity)：插入或者更新，若主键有值，则更新，若没有主键值，则插入，插入或者更新都会忽略 null 值。
insertOrUpdate(entity, ignoreNulls)：插入或者更新，若主键有值，则更新，若没有主键值，则插入。

`1. insert(entity)`：插入实体类数据，不忽略 `null` 值。


    @Autowired
    private AccountMapper accountMapper;  

   @Test
    void insert() {
        Account account = new Account(16, "哈皮", null, LocalDateTime.now()); //还是自增
        //INSERT INTO `tb_account`(`user_name`, `age`, `birthday`) VALUES (?, ?, ?)
        //Parameters: 哈皮(String), null, 2024-01-02T09:42:14.063491400(LocalDateTime)
        int row = accountMapper.insert(account);
        System.err.println("新增数量:" + row + "条");
    }

`2.insertSelective(entity)`：插入实体类数据，但是忽略 `null` 的数据，只对有值的内容进行插入。这样的好处是数据库已经配置了一些默认值，这些默认值才会生效。

    /**
     * insertSelective(entity)：插入实体类数据，但是忽略 null 的数据，只对有值的内容进行插入。这样的好处是数据库已经配置了一些默认值，这些默认值才会生效。
     */
    @Test
    void insertSelective() {
        Account account = new Account(null, "赵华", null, LocalDateTime.now());
        //Preparing: INSERT INTO `tb_account`(`user_name`, `birthday`) VALUES (?, ?)
        //Parameters: 赵华(String), 2024-01-02T09:44:54.492425100(LocalDateTime)
        int row = accountMapper.insertSelective(account);
        System.err.println("新增数量:" + row + "条");
    }

3. insert(entity, ignoreNulls)：插入实体类数据。

ignoreNulls: false相当于 insert(entity)
ignoreNulls: true相当于 insertSelective(entity)

   /**
     * insert(entity, ignoreNulls)：插入实体类数据。
     * ignoreNulls: false相当于 insert(entity)
     * ignoreNulls: true相当于 insertSelective(entity)
     */
    @Test
    void insert2() {
        Account account = new Account(null, "赵华", null, LocalDateTime.now());
        int row = accountMapper.insert(account, true);
        System.err.println("新增数量:" + row + "条");
    }

4.insertWithPk(entity)：插入带有主键的实体类，不忽略 null 值。

   /**
     * insertWithPk(entity)：插入带有主键的实体类，不忽略 null 值。
     */
    @Test
    void insertWithPk() {
        Account account = new Account(null, "赵华", null, LocalDateTime.now());
        int row = accountMapper.insertWithPk(account);
        System.err.println("新增数量:" + row + "条");
    }

5. insertSelectiveWithPk(entity)：插入带有主键的实体类，忽略 null 值。相当于insertWithPk(entity, true)

  /**
     * insertSelectiveWithPk(entity)：插入带有主键的实体类，忽略 null 值。
     * 相当于insertWithPk(entity, true)
     */
    @Test
    void insertSelectiveWithPk() {
        Account account = new Account(5, "赵华", null, LocalDateTime.now());
        int row = accountMapper.insertSelectiveWithPk(account);
        System.err.println("新增数量:" + row + "条");
    }

6.`insertWithPk(entity, ignoreNulls)`：带有主键的插入，此时实体类不会经过主键生成器生成主键。

insertWithPk = insertWithPk(entity, false)

insertSelectiveWithPk = insertWithPk(entity, true)

  /**
     * insertWithPk(entity, ignoreNulls)：带有主键的插入，此时实体类不会经过主键生成器生成主键。
     * insertWithPk = insertWithPk(entity, false)
     * insertSelectiveWithPk = insertWithPk(entity, true)
     */
    @Test
    void insertWithPk2() {
        Account account = new Account(5, "赵华", null, LocalDateTime.now());
        int row = accountMapper.insertWithPk(account, true);
        System.err.println("新增数量:" + row + "条");
    }

7.insertBatch(entities)：批量插入实体类数据，只会根据第一条数据来构建插入的字段内容。

只会根据字段数量最多的数据来构建插入的字段内容

不忽略null

/**
     * insertBatch(entities)：批量插入实体类数据，只会根据第一条数据来构建插入的字段内容。
     * 只会根据字段数量最多的数据来构建插入的字段内容
     * 不忽略null
     */
    @Test
    void insertBatch() {
        ArrayList<Account> list = new ArrayList<>();
        list.add(new Account(null, "林一", 25, LocalDateTime.now()));
        list.add(new Account(null, null, null, null));
        list.add(new Account("王五", 23, LocalDateTime.now()));
        int row = accountMapper.insertBatch(list);
        System.err.println("新增数量:" + row + "条");
    }

8. insertBatch(entities, size)：批量插入实体类数据，按 size 切分。分开插入 n条做切分

/**
     * insertBatch(entities, size)：批量插入实体类数据，按 size 切分。
     * 分开插入 n条做切分
     */
    @Test
    void insertBatch2() {
        ArrayList<Account> list = new ArrayList<>();
        list.add(new Account(null, "剑一", 25, LocalDateTime.now()));
        list.add(new Account(null, "剑二", 25, LocalDateTime.now()));
        list.add(new Account(null, "剑三", 25, LocalDateTime.now()));
        int row = accountMapper.insertBatch(list, 2);
        System.err.println("新增数量:" + row + "条");
    }

9.insertOrUpdate(entity)：插入或者更新，若主键有值，则更新，若没有主键值，则插入，插入或者更新都不会忽略 null 值。

    /**
     * insertOrUpdate(entity)：插入或者更新，若主键有值，则更新，若没有主键值，则插入，插入或者更新都不会忽略 null 值。
     */
    @Test
    void insertOrUpdate() {
        Account account = new Account(56, "林二", 25, LocalDateTime.now());
        int row = accountMapper.insertOrUpdate(account);
        System.err.println("新增/更新 数量:" + row + "条");
    }

10.insertOrUpdateSelective(entity)：插入或者更新，若主键有值，则更新，若没有主键值，则插入，插入或者更新都会忽略 null 值。

    /**
     * insertOrUpdateSelective(entity)：插入或者更新，若主键有值，则更新，若没有主键值，则插入，插入或者更新都会忽略 null 值。
     */
    @Test
    void insertOrUpdateSelective() {
        Account account = new Account(56, "林二", null, LocalDateTime.now());
        int row = accountMapper.insertOrUpdateSelective(account);
        System.err.println("新增/更新 数量:" + row + "条");
    }

11. `insertOrUpdate(entity, ignoreNulls)`：插入或者更新，若主键有值，则更新，若没有主键值，则插入。

 /**
     * insertOrUpdate(entity, ignoreNulls)：插入或者更新，若主键有值，则更新，若没有主键值，则插入。
     * insertOrUpdate = insertOrUpdate(entity, false)
     * insertOrUpdateSelective = insertOrUpdate(entity, true)
     */
    @Test
    void insertOrUpdate2() {
        Account account = new Account(56, "林二", null, LocalDateTime.now());
        int row = accountMapper.insertOrUpdate(account, false);
        System.err.println("新增/更新 数量:" + row + "条");
    }

12.用 UpdateWrapper 新增数据

  /**
     * 用 UpdateWrapper 新增数据
     * INSERT INTO `tb_account`(`user_name`,  `birthday`)
     * VALUES (?, now())
     */
    @Test
    public void testInsertWithRaw() {
        Account account = new Account();
        account.setUserName("剑一");

        Account newAccount = UpdateWrapper.of(account)
//       .setRaw("birthday", "now()")
//       .setRaw(ACCOUNT.BIRTHDAY, "now()")
                .setRaw(Account::getBirthday, "now()")
                .toEntity();

        int row = accountMapper.insert(newAccount);
        System.err.println("新数量:" + row + "条");
    }

    /**
     * 用 UpdateWrapper 新增数据 复杂一点
     * INSERT INTO `tb_account`(`user_name`,  `birthday`)
     * VALUES (?, (select xxx from ...))
     */
    @Test
    public void testInsertWithRaw2() {
        Account account = new Account();
        account.setUserName("剑二");

        Account newAccount = UpdateWrapper.of(account)
                .setRaw(Account::getBirthday, "(select a.birthday from (SELECT birthday FROM tb_account where id = 1)" +
                        " a )")
                .toEntity();

        int row = accountMapper.insert(newAccount);
        System.err.println("新数量:" + row + "条");
    }

二删除数据

不忽略 null 值。就是允许有null

忽略null 就是不允许有null

BaseMapper 的接口提供了 deleteById、deleteBatchByIds、deleteByMap、deleteByQuery 方法，用于删除数据；

deleteById(id)：根据主键删除数据。如果是多个主键的情况下，需要传入数组，例如：new Integer[]{100,101}。
delete(entity)：根据实体主键来删除数据。相比deleteById(id)，此方法更便于对复合主键实体类的删除。
deleteBatchByIds(ids)：根据多个主键批量删除数据。
deleteBatchByIds(ids, size)：根据多个主键批量删除数据。
deleteByMap(whereConditions)：根据 Map 构建的条件来删除数据。
deleteByCondition(whereConditions)：根据查询条件来删除数据。
deleteByQuery(queryWrapper)：根据查询条件来删除数据。

`1. deleteById(id)`：根据主键删除数据。如果是多个主键的情况下，需要传入数组，例如：`new Integer[]{100,101}`。

 /**
     * deleteById(id)：根据主键删除数据。如果是多个主键的情况下，需要传入数组，例如：new Integer[]{100,101}。
     */
    @Test
    public void deleteById() {
        int row = accountMapper.deleteById(59);
        System.err.println("删除数量:" + row + "条");
    }

2. `deleteBatchByIds(ids)`：根据多个主键批量删除数据。

    /**
     * deleteBatchByIds(ids)：根据多个主键批量删除数据。
     */
    @Test
    public void deleteBatchByIds() {
        List<Integer> array = new ArrayList<Integer>();
        array.add(59);
        array.add(60);
        array.add(61);
        int row = accountMapper.deleteBatchByIds(array);
        System.err.println("删除数量:" + row + "条");
    }

3. deleteBatchByIds(ids, size)：根据多个主键批量删除数据。分片删除

    /**
     * deleteBatchByIds(ids, size)：根据多个主键批量删除数据。 分片删除
     */
    @Test
    public void deleteBatchByIds2() {
        List<Integer> array = new ArrayList<Integer>();
        array.add(62);
        array.add(64);
        array.add(65);
        int row = accountMapper.deleteBatchByIds(array, 2);
        System.err.println("删除数量:" + row + "条");
    }

4. `deleteByMap(whereConditions)`：根据 Map 构建的条件来删除数据。

    /**
     * deleteByMap(whereConditions)：根据 Map 构建的条件来删除数据。
     */
    @Test
    public void deleteByMap() {
        //条件 where id =63 and age = 18
        Map<String, Object> map = new HashMap<>();
        map.put("id", 63);
        map.put("age", 18);
        int row = accountMapper.deleteByMap(map);
        System.err.println("删除数量:" + row + "条");
    }

5.deleteByCondition(whereConditions)：根据查询条件来删除数据。

    /**
     * deleteByCondition(whereConditions)：根据查询条件来删除数据。
     * ge >=
     * le <=
     * gt >
     * eq =
     * lt <
     * notIN
     */
    @Test
    public void deleteByCondition() {
        //accountMapper.deleteByCondition(ACCOUNT.ID.ge(100));
//        int row = accountMapper.deleteByCondition(ACCOUNT.ID.in(67,69));
        int row = accountMapper.deleteByCondition(ACCOUNT.ID.eq(70));
        System.err.println("删除数量:" + row + "条");
    }

6.deleteByQuery(queryWrapper)：根据查询条件来删除数据。

    /**
     * deleteByQuery(queryWrapper)：根据查询条件来删除数据。
     */
    @Test
    public void deleteByQuery() {
        QueryWrapper queryWrapper = QueryWrapper.create();
        queryWrapper.where(ACCOUNT.ID.ge(66));

//通过 queryWrapper 删除
        int row = accountMapper.deleteByQuery(queryWrapper);
        System.err.println("删除数量:" + row + "条");
    }

三更新数据

不忽略 null 值。就是允许有null

忽略null 就是不允许有null

BaseMapper 的接口提供了 update、updateByMap、updateByQuery 方法，用于更新数据；

update(entity)：根据主键来更新数据，若实体类属性数据为 null，该属性不会更新到数据库。
update(entity, ignoreNulls)：根据主键来更新数据到数据库。
updateByMap(entity, whereConditions)：根据 Map 构建的条件来更新数据。
updateByMap(entity, ignoreNulls, whereConditions)：根据 Map 构建的条件来更新数据。
updateByCondition(entity, whereConditions)：根据查询条件来更新数据。
updateByCondition(entity, ignoreNulls, whereConditions)：根据查询条件来更新数据。
updateByQuery(entity, queryWrapper)：根据查询条件来更新数据。
updateByQuery(entity, ignoreNulls, queryWrapper)：根据查询条件来更新数据。
~~updateNumberAddByQuery(fieldName, value, queryWrapper)~~：执行类似 update table set field = field + 1 where ... 的场景。
~~updateNumberAddByQuery(column, value, queryWrapper)~~：执行类似 update table set field = field + 1 where ... 的场景。
~~updateNumberAddByQuery(fn, value, queryWrapper)~~：执行类似 update table set field = field + 1 where ... 的场景。

1.`update(entity)`：根据主键来更新数据，若实体类属性数据为 `null`，该属性不会更新到数据库。

    /**
     * update(entity)：根据主键来更新数据，若实体类属性数据为 null，该属性不会更新到数据库。
     */
    @Test
    public void update() {
        Account account = new Account();
        account.setUserName("小明");
        account.setAge(18);
        account.setBirthday(LocalDateTime.now());
        account.setId(72);
        int row = accountMapper.update(account);
        System.err.println("修改数量:" + row + "条");
    }

2.update(entity, ignoreNulls)：根据主键来更新数据到数据库。

    /**
     * update(entity, ignoreNulls)：根据主键来更新数据到数据库。
     */
    @Test
    public void update2() {
        Account account = new Account();
        account.setUserName("小明1");
        account.setId(72);
        int row = accountMapper.update(account,false);
        System.err.println("修改数量:" + row + "条");
    }

3.updateByMap(entity, whereConditions)：根据 Map 构建的条件来更新数据。不忽略NUll

    /**
     * updateByMap(entity, whereConditions)：根据 Map 构建的条件来更新数据。
     * 不忽略NUll
     *
     */
    @Test
    public void updateByMap() {
        Account account = new Account();
        account.setUserName("小明2");

        Map<String, Object> map = new HashMap<>();
        map.put("id","72");
        int row = accountMapper.updateByMap(account,map);
        System.err.println("修改数量:" + row + "条");
    }

4.updateByMap(entity, ignoreNulls, whereConditions)：根据 Map 构建的条件来更新数据。忽略null

    /**
     * updateByMap(entity, ignoreNulls, whereConditions)：根据 Map 构建的条件来更新数据。
     * 忽略null
     */
    @Test
    public void updateByMap2() {
        Account account = new Account();
//        account.setUserName("小明2");
        account.setUserName(null); //会报错

        Map<String, Object> map = new HashMap<>();
        map.put("id","72");
        int row = accountMapper.updateByMap(account,true,map);
        System.err.println("修改数量:" + row + "条");
    }

5.updateByCondition(entity, whereConditions)：根据查询条件来更新数据。不忽略NUll

    /**
     * updateByCondition(entity, whereConditions)：根据查询条件来更新数据。
     * 不忽略NUll
     */
    @Test
    public void updateByCondition() {
        Account account = new Account();
        account.setUserName("剑南山2");
//        account.setUserName(null); //会报错

        //  update tb_account set user_name="剑南山2" , age=21   where id = 73
//        int row = accountMapper.updateByCondition(account,ACCOUNT.ID.eq("73"));

        //   update tb_account set user_name="剑南山2" , age=21   where id > 73
        int row = accountMapper.updateByCondition(account,ACCOUNT.ID.gt(73));
        System.err.println("修改数量:" + row + "条");
    }

6.updateByCondition(entity, ignoreNulls, whereConditions)：根据查询条件来更新数据。忽略NUll,传入空不修改

    /**
     * updateByCondition(entity, ignoreNulls, whereConditions)：根据查询条件来更新数据。
     * 忽略NUll,传入空不修改
     */
    @Test
    public void updateByCondition2() {
        Account account = new Account();
        account.setUserName(null); //默认不修改
        account.setAge(18);
//        account.setUserName(null); //会报错

        // update tb_account set  age=18  where id = 73
//        int row = accountMapper.updateByCondition(account,ACCOUNT.ID.eq("73"));
        // update tb_account set  age=18  where id > 73
        int row = accountMapper.updateByCondition(account,true,ACCOUNT.ID.gt(73));
        System.err.println("修改数量:" + row + "条");
    }

7.updateByQuery(entity, queryWrapper)：根据查询条件来更新数据。不忽略NUll

    /**
     * updateByQuery(entity, queryWrapper)：根据查询条件来更新数据。
     * 不忽略NUll
     */
    @Test
    public void updateByQuery() {
        Account account = new Account();
        account.setUserName("神奇的小鱼人");
        account.setAge(20);

        QueryWrapper queryWrapper = new QueryWrapper();

        // update tb_account set user_name="神奇的小鱼人" , age=21   where id = 73 or id = 74
        queryWrapper.where(ACCOUNT.ID.eq(73)).or(ACCOUNT.ID.eq(74));

        int row = accountMapper.updateByQuery(account,queryWrapper);
        System.err.println("修改数量:" + row + "条");
    }

7.updateByQuery(entity, ignoreNulls, queryWrapper)：根据查询条件来更新数据。忽略NUll

    /**
     * updateByQuery(entity, ignoreNulls, queryWrapper)：根据查询条件来更新数据。
     * 忽略NUll
     */
    @Test
    public void updateByQuery2() {
        Account account = new Account();
        account.setUserName(null); //忽略NULL 不进行update
        account.setAge(20);

        QueryWrapper queryWrapper = new QueryWrapper();

        // update tb_account set  age=21   where id = 73 or id = 74
        queryWrapper.where(ACCOUNT.ID.eq(73)).or(ACCOUNT.ID.eq(74));

        int row = accountMapper.updateByQuery(account,queryWrapper);
        System.err.println("修改数量:" + row + "条");
    }

8.updateByQuery(entity, ignoreNulls, queryWrapper)：根据查询条件来更新数据。不忽略NUll

  /**
     * updateByQuery(entity, ignoreNulls, queryWrapper)：根据查询条件来更新数据。
     * ignoreNulls:false  忽略NUll
     * ignoreNulls:true  不忽略NUll
     *
     */
    @Test
    public void updateByQuery2() {
        Account account = new Account();
        account.setUserName(null); //忽略NULL 不进行update
        account.setAge(20);

        QueryWrapper queryWrapper = new QueryWrapper();

        // update tb_account set  age=21   where id = 73 or id = 74
        queryWrapper.where(ACCOUNT.ID.eq(73)).or(ACCOUNT.ID.eq(74));

        int row = accountMapper.updateByQuery(account,false,queryWrapper);
        System.err.println("修改数量:" + row + "条");
    }

9. 部分字段更新 update

(1) 部分字段

在很多场景下，我们希望只更新部分字段，而更新的字段中，一些为 null，一些非 null。此时需要用到 UpdateEntity 工具类，以下是示例代码：

以下的示例中，会把 id (主键)为 100 这条数据中的 user_name 字段更新为 null，age 字段更新为 10，其他字段不会被更新。

也就是说，通过 UpdateEntity 创建的对象，只会更新调用了 setter 方法的字段，若不调用 setter 方法，不管这个对象里的属性的值是什么，都不会更新到数据库。

    /**
     * updateByQuery(entity, ignoreNulls, queryWrapper)：根据查询条件来更新数据。
     * 不忽略NUll
     */
    @Test
    public void UpdateEntity () {
        //update tb_account
        //set user_name = ?, age = ? where id = ?
        //#参数: null,10,100

        //写法1 不忽略NUll
//        Account account = UpdateEntity.of(Account.class, 100);
        //写法2 不忽略NUll
//        Account account = UpdateEntity.of(Account.class);
//        account.setId(74);

        //写法3 忽略null
        //update tb_account
        //set  age = ? where id = ?
        //#参数: 10,100
        Account account = new Account();
        account.setId(74);
        account.setUserName(null);
        account.setAge(11);

        int row = accountMapper.update(account);
        System.err.println("修改数量:" + row + "条");
    }

(2) 部分字段更新（增强）

    /**
     * 部分字段更新（增强）
     */
    @Test
    public void UpdateEntity2 () {
        Account account = UpdateEntity.of(Account.class, 100);

        account.setUserName(null);

        // 通过 UpdateWrapper 操作 account 数据
        UpdateWrapper wrapper = UpdateWrapper.of(account);
        wrapper.setRaw("age", "age + 1");

        accountMapper.update(account);

        // update tb_account
        //set user_name = null, age = age + 1 where id = 100
        int row = accountMapper.update(account);
        System.err.println("修改数量:" + row + "条");
    }

(3) 更高级的用法

    /**
     * 更高级的用法2
     */
    @Test
    public void UpdateEntity4 () {
        Account account = UpdateEntity.of(Account.class, 100);

//        account.setUserName("Michael2");
// 通过 UpdateWrapper 操作 account 数据
        UpdateWrapper wrapper = UpdateWrapper.of(account);
//        wrapper.setRaw(ACCOUNT.AGE, "(select a.age from (select age from tb_account where id = 101) a )");
        
        
        wrapper.set(ACCOUNT.USER_NAME, "(select name from tb_account where id = 101)");

        accountMapper.update(account);

        int row = accountMapper.update(account);
        System.err.println("修改数量:" + row + "条");
    }

10. 链式修改-UpdateChain

UpdateChain 是一个对 UpdateEntity、UpdateWrapper 等进行封装的一个工具类，方便用户用于进行链式操作。

假设我们要更新 Account 的 userName 为 "张三"，更新年龄在之前的基础上加 1，更新代码如下：

    /**
     * UpdateChain 是一个对 UpdateEntity、UpdateWrapper 等进行封装的一个工具类，方便用户用于进行链式操作。
     * 不忽略空
     * UPDATE `tb_account` SET `user_name` = '张三' , `age` = age + 1
     * WHERE `id` = 1
     *
     * UPDATE `tb_account` SET `user_name` = null , `age` = age + 1
     * WHERE `id` = 1
     */
    @Test
    public void testUpdateChain() {
        UpdateChain.of(Account.class)
//                .set(Account::getUserName, "张三")
                .set(Account::getUserName, null)
                .setRaw(Account::getAge, "age + 1")
                .where(Account::getId).eq(1)
                .update();
    }

    /**
     * 假设我们要更新 Account 的 userName 为 "张三"，更新年龄在之前的基础上加 1，更新代码如下：
     * UPDATE `tb_account` SET `age` = `age` + 1
     * WHERE  `id` >= 100 AND `age` = 18
     *
     */
    @Test
    public void testUpdateChain2() {

        //更新数据
      UpdateChain.of(Account.class)
                .set(Account::getAge, ACCOUNT.AGE.add(1))
                .where(Account::getId).ge(100)
                .and(Account::getAge).eq(18)
                .update();

        //查询所有数据并打印
        QueryChain.of(accountMapper)
                .where(Account::getId).ge(100)
                .and(Account::getAge).eq(18)
                .list()
                .forEach(System.out::println);
    }

四基础查询

单条数据查询

在 MyBatis-Flex 的 BaseMapper 中，提供了如下的功能用于查询数据库的数据：

selectOneById(id)：根据主键查询数据。
selectOneByEntityId(entity)：根据实体主键查询数据，便于对复合主键实体类的查询。
selectOneByMap(whereConditions)：根据 Map 构建的条件来查询数据。
selectOneByCondition(whereConditions)：根据查询条件查询数据。
selectOneByQuery(queryWrapper)：根据查询条件来查询 1 条数据。
selectOneByQueryAs(queryWrapper, asType)：根据查询条件来查询 1 条数据。
selectOneWithRelationsByMap(whereConditions)：根据 Map 构建的条件来查询 1 条数据。
selectOneWithRelationsByCondition(whereConditions)：根据查询条件查询 1 条数据。
selectOneWithRelationsByQuery(queryWrapper)：根据查询条件来查询 1 条数据。
selectOneWithRelationsByQueryAs(queryWrapper, asType)：根据查询条件来查询 1 条数据。
selectListByIds(ids)：根据多个主键来查询多条数据。
selectListByMap(whereConditions)：根据 Map 来构建查询条件，查询多条数据。
selectListByMap(whereConditions, count)：根据 Map 来构建查询条件，查询多条数据。
selectListByCondition(whereConditions)：根据查询条件查询多条数据。
selectListByCondition(whereConditions, count)：根据查询条件查询多条数据。
selectListByQuery(queryWrapper)：根据查询条件查询数据列表。
selectListByQuery(queryWrapper, consumers)：根据查询条件查询数据列表。
selectCursorByQuery(queryWrapper)：根据查询条件查询游标数据，该方法必须在事务中才能正常使用，非事务下无法获取数据。
selectRowsByQuery(queryWrapper)：根据查询条件查询 Row 数据。
selectListByQueryAs(queryWrapper, asType)：根据查询条件查询数据列表，要求返回的数据为 asType。这种场景一般用在 left join 时，有多出了实体类本身的字段内容，可以转换为 dto、vo 等场景。
selectListByQueryAs(queryWrapper, asType, consumers)：根据查询条件查询数据列表，要求返回的数据为 asType 类型。
selectListWithRelationsByQuery(queryWrapper)：查询实体类及其 Relation 注解字段。
selectListWithRelationsByQueryAs(queryWrapper, asType)：查询实体类及其 Relation 注解字段。
selectListWithRelationsByQueryAs(queryWrapper, asType, consumers)：查询实体类及其 Relation 注解字段。
selectAll()：查询全部数据。
selectAllWithRelations()：查询全部数据，及其 Relation 字段内容。
selectObjectByQuery(queryWrapper)：查询第一列返回的数据，QueryWrapper 执行的结果应该只有 1 列，例如：QueryWrapper.create().select(ACCOUNT.id).where(...);
selectObjectByQueryAs(queryWrapper, asType)：查询第一列返回的数据，QueryWrapper 执行的结果应该只有 1 列，例如：QueryWrapper.create().select(ACCOUNT.id).where(...);
selectObjectListByQuery(queryWrapper)：查询第一列返回的数据集合，QueryWrapper 执行的结果应该只有 1 列，例如：QueryWrapper.create().select(ACCOUNT.id).where(...);
selectObjectListByQueryAs(queryWrapper, asType)：查询第一列返回的数据集合，QueryWrapper 执行的结果应该只有 1 列，例如：QueryWrapper.create().select(ACCOUNT.id).where(...);
selectCountByQuery(queryWrapper)：查询数据量。
selectCountByCondition(whereConditions)：根据条件查询数据总量。

1. selectOneById(id)：根据主键查询数据。

    /**
     * selectOneById(id)：根据主键查询数据。
     */
    @Test
    public void testUpdateChain() {
        Account account = accountMapper.selectOneById(1L);
        System.err.println("==============");
        System.err.println(account);
        System.err.println("==============");
    }

2.`selectOneByEntityId(entity)`：根据实体主键查询数据，便于对复合主键实体类的查询。

只能根据主键查询

    /**
     * selectOneByEntityId(entity)：根据实体主键查询数据，便于对复合主键实体类的查询。
     */
    @Test
    public void selectOneByEntityId() {
        Account param = new Account();
        param.setId(1);
        Account account = accountMapper.selectOneByEntityId(param);
        System.err.println("==============");
        System.err.println(account);
        System.err.println("==============");

        Account param2 = new Account();
        param.setAge(18);
        param.setUserName("剑南山2");
        Account account2 = accountMapper.selectOneByEntityId(param2);
        System.err.println("==============");
        System.err.println(account2);
        System.err.println("==============");
    }

3.`selectOneByMap(whereConditions)`：根据 Map 构建的条件来查询数据。

    /**
     * selectOneByMap(whereConditions)：根据 Map 构建的条件来查询数据。
     * 
     * selectOneByMap(Map<String, Object> whereConditions)
     */
    @Test
    public void selectOneByMap() {
        Map<String,Object> param = new HashMap<>();
        param.put("id",2);
        param.put("user_name","李四");
        Account account = accountMapper.selectOneByMap(param);
        System.err.println("==============");
        System.err.println(account);
        System.err.println("==============");
    }

4.selectOneByCondition(whereConditions)：根据查询条件查询数据。

    /**
     * selectOneByCondition(whereConditions)：根据查询条件查询数据。
     *
     * selectOneByCondition(QueryCondition whereConditions)
     */
    @Test
    public void selectOneByCondition() {
        Account account = accountMapper.selectOneByCondition(ACCOUNT.ID.eq(2)
                .or(ACCOUNT.ID.eq(1)));
        System.err.println("==============");
        System.err.println(account);
        System.err.println("==============");
    }

5. selectOneByQuery(queryWrapper)：根据查询条件来查询 1 条数据。

    /**
     * selectOneByQuery(queryWrapper)：根据查询条件来查询 1 条数据。
     * selectOneByQuery(QueryWrapper queryWrapper)
     */
    @Test
    public void selectOneByQuery() {
        QueryWrapper param = new QueryWrapper();
        // where id = 1
//        param.where(ACCOUNT.ID.eq(1));
        
        //SELECT `id`, `user_name`, `age`, `birthday` FROM `tb_account` WHERE `user_name` LIKE ? LIMIT 1
        //Parameters: %李四%(String)
        param.where(ACCOUNT.USER_NAME.like("李四"));
        Account account = accountMapper.selectOneByQuery(param);
        System.err.println("==============");
        System.err.println(account);
        System.err.println("==============");
    }

6. selectOneWithRelationsByMap(whereConditions)：根据 Map 构建的条件来查询 1 条数据。

    /**
     * selectOneWithRelationsByMap(whereConditions)：根据 Map 构建的条件来查询 1 条数据。
     *
     * selectOneWithRelationsByMap(Map<String, Object> whereConditions)
     */
    @Test
    public void selectOneWithRelationsByMap() {
        Map<String,Object> param = new HashMap<>();
        param.put("id",1);

        // Preparing:  SELECT `id`, `user_name`, `age`, `birthday` FROM `tb_account` WHERE `tb_account`.`id` = ? LIMIT 1
        // Parameters: 1(Integer)
        Account account = accountMapper.selectOneWithRelationsByMap(param);
        System.err.println("==============");
        System.err.println(account);
        System.err.println("==============");
    }

7.selectOneWithRelationsByCondition(whereConditions)：根据查询条件查询 1 条数据。

    /**
     * selectOneWithRelationsByCondition(whereConditions)：根据查询条件查询 1 条数据。
     */
    @Test
    public void selectOneWithRelationsByCondition() {  
        // Preparing:  SELECT `id`, `user_name`, `age`, `birthday` FROM `tb_account` WHERE `tb_account`.`id` = ? LIMIT 1
        // Parameters: 1(Integer)
        Account account = accountMapper.selectOneWithRelationsByCondition(ACCOUNT.ID.eq(1));
        System.err.println("==============");
        System.err.println(account);
        System.err.println("==============");
    }

8.selectOneWithRelationsByQuery(queryWrapper)：根据查询条件来查询 1 条数据。

    /**
     * selectOneWithRelationsByQuery(queryWrapper)：根据查询条件来查询 1 条数据。
     */
    @Test
    public void selectOneWithRelationsByQuery() {
        // Preparing:  SELECT `id`, `user_name`, `age`, `birthday` FROM `tb_account` WHERE `tb_account`.`id` = ? LIMIT 1
        // Parameters: 1(Integer)
        QueryWrapper param = new QueryWrapper();
        param.where(ACCOUNT.ID.eq(1));
        Account account = accountMapper.selectOneWithRelationsByQuery(param);
        System.err.println("==============");
        System.err.println(account);
        System.err.println("==============");
    }

9.selectOneWithRelationsByQueryAs(queryWrapper, asType)：根据查询条件来查询 1 条数据。

    /**
     * selectOneWithRelationsByQueryAs(queryWrapper, asType)：根据查询条件来查询 1 条数据。
     */
    @Test
    public void selectOneWithRelationsByQueryAs() {
        // Preparing:  SELECT `id`, `user_name`, `age`, `birthday` FROM `tb_account` WHERE `tb_account`.`id` = ? LIMIT 1
        // Parameters: 1(Integer)
        QueryWrapper param = new QueryWrapper();
        param.where(ACCOUNT.ID.eq(1));
        Account account = accountMapper.selectOneWithRelationsByQueryAs(param,Account.class);
        System.err.println("==============");
        System.err.println(account);
        System.err.println("==============");
    }

多条数据查询

1.selectListByIds(ids)：根据多个主键来查询多条数据。

    /**
     * selectListByIds(ids)：根据多个主键来查询多条数据。
     * selectListByIds(@Param("$$primaryValue") Collection<? extends Serializable> var1)
     */
    @Test
    public void selectListByIds() {
        List<Integer> param = Arrays.asList(1, 2);
        //Preparing: SELECT `id`, `user_name`, `age`, `birthday` FROM `tb_account` WHERE `id` = ? OR `id` = ?
        //Parameters: 1(Integer), 2(Integer)
        //==============
        //Account(id=1, userName=null, age=20, birthday=2020-01-11T00:00)
        //Account(id=2, userName=李四, age=19, birthday=2021-03-21T00:00)
        //==============
        List<Account> accounts = accountMapper.selectListByIds(param);
        System.err.println("==============");
        accounts.forEach(System.err::println);
        System.err.println("==============");
    }

2.selectListByMap(whereConditions)：根据 Map 来构建查询条件，查询多条数据。

    /**
     * selectListByMap(whereConditions)：根据 Map 来构建查询条件，查询多条数据。
     */
    @Test
    public void selectListByMap() {
        Map<String, Object> param = new HashMap<>();
        param.put("user_name","剑南山2");
        //Preparing: SELECT `id`, `user_name`, `age`, `birthday` FROM `tb_account` WHERE `tb_account`.`user_name` = ?
        //Parameters: 剑南山2(String)
        //==============
        //Account(id=99, userName=剑南山2, age=18, birthday=2023-12-29T18:17:31)
        //Account(id=101, userName=剑南山2, age=19, birthday=2020-01-11T00:00)
        //==============
        List<Account> accounts = accountMapper.selectListByMap(param);
        System.err.println("==============");
        accounts.forEach(System.err::println);
        System.err.println("==============");
    }

3.`selectListByMap(whereConditions, count)`：根据 Map 来构建查询条件，查询多条数据。

    /**
     * selectListByMap(whereConditions, count)：根据 Map 来构建查询条件，查询多条数据。
     * SELECT `id`, `user_name`, `age`, `birthday` FROM `tb_account` WHERE `tb_account`.`user_name` = ? LIMIT 2
     *
     */
    @Test
    public void selectListByMap2() {
        Map<String, Object> param = new HashMap<>();
        param.put("user_name","剑南山2");
        // QueryWrapper.create().where(whereConditions).limit(count)
        List<Account> accounts = accountMapper.selectListByMap(param,2L);
        System.err.println("==============");
        accounts.forEach(System.err::println);
        System.err.println("==============");
    }

4.`selectListByCondition(whereConditions)`：根据查询条件查询多条数据。

 /**
     * selectListByCondition(whereConditions)：根据查询条件查询多条数据。
     * SELECT `id`, `user_name`, `age`, `birthday` FROM `tb_account` WHERE `id` = ?
     *  Parameters: 1
     *  
     * SELECT `id`, `user_name`, `age`, `birthday` FROM `tb_account` WHERE `user_name` LIKE ?
     *  Parameters: %李%(String)
     */
    @Test
    public void selectListByCondition() {
//        List<Account> accounts = accountMapper.selectListByCondition(ACCOUNT.ID.eq(1));
        List<Account> accounts = accountMapper.selectListByCondition(ACCOUNT.USER_NAME.like("李"));
        System.err.println("==============");
        accounts.forEach(System.err::println);
        System.err.println("==============");
    }

5.`selectListByCondition(whereConditions, count)`：根据查询条件查询多条数据。

/**
     * selectListByCondition(whereConditions, count)：根据查询条件查询多条数据。
     *
     * SELECT `id`, `user_name`, `age`, `birthday` FROM `tb_account` WHERE `user_name` LIKE ? LIMIT 2
     * Parameters: %李%(String)
     *
     */
    @Test
    public void selectListByCondition2() {
        List<Account> accounts = accountMapper.selectListByCondition(ACCOUNT.USER_NAME.like("李"),2L);
        System.err.println("==============");
        accounts.forEach(System.err::println);
        System.err.println("==============");
    }

6.`selectListByQuery(queryWrapper)`：根据查询条件查询数据列表。(比较常用)

 /**
     * selectListByQuery(queryWrapper)：根据查询条件查询数据列表。
     *
     * 方法1 类似于selectListByMap用法
     * SELECT `id`, `user_name`, `age`, `birthday` FROM `tb_account` WHERE `tb_account`.`id` = ? LIMIT 10
     * Parameters: 1(String)
     *
     * 方法2 类似于selectListByCondition用法
     * SELECT `id`, `user_name`, `age`, `birthday` FROM `tb_account` WHERE `user_name` LIKE ? LIMIT 10
     * Parameters: %李%(String)
     */
    @Test
    public void selectListByQuery() {
        //方法1 类似于selectListByMap
        /*Map<String,Object> map = new HashMap<>();
        map.put("id","1");
        List<Account> accounts = accountMapper.selectListByQuery(QueryWrapper.create().where(map).limit(10));
        */

        // 方法2 类似于selectListByCondition用法
//        List<Account> accounts = accountMapper.selectListByQuery(QueryWrapper.create().where(ACCOUNT.USER_NAME.like("李")).limit(10));

        // 方法3 new QueryWrapper() 也类似于selectListByCondition用法
        QueryWrapper queryWrapper = new QueryWrapper();
        List<Account> accounts = accountMapper.selectListByQuery(queryWrapper.where(ACCOUNT.USER_NAME.like("李")));

        System.err.println("==============");
        accounts.forEach(System.err::println);
        System.err.println("==============");
    }

7. `selectListByQueryAs(queryWrapper, asType)`：根据查询条件查询数据列表，要求返回的数据为 asType。这种场景一般用在 left join 时，有多出了实体类本身的字段内容，可以转换为 dto、vo 等场景。(相对常用)

 /**
     * selectListByQueryAs(queryWrapper, asType)：根据查询条件查询数据列表，要求返回的数据为 asType。这种场景一般用在 left join 时
     * ，有多出了实体类本身的字段内容，可以转换为 dto、vo 等场景。
     * 
     * select a.*, b.title, b.content
     * from tb_account a
     * left join tb_book b on a.id = b.account_id
     * where a.id = 1
     */
    @Test
    public void selectListByQueryAs() {
        QueryWrapper queryWrapper = new QueryWrapper();
//        List<Row> accounts = accountMapper.selectListByQueryAs(QueryWrapper.create().where(ACCOUNT.ID.eq(1)), Row.class);
//        List<Account> accounts = accountMapper.selectListByQueryAs(  QueryWrapper.create().where(ACCOUNT.ID.eq(1)) , Account.class);
        List<AccountDto> accounts = accountMapper.selectListByQueryAs(
                QueryWrapper.create().select(ACCOUNT.ALL_COLUMNS, BOOK.TITLE, BOOK.CONTENT)
                        .from(ACCOUNT).as("a")
                        .leftJoin(BOOK).as("b").on(ACCOUNT.ID.eq(BOOK.ACCOUNT_ID))
                        .where(ACCOUNT.ID.eq(1))
                , AccountDto.class);

        System.err.println("==============");
        accounts.forEach(System.err::println);
        System.err.println("==============");
    }

8.selectListWithRelationsByQuery(queryWrapper)：查询实体类及其 Relation 注解字段。

    /**
     * selectListWithRelationsByQuery(queryWrapper)：查询实体类及其 Relation 注解字段。
     *
     */
    @Test
    public void selectListWithRelationsByQuery() {
        List<Account> accounts = accountMapper.selectListWithRelationsByQuery(
                QueryWrapper.create().where(ACCOUNT.ID.eq(1)));
        System.err.println("==============");
        accounts.forEach(System.err::println);
        System.err.println("==============");
    }

9.`selectListWithRelationsByQueryAs(queryWrapper, asType)`：查询实体类及其 Relation 注解字段。

    /**
     * selectListWithRelationsByQueryAs(queryWrapper, asType)：查询实体类及其 Relation 注解字段。
     *
     */
    @Test
    public void selectListWithRelationsByQueryAs() {
        List<Account> accounts = accountMapper.selectListWithRelationsByQueryAs(QueryWrapper.create().where(ACCOUNT.ID.eq(1))
                ,Account.class);
        System.err.println("==============");
        accounts.forEach(System.err::println);
        System.err.println("==============");
    }

10. selectAll()：查询全部数据。

    /**
     * selectAll()：查询全部数据。
     * SELECT `id`, `user_name`, `age`, `birthday` FROM `tb_account`
     */
    @Test
    public void selectAll() {
        List<Account> accounts = accountMapper.selectAll();
        List<Account> accounts2 = accountMapper.selectAllWithRelations();
        System.err.println("==============");
        accounts.forEach(System.err::println);
        System.err.println("==============");
    }

11. `selectAllWithRelations()`：查询全部数据，及其 Relation 字段内容。

    /**
     * selectAllWithRelations()：查询全部数据，及其 Relation 字段内容。
     * SELECT `id`, `user_name`, `age`, `birthday` FROM `tb_account`
     */
    @Test
    public void selectAllWithRelations() {
        List<Account> accounts = accountMapper.selectAllWithRelations();
        System.err.println("==============");
        accounts.forEach(System.err::println);
        System.err.println("==============");
    }

12.`selectObjectByQuery(queryWrapper)`：查询第一列返回的数据，QueryWrapper 执行的结果应该只有 1 列，例如：`QueryWrapper.create().select(ACCOUNT.id).where(...);`

    /**
     * selectObjectByQuery(queryWrapper)：
     * 查询第一列返回的数据，QueryWrapper 执行的结果应该只有 1 列，
     * 例如：QueryWrapper.create().select(ACCOUNT.id).where(...);
     *
     * SELECT `user_name` FROM `tb_account` WHERE `id` = ?
     * 
     * 只能返回一列 并且只有一条 
     * 多条会报错,多条只返回第一列的第一个
     */
    @Test
    public void selectAllWithRelations() {
        Object accounts = accountMapper.selectObjectByQuery(QueryWrapper.create()
                .select(ACCOUNT.USER_NAME)
                .where(ACCOUNT.ID.eq(1)));
        System.err.println("==============");
        System.err.println(accounts);
        System.err.println("==============");
    }

13.`selectObjectByQueryAs(queryWrapper, asType)`：查询第一列返回的数据，QueryWrapper 执行的结果应该只有 1 列，例如：`QueryWrapper.create().select(ACCOUNT.id).where(...);`

 SELECT `user_name` FROM `tb_account` WHERE `id` = ? OR `id` = ?
 Parameters: 1(Integer), 2(Integer)

 结果:
 ==============
 [小明, 李四]
 ==============

    /**
     * selectObjectListByQuery(queryWrapper)：查询第一列返回的数据集合，QueryWrapper 执行的结果应该只有 1 列，
     * 例如：QueryWrapper.create().select(ACCOUNT.id).where(...);
     *
     * SELECT `user_name` FROM `tb_account` WHERE `id` = ? OR `id` = ?
     * Parameters: 1(Integer), 2(Integer)
     *
     * 结果:
     * ==============
     * [小明, 李四]
     * ============== 
     */
    @Test
    public void selectObjectListByQuery() {
        List<Object> accounts = accountMapper.selectObjectListByQuery(QueryWrapper.create()
                .select(ACCOUNT.USER_NAME)
                .where(ACCOUNT.ID.eq(1)).or(ACCOUNT.ID.eq(2)));
        System.err.println("==============");
        System.err.println(accounts);
        System.err.println("==============");
    }

14.`selectObjectListByQueryAs(queryWrapper, asType)`：查询第一列返回的数据集合，QueryWrapper 执行的结果应该只有 1 列，例如：

    /**
     * selectObjectListByQueryAs(queryWrapper, asType)：
     * 查询第一列返回的数据集合，QueryWrapper 执行的结果应该只有 1 列，例如：
     *
     */
    @Test
    public void selectObjectListByQueryAs() {
        List<Account> accounts = accountMapper.selectObjectListByQueryAs(QueryWrapper.create()
                .select(ACCOUNT.USER_NAME)
                .where(ACCOUNT.ID.eq(1)).or(ACCOUNT.ID.eq(2)),Account.class);
        System.err.println("==============");
        System.err.println(accounts);
        System.err.println("==============");
    }

15.`selectCountByQuery(queryWrapper)`：查询数据量。

    /**
     * selectCountByQuery(queryWrapper)：查询数据量。
     * SELECT COUNT(*) FROM `tb_account` WHERE `id` = ? OR `id` = ?
     * Parameters: 1(Integer), 2(Integer)
     *
     * 结果:
     * ==============
     * 2
     * ==============
     */
    @Test
    public void selectCountByQuery() {
        long account = accountMapper.selectCountByQuery(QueryWrapper.create()
                .select(ACCOUNT.USER_NAME)
                .where(ACCOUNT.ID.eq(1)).or(ACCOUNT.ID.eq(2)));
        System.err.println("==============");
        System.err.println(account);
        System.err.println("==============");
    }

16 `selectCountByCondition(whereConditions)`：根据条件查询数据总量。

    /**
     * selectCountByCondition(whereConditions)：根据条件查询数据总量。
     * SELECT COUNT(*) FROM `tb_account` WHERE `id` = ? OR `id` = ?
     * Parameters: 1(Integer), 2(Integer)
     *
     * 结果:
     * ==============
     * 2
     * ==============
     */
    @Test
    public void selectCountByCondition() {
        long account = accountMapper.selectCountByCondition(ACCOUNT.ID.eq(1)
                .or(ACCOUNT.ID.eq(2)));
        System.err.println("==============");
        System.err.println(account);
        System.err.println("==============");
    }

未完待更...