批量循环查询

文章目录

1、rpc批量查询

java 复制代码
    private List<DTO> query(String code, Integer type) {

        List<DTO> resultList = new ArrayList<>();
        List<DTO> skuList;
  
        //01.构造req
        Req request = buildTRequest(code, type);
        Response response;
        int fetchedCount = 0;
        int maxCycle = 1;
        boolean needMoreFetch = true;
        while (maxCycle <= 1000) {
            maxCycle++;
            try {
                response = skuGateway.query(request);
            } catch (Exception e) {
                throw new GatewayException(1,
                        String.format("获取sku失败 code:[%s]", code), e);
            }
            skuList = response.getData();
            
            if (CollectionUtils.isNotEmpty(skuList)) {
                resultList.addAll(skuList);
                fetchedCount += skuList.size();
            }

            if (total <= fetchedCount) {
                needMoreFetch = false;
            } else {
                request.setOffset(fetchedCount);
            }
        }
        return resultList;
    }

2、200、200条查询db数据

  • eg1
java 复制代码
private void query(Request request) {

        int page = 1;
        List<DO> dOList = query(request, page);
        while (CollectionUtils.isNotEmpty(dOList) && page <= 1000) {//一次200,循环1000次,就是20w的数据量,肯定够了
            //处理数据
            judgeSameTask(dOList);
            if (200 > dOList.size()) {
                break;
            }
            page++;
            dOList = query(request, page);
        }
    }
  • eg2
java 复制代码
private List<Info> batchQuery(Request request) {
        List<Info> result = new ArrayList<>();
        int page = 1;
        List<Info> infos = query(request, page);
        while (CollectionUtils.isNotEmpty(infos) && page <= 1000) {//一次200,循环1000次,就是20w的数据量,肯定够了
            result.addAll(infos);
            if (200 > infos.size()) {
                break;
            }
            page++;
            infos = query(request, page);
        }
        return totalSkuStockList;
    }


private List<ReturnPlanTaskDO> query(Request request, int page) {

        //01.构建查询条件
        XxxDOExample example = buildDOExample();

        //02.分页参数
        example.limit((page - 1) * 200, 200);

        //03.查询
        return myService.query(example);
    }
  • eg3
java 复制代码
    private List<Info> batchQuery(TRequest request) {
        List<Info> result = new ArrayList<>();
        int page = 1;
        List<Info> infoList = query(request, page);
        while (CollectionUtils.isNotEmpty(infoList) && page <= 1000) {//一次200,循环1000次,就是20w的数据量,肯定够了
            result.addAll(infoList);
            if (200 > skuStockSaleInfos.size()) {
                break;
            }
            page++;
            infoList = query(request, page);
        }
        return result;
    }

    private List<Info> query(TRequest request, int page) {
        //01.构建查询条件
        Paging paging = new Paging();
        paging.setOffset((page - 1) * 200);
        paging.setLimit(200);
        request.setPaging(paging);

        //02.查询
        TResponse response = skuService.query(request);
        if (response != null && response.getCode() == 0) {
            return response.getInfoList();
        } else {
            return Collections.emptyList();
        }
    }
  • eg4
java 复制代码
List<DO> result = Lists.newArrayList();
boolean loop = true;
long id = 0L;
do {
    XxxDOExample example = new XxxDOExample();
    example.limit(200);
    example.setOrderByClause("id asc");
    XxxDOExample.Criteria criteria = example.createCriteria();
    criteria1.andValidEqualTo(Boolean.TRUE);
    criteria1.andIdGreaterThan(id);
    List<DO> selectByExample = myMapper.selectByExample(example);
    if (CollectionUtils.isNotEmpty(selectByExample)) {
    result.addAll(selectByExample);
    int size = selectByExample.size();
    if (size < 200) {
        loop = false;
    } else {
        id = selectByExample.get(size - 1).getId();
    }
} while (loop);

第一次查询0-100,数据。(过滤或者处理一下这100条数据)后,存入list中,fetchCount = 100,

第二次查询100-200。(过滤或者处理一下这100条数据)后,存入list中,fetchCount = 200,

···

直到第10次处理完,fetchCount == total(1000)了,needFalse = false,停止查询

补充:为什么采用这种,每次查询100条,(处理或不处理)存入list,直到全部1000条都(处理或不处理)存入list。而不是直接一次查询出这1000条数据

解:因为如果你不查询一次,你根本就不知道数据库中有1000条满足条件的数据。所以,你也可以先查询一次limit offset(0-1)查出total = 1000,此时你再执行sql查询page(0-1000)一次全部查出来放入list

limit 20000 , 10:从第20001行数据开始查找,查找10条(20001、20002、····200010)=》 where id 〉 20000 limit 0 ,10。PageModel即父类RowBounds(mysql中的)即这种形式limit、offset

limit 10 offset 3 :(从第4行开始查找,找10条数据),即4、5、6、···13。

<if test="rows != null">
      <if test="offset != null">
        limit ${offset}, ${rows}    偏移量、多少条
      </if>
      <if test="offset == null">
        limit ${rows}
      </if>
    </if>
    这里limit ${offset}, ${rows}   对比 limit 20000 , 10
    即offset是偏移量,从第20001开始查询,查10条。 这里是limit 0,1000 从第一条开始查查询1000条
  • eg5
java 复制代码
return Lists.partition(skuIds, 200).stream().map(skus -> {
	XxxDOExample example = new XxxDOExample();
example.createCriteria().andSkuIdIn(skus)
                    .andValidEqualTo(Boolean.TRUE);
            return example;
        }).map(example -> myMapper.selectByExample(example))
                .reduce((list1, list2) -> {
                    list1.addAll(list2);
                    return list1;
         }).orElse(Lists.newArrayList());

3、分页查询注意事项

只要使用分页查询,必须加上order by

1、原因

不使用order by,分页查询的数据不准确

  • 背景:

    select查询,如果不走二级索引查询,查询结果默认是按照主键id,正序排序;

    如果走了二级索引,则结果默认按二级索引排序展示

  • 问题复现

    select limit 0,5,使用了二级索引A进行查询,则结果按照索引A正序排序,为:7,8,9,1,2;

    又进行了select 5,10查询第二页;

    此时,因为数据库原因(主从切换,原本该走从查询的,现在走主查询了),或数据量变化(原本数据量级该走A索引查询的,现在走B索引查询了)

    select limit 5,5,使用了二级索引B进行查询,则结果按照索引B正序排序,为:11,12,13,14,2;导致id = 2的数据,在第一页 和 第二页分页查询结果中都出现了!!!甚至会导致数据丢失

2、解:

分页查询一定使用order by

3、SOP

3.1 分页查询全量数据(200、200、200 ---)

  • 无脑order by id asc即可

  • 原因:

    此时如果order by 字段a,会有以下问题

    • 字段a,不是联合索引一员,导致走不到索引

    • 字段a,是联合索引一员,但是,中间断了x_y_z_a,但是本次查询条件仅有x_y ,order by a,也会使索引失效

    • 字段a,是联合索引一员,且连续,能走到索引,但是order by a字段,a字段有很多相同的数据。比如a字段为仓id

      select order by a ,limit 0, 5 ,结果为7,8,9,1,2

​ select order by a ,limit 5, 5 ,结果为2,11,12,13,14

​ 原因就是a字段有很多相同的数据,order by a,前后两页也有可能有相同数据

​ 比如联合索引为valid_poiId,select * from table where valid = 1 limit 0,200这个时候查出来的数据都是valid = 1的,因此查询结果会按照联合索引中的第二个字段poiId正序排序的!!!

即生效sql实际上为select * from table where valid = 1 order by poiId asc limit 0,200

问题:当poi_id有序增长时,id的增长并不有序,甚至可能跨度很大!!!,导致翻页时,如果使用了granThanId方式,取最后一条数据的id可能跳跃很大,导致漏数据。

复现:

查询结果 poiId id

​ 1 10009577 777

​ 2 10001014 77777777

这样即使查询出来的两条数据按poiId排序挨在一起,但是id却跨度很大很大。上一次granthanId的id为776,不会丢数据。这一次granThanid的id为77777777,id > 77777777,这样777- 77777777中间很多id的数据都没查出来!!!相当于丢数据了

所以,此时必须添加一个能确定顺序的索引,即order by a asc,id asc 。不如,直接order by id

3.2 分页查询全量数据,建议使用greathanId

3.3 如果是页面分页查询某一页的数据,而且需要字段a排序展示,则order by a asc,id asc

  • 原因:如果直接order by id,则查询出来的几条数据,不是按a字段排序的,可能不符合要求(a字段为销量,order by id查询出来的几条数据,销量可能不是最高的前几条)

    example.setOrderByClause("poi_id asc, create_at asc");

相关推荐
全频道1 个月前
批量查询快递单号物流信息:高效掌握最后更新动态
物流·批量查询·快递
OceanSky61 年前
Redis学习笔记17:基于spring data redis及lua脚本批处理scan指令查询永久有效的key
redis·lua·批量查询·scan·ttl