import com.baomidou.mybatisplus.mapper.Wrapper; //导入依赖的package包/类
/**
 * 测试 Condition orderBy
 */
@Test
public void testConditionOrderBys() {
    //空集合测试
    List<String> orders = null;
    Wrapper wrapper = Condition.create();
    wrapper.orderAsc(orders);
    Assert.assertNull(wrapper.getSqlSegment());
    orders = new ArrayList<>(3);
    wrapper.orderAsc(orders);
    Assert.assertNull(wrapper.getSqlSegment());
    orders.add("id1");
    orders.add("id2");
    orders.add("id3");
    wrapper.orderAsc(orders);
    Assert.assertEquals("ORDER BY id1 ASC, id2 ASC, id3 ASC", wrapper.getSqlSegment());
    wrapper.orderDesc(orders);
    Assert.assertEquals("ORDER BY id1 ASC, id2 ASC, id3 ASC, id1 DESC, id2 DESC, id3 DESC", wrapper.getSqlSegment());
}
 

import com.baomidou.mybatisplus.mapper.Wrapper; //导入依赖的package包/类
/**
 * <p>
 * 执行 SQL 更新
 * </p>
 *
 * @param wrapper
 * @return
 */
@Transactional
public boolean update(Wrapper wrapper) {
    Map<String, Object> map = new HashMap<>();
    map.put("et", this);
    map.put("ew", wrapper);
    // update
    return SqlHelper.retBool(sqlSession().update(sqlStatement(SqlMethod.UPDATE), map));
}
 

import com.baomidou.mybatisplus.mapper.Wrapper; //导入依赖的package包/类
/**
 * 测试 Condition orderBy
 */
@Test
public void testConditionOrderBy() {
    Wrapper wrapper = Condition.create().orderBy("id desc");
    System.out.println(wrapper.getSqlSegment());
    Assert.assertEquals("ORDER BY id desc", wrapper.getSqlSegment());
}
 

import com.baomidou.mybatisplus.mapper.Wrapper; //导入依赖的package包/类
@Transactional
public boolean delete(Wrapper wrapper) {
    return retBool(baseMapper.delete(wrapper));
}
 

import com.baomidou.mybatisplus.mapper.Wrapper; //导入依赖的package包/类
@Transactional
public boolean update(T entity, Wrapper wrapper) {
    return retBool(baseMapper.update(entity, wrapper));
}
 

import com.baomidou.mybatisplus.mapper.Wrapper; //导入依赖的package包/类
public T selectOne(Wrapper wrapper) {
    return SqlHelper.getObject(baseMapper.selectList(wrapper));
}
 

import com.baomidou.mybatisplus.mapper.Wrapper; //导入依赖的package包/类
public Map<String, Object> selectMap(Wrapper wrapper) {
    return SqlHelper.getObject(baseMapper.selectMaps(wrapper));
}
 

import com.baomidou.mybatisplus.mapper.Wrapper; //导入依赖的package包/类
public Object selectObj(Wrapper wrapper) {
    return SqlHelper.getObject(baseMapper.selectObjs(wrapper));
}
 

import com.baomidou.mybatisplus.mapper.Wrapper; //导入依赖的package包/类
public int selectCount(Wrapper wrapper) {
    return SqlHelper.retCount(baseMapper.selectCount(wrapper));
}
 

import com.baomidou.mybatisplus.mapper.Wrapper; //导入依赖的package包/类
public List<T> selectList(Wrapper wrapper) {
    return baseMapper.selectList(wrapper);
}
 

import com.baomidou.mybatisplus.mapper.Wrapper; //导入依赖的package包/类
public List<Map<String, Object>> selectMaps(Wrapper wrapper) {
    return baseMapper.selectMaps(wrapper);
}
 

import com.baomidou.mybatisplus.mapper.Wrapper; //导入依赖的package包/类
public List<Object> selectObjs(Wrapper wrapper) {
    return baseMapper.selectObjs(wrapper);
}
 

import com.baomidou.mybatisplus.mapper.Wrapper; //导入依赖的package包/类
@SuppressWarnings({"rawtypes", "unchecked"})
public Page<Map<String, Object>> selectMapsPage(Page page, Wrapper wrapper) {
    SqlHelper.fillWrapper(page, wrapper);
    page.setRecords(baseMapper.selectMapsPage(page, wrapper));
    return page;
}
 

import com.baomidou.mybatisplus.mapper.Wrapper; //导入依赖的package包/类
public Page<T> selectPage(Page<T> page, Wrapper wrapper) {
    SqlHelper.fillWrapper(page, wrapper);
    page.setRecords(baseMapper.selectPage(page, wrapper));
    return page;
}
 

import com.baomidou.mybatisplus.mapper.Wrapper; //导入依赖的package包/类
/**
 * @param t
 * @return
 */
@Transactional
public Integer deleteByEntity(T t) {
    Wrapper<T> wrapper = new EntityWrapper<T>(t);
    return mapper.delete(wrapper);
}
 

import com.baomidou.mybatisplus.mapper.Wrapper; //导入依赖的package包/类
@Transactional
public Integer deleteByEntity(T t) {
	Wrapper<T> wrapper = new EntityWrapper<T>(t);
	return mapper.delete(wrapper);
}
 

import com.baomidou.mybatisplus.mapper.Wrapper; //导入依赖的package包/类
public List<T> selectList(Wrapper<T> entity) {
	return mapper.selectList(entity);
}
 

import com.baomidou.mybatisplus.mapper.Wrapper; //导入依赖的package包/类
public List<SysUserRole> getRolesByUserId(Long userId) {
	SysUserRole sysUserRole = new SysUserRole(userId, null);
	Wrapper<SysUserRole> wrapper = new EntityWrapper<SysUserRole>(sysUserRole);
	List<SysUserRole> userRoles = sysUserRoleMapper.selectList(wrapper);
	return userRoles;
}
 

import com.baomidou.mybatisplus.mapper.Wrapper; //导入依赖的package包/类
/**
 * 查询符合条件的第一条数据
 *
 * @param entity 查询条件
 */
public T selectOne(Wrapper<T> entity) {
    List<T> list = mapper.selectList(entity);
    if (list.size() == 0) return null;
    return list.get(0);
}
 

import com.baomidou.mybatisplus.mapper.Wrapper; //导入依赖的package包/类
/**
 * 全局配置测试
 */
@org.junit.Test
public void testGlobalConfig() {
    SqlSession session = this.sqlSessionFactory().openSession(false);
    TestMapper testMapper = session.getMapper(TestMapper.class);
    /*Wrapper type = Condition.instance().eq("id",1).or().in("type", new Object[]{1, 2, 3, 4, 5, 6});
    List list = testMapper.selectList(type);
    System.out.println(list.toString());*/
    Test test = new Test();
    test.setCreateTime(new Date());
    // 开启全局校验字符串会忽略空字符串
    test.setType("");
    testMapper.insert(test);

    SqlSession sqlSession = this.sqlSessionFactory().openSession(false);
    NotPKMapper pkMapper = sqlSession.getMapper(NotPKMapper.class);
    NotPK notPK = new NotPK();
    notPK.setUuid(UUID.randomUUID().toString());
    notPK.setIs(true);
    notPK.setIsis(false);
    int num = pkMapper.insert(notPK);
    Assert.assertTrue(num > 0);
    NotPK notPK1 = pkMapper.selectOne(notPK);
    Assert.assertNotNull(notPK1);
    List<NotPK> notPKS = pkMapper.selectPage(RowBounds.DEFAULT, new EntityWrapper<>(notPK));
    System.out.println(notPKS);
    Wrapper type = Condition.create().eq("type", 12121212);
    Assert.assertFalse(type.isEmptyOfWhere());
    System.out.println(type.getSqlSegment());
    Assert.assertFalse(type.isEmptyOfWhere());
    pkMapper.selectPage(RowBounds.DEFAULT, type);
    NotPK notPK2 = null;
    try {
        notPK2 = pkMapper.selectById("1");
    } catch (Exception e) {
        System.out.println("因为没有主键,所以没有注入该方法");
    }
    Assert.assertNull(notPK2);
    int count = pkMapper.selectCount(Condition.EMPTY);
    pkMapper.selectList(Condition.create().orderBy("uuid"));
    pkMapper.selectList(Condition.create().eq("uuid", "uuid").orderBy("uuid"));
    Assert.assertTrue(count > 0);
    int deleteCount = pkMapper.delete(null);
    Assert.assertTrue(deleteCount > 0);
    List<String> list = new ArrayList<>();
    list.add("1");
    list.add("2");
    list.add("3");
    RoleMapper mapper = sqlSession.getMapper(RoleMapper.class);
    System.out.println(mapper.selectBatchIds(list));
    System.out.println(mapper.selectBatchIds(new HashSet<>(list)));
    sqlSession.commit();
}