mybatis-flex笔记

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

https://gitee.com/hntianshu/mybatis-flex-test.githttp://xn--ces6a538pmb2a

一新增数据

不忽略 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)：根据查询条件来更新数据。
     * 不忽略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 + "条");
    }