2、sql查询出所有的数据，代码 group 分组取出每个类别的前3个数据

3、sql查询每个类别前3数据，union连接起来

4、sql查询查询出来所有的类型，根据类型查询出每个类型的前3个数据

添加15万条测试数据：

@Before
    public void  getList() {
        long start = System.currentTimeMillis();
        Ranking user;
        for (int i = 1; i <= 3; i++) {
            for (int j = 1; j <=50000 ; j++) {
                user = new Ranking();
                user.setType(i);
                user.setNum(j);
                list.add(user);
        System.out.println("拼装数据 耗时："+(System.currentTimeMillis()-start));
        System.out.println(list.size());
    @Test
    public void batchInsert() {
        SqlSession sqlSession = sqlSessionFactory.openSession(ExecutorType.BATCH,false);
        RankMapper mapper = sqlSession.getMapper(RankMapper.class);
        System.out.println("batchInsert 插入开始========");
        long start = System.currentTimeMillis();
        for (int i = 0; i < list.size(); i++) {
            mapper.insert(list.get(i));
            if (i%5000==4999) {
                sqlSession.flushStatements();
        sqlSession.flushStatements();
        System.out.println("SqlSession 批量插入耗时："+(System.currentTimeMillis()-start));
SELECT
	a.type,a.num
	ranking AS a
WHERE
		SELECT
			COUNT(*)
			ranking AS b
		WHERE
			b.type = a.type
		AND b.num >= a.num
	) <= 3
ORDER BY
	a.type ASC,
	a.num DESC;
 
因为涉及子查询，查询效率太低，几分钟后sql还是没有执行完毕。。
 
先使用mybatis-plus 查询出所有的数据，使用分组统计出每个类别前三的数据。
 
    @Test
    public void testRankSelect() {
        long start = System.currentTimeMillis();
        List<Ranking> rankings = rankMapper.selectList(null);
        long end = System.currentTimeMillis();
        System.out.println("查询15万数据查询时间："+(end-start));
        System.out.println("分组开始================");
        List<Ranking> rankingresult = new ArrayList<>();
        Map<Integer, List<Ranking>> typeGroup = rankings.stream().collect(Collectors.groupingBy(Ranking::getType));
        typeGroup.forEach((k,v)->{
            List<Ranking> v1 = v;
            v1.sort(Comparator.comparing(Ranking::getNum).reversed());
            v1 = v1.subList(0,3);
            rankingresult.addAll(v1);
        long groupEnd = System.currentTimeMillis();
        System.out.println("分组统计前三花费时间："+(groupEnd-end));
        System.out.println(rankingresult);
效果：15万条数据，查询加上分组统计大约花费2秒；用sql时间应该在1秒之内
 
分别查询出3个类别前3的数据，然后union起来
 
(SELECT type,num from ranking where type = 1 order by num desc limit 3)
union
(SELECT type,num from ranking where type = 2 order by num desc limit 3)
union
(SELECT type,num from ranking where type = 3 order by num desc limit 3)
 
在类别不多的情况下，使用此种方式，3个类别，15万条数据 执行时间0.12秒
 
先sql查询出来所有的类型，根据类型遍历查询每个类型的前3条数据，将查询出来的数据放入list中
 
    @Test
    public void queryWrapperRankSelect() {
        long start = System.currentTimeMillis();
        QueryWrapper<Ranking> queryWrapper = new QueryWrapper<>();
        queryWrapper.select("distinct type");
        List<Ranking> rankTypes = rankMapper.selectList(queryWrapper);
        List<Ranking> rankingresult = new ArrayList<>();
        rankTypes.forEach(e->{
            LambdaQueryWrapper<Ranking> lambdaQueryWrapper = new LambdaQueryWrapper<>();
            lambdaQueryWrapper.eq(Ranking::getType,e.getType());
            lambdaQueryWrapper.orderByDesc(Ranking::getNum);
            lambdaQueryWrapper.last("limit 3");
            List<Ranking> rankings = rankMapper.selectList(lambdaQueryWrapper);
            rankingresult.addAll(rankings);
        long end = System.currentTimeMillis();
        System.out.println("分组统计前三花费时间："+(end-start));
        System.out.println(rankingresult);
效果：查询处理数据大约花费0.7秒
 
若是需求允许，并且类别固定且数量少的情况下，使用方案3效率最高（灵活性低，类别固定情况下可以使用）；
 
其次就是方案4，先sql查询出来所有的类型，根据类型遍历查询每个类型的前3条数据，将查询出来的数据放入list中，效率高（建议使用）。
 
然后就是使用方案2，先查询出来所有的数据，在分组求每个类别的前3的数据，效率也挺高的（建议使用）。
 
最后就是方案1，使用sql直接计算出结果，效率最低，如果数据量大的情况下程序可能会崩溃（不建议使用）。
                    需求：统计每个类别某项数据排名前几的数据方案：1、sql统计2、sql查询出所有的数据，代码 group 分组取出每个类别的前3个数据3、sql查询每个类别前3数据，union连接起来测试：表结构：添加15万条测试数据：@Before    public void  getList() {        long start = System.currentTimeMillis();        Ranking user;      ...
				
使用mysql、hive查询各科成绩前三名一、建表造数据二、使用myql查询2.1 不考虑并列情况方法一：使用加行号的方式查询方法二：使用子查询嵌套查询（使用最多）2.2 考虑并列情况三、使用hive查询前三名3.1 不考虑并列情况:rank()3.2 考虑并列情况:dense_rank()
一、建表造数据
create table scores(
name varchar(100),
subject varchar(100),
score int
插入数据：
insert into sco
				
1、SQLServer
sqlserver    支持top关键字，返回前若干条数据。
select top 5 * from table;     // 返回前5行数据
2、MySQL
mysql 支持 limit，只能适用于mysql。limit 子句用于强制 select 语句返回置顶的记录数，接受一个或两个数字参数，必须是整数常量。一个参数是返回前几条记录；两个参数时，第一个参数指定第一个返回记录行的偏移量（初始记录行的偏移量是0），第二个参数指定返回记录的最大数目。
一个参数：select * 
				
关系型数据库，获取分组后取每组中最大前3条的sql语句
SELECT * FROM (
SELECT ROW_NUMBER() OVER(PARTITION BY 分组字段 ORDER BY 分组后排序字段 DESC) rn ,t.*
FROM 表 t) t2 WHERE t2.rn<4
				
MariaDB [mysql]> select argument,count(argument) num from mysql.general_log group by argument order by num desc limit3;
+--------------------------------------------------------------------------------------------------------+-----+
| argument         .
--2．查询类别为“cn002”的所有商品信息。
select * from Category join Goods on 
Category.CategoryNO=Goods.CategoryNO
where Category.CategoryNO='cn002';
--3 查询类别为“cn001”和“cn002”对应的所有商品信息。
select * from Category join Goods on 
Category....
				
以下查询语句返回 customer表中 city重复次数（count） 最多的20条记录：
SELECT city, count( * ) AS count
FROM customer
GROUP BY city
ORDER BY count DESC
LIMIT 20
以下查询语句返回 article_keyword 表中 keyword 的重复次数（count） 排名前 6 的数值。通过添加 DISTINCT 返回唯一记录：
SELECT DISTINCT count( * ) AS count
left join student s 
on s.id = a.student_id 
where (select count(1) from score b where b.`subject` = a.`subject` and a.score < b.score) < 3 
order by a.`subject
				
可以通过编写一段脚本自动化完成这个任务。首先需要连接数据库，然后获取所有表的名称。然后，循环遍历每个表，使用 SQL 查询语句获取每个表中的行数，并将这些信息保存下来。最后，可以将这个信息输出到一个文件或发送邮件通知管理员。以下是一个简单的示例 SQL 查询语句：
SELECT COUNT(*) FROM table_name;
其中，table_name 需要替换为实际的表名。您可以将这个查询语句嵌入到循环中，并将结果保存到一个数组或字典中。最终结果可能如下所示：
    "users": 10000,
    "orders": 5000,
    "products": 8000
其中，"users" 表包含 10000 行数据，"orders" 表包含 5000 行数据，"products" 表包含 8000 行数据。