AI 助理
备案控制台
开发者社区 物联网 文章 正文

SpringBoot使用mysql查询昨天、今天、过去一周、过去半年、过去一年数据

2024-11-11 60
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： SpringBoot使用mysql查询昨天、今天、过去一周、过去半年、过去一年数据

image.png

@[TOC]

摘要

1、今日数据： 以2h为间隔，左间隔时间=< “条数” <当下最近时间右间隔时间，比如，[00：00, 02:00)
2、过去一天数据：以2h为间隔，左间隔时间=< ”条数“ <右间隔时间 （注意查询的是过去一整天的数据不包括今天的）
3、过去7天数据： 以1天/单位，记录当天的预警信息总条数截至到当前时间,比如，从今天往前推6天记录每天总条数
4、过去30天数据：以5天/单位，左间隔时间=< “条数” <右间隔时间 比如，[2020-03-19, 2020-03-24)
5、过去半年数据：以每个月/单位，查询当月往前推半年数据，比如，2020-03-24查询的是“2019-10 -> 2020-03”
6、过去1年数据： 以每个月/单位，查询当前月往前推一年数据截止到上个月数据，比如2020-03-24查询的是“2019-03 -> 2020-02”

图片案例

image.png
image.png
image.png
image.png
image.png
image.png
image.png
image.png
image.png
image.png
image.png
image.png

代码

描述：代码没有重新中文整理思路，看着有点乱，敬请谅解

整理思路：

第一步：根据查询的范围类型优先构建list，包含 list初始化大小，x：时间字符串， y：数量条数，默认为0

第二步：查询SQL，对应填充list，返回前端即可

工具类：==DateTool==

package com.geespace.microservices.data.metrics.config.server.common.tools;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;

import com.geespace.microservices.data.metrics.config.server.bean.dto.ReportDto;
import com.geespace.microservices.data.metrics.config.server.common.constant.NumberDictionary;
import com.geespace.microservices.data.metrics.config.server.common.enums.ListEnum;

import lombok.extern.slf4j.Slf4j;

/**
 * 日期工具类
 * @Author: liudz
 * @Date: 2019-12-12
 **/
@Slf4j
 public final class DateTool {
   
    /**
     * 构造函数
     */
    private DateTool() {
   }

    /**
       *  检测一个字符串是否是时间格式
       * @param str 请求字符串
       * @author liudz
       * @date 2019/12/17
       * @return 执行结果
       **/
    public static boolean isValidDate(String str) {
   
        boolean convertSuccess = true;
        // 指定日期格式为四位年/两位月份/两位日期，注意yyyy/MM/dd区分大小写；设置lenient为false. 否则SimpleDateFormat会比较宽松地验证日期，比如2007/02/29会被接受，并转换成2007/03/01
        SimpleDateFormat format = new SimpleDateFormat("HH:mm");
        try {
   
            format.setLenient(false);
            format.parse(str);
        } catch (Exception e) {
   
            convertSuccess = false;
        }
        return convertSuccess;
    }

    /**
     *  accord( a dateStr and number and type) return a number ago of a newDateStr
     * @param dateStr dateStr
     * @param number number
     * @param type type
     * @author liudz
     * @date 2020/3/17
     * @return newDateStr
     **/
    public static String returnANumberAgoDate(String dateStr, Integer number, int type) {
   
        String newDateStr = "";
        try {
   
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
            Date date;
            date = simpleDateFormat.parse(dateStr);
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(date);
            if (type == ListEnum.ONE.getValue() || type == ListEnum.TWO.getValue() || type == ListEnum.THREE.getValue() || type == ListEnum.FOUR.getValue()) {
   
                calendar.add(Calendar.DATE, number);
            } else if (type == ListEnum.FIVE.getValue()) {
   
                calendar.add(Calendar.MONTH, number);
            }  else if (type == ListEnum.SIX.getValue()) {
   
                calendar.add(Calendar.YEAR, number);
                calendar.add(Calendar.MONTH, 1);
            }
            date = calendar.getTime();
            newDateStr = simpleDateFormat.format(date);
        } catch (ParseException e) {
   
            log.error(e.getMessage());
        }
        return newDateStr;
    }

    /**
     *  according a dateStr returns a map containing dateStrKey
     * @param type type
     * @author liudz
     * @date 2020/3/17
     * @return map
     **/
    public static List<ReportDto> returnDateMap(int type) {
   
        List<ReportDto> list = new ArrayList<>();
        if (type == ListEnum.ONE.getValue()) {
   
            list = returnDateArrType1(list);
        }  else if (type == ListEnum.TWO.getValue()) {
   
            list = returnDateArrType2(list);
        } else if (type == ListEnum.THREE.getValue()) {
   
            list = returnDateArrType3(list, type);
        } else if (type == ListEnum.FOUR.getValue()) {
   
            list = returnDateArrType4(list, type);
        } else if (type == ListEnum.FIVE.getValue()) {
   
            list = returnDateArrType5(list, type);
        } else {
   
            list = returnDateArrType6(list, type);
        }
        return list;
    }

    /**
     * 报表3-1，type=1,查询今天数据
     * @param list list
     * @author liudz
     * @date 2020/3/24
     * @return list
     **/
    public static List<ReportDto> returnDateArrType1(List<ReportDto> list) {
   
        int count = 1;
        Date date = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("HH");
        String format = simpleDateFormat.format(date);
        int arrayLength = Integer.valueOf(format) / NumberDictionary.TWO + NumberDictionary.ONE;
        do {
   
            joinListParam(count, list);
            count++;
        } while (count <= arrayLength);

        return list;
    }
    /**
     *  joinListParam
     * @param arrayLength arrayLength
     * @param list list
     * @author liudz
     * @date 2020/8/27
     **/
    public static void joinListParam(int arrayLength, List<ReportDto> list) {
   
        ReportDto reportDto = new ReportDto();
        switch (arrayLength) {
   
            case NumberDictionary.ONE:
                reportDto.setDateStr("00:00-02:00");
                break;
            case NumberDictionary.TWO:
                reportDto.setDateStr("02:00-04:00");
                break;
            case NumberDictionary.THREE:
                reportDto.setDateStr("04:00-06:00");
                break;
            case NumberDictionary.FOUR:
                reportDto.setDateStr("06:00-08:00");
                break;
            case NumberDictionary.FIVE:
                reportDto.setDateStr("08:00-10:00");
                break;
            case NumberDictionary.SIX:
                reportDto.setDateStr("10:00-12:00");
                break;
            case NumberDictionary.SEVEN:
                reportDto.setDateStr("12:00-14:00");
                break;
            case NumberDictionary.EIGHT:
                reportDto.setDateStr("14:00-16:00");
                break;
            case NumberDictionary.NINE:
                reportDto.setDateStr("16:00-18:00");
                break;
            case NumberDictionary.TEN:
                reportDto.setDateStr("18:00-20:00");
                break;
            case NumberDictionary.ELEVEN:
                reportDto.setDateStr("20:00-22:00");
                break;
            case NumberDictionary.TWELVE:
                reportDto.setDateStr("22:00-23:59");
                break;
            default:
                throw new RuntimeException("no suck this arrayLength!");
        }
        list.add(reportDto);
    }
    /**
     * 报表3-1，type=2,查询昨天数据
     * @param list list
     * @author liudz
     * @date 2020/3/24
     * @return list
     **/
    public static List<ReportDto> returnDateArrType2(List<ReportDto> list) {
   
        int count = 1;
        do {
   
            joinListParam(count, list);
            count++;
        } while (count <= NumberDictionary.TWELVE);
        return list;
    }
    /**l
     * 报表3-3，type=3,查询过去7天数据
     * @param list list
     * @param type type
     * @author liudz
     * @date 2020/3/24
     * @return list
     **/
    public static List<ReportDto> returnDateArrType3(List<ReportDto> list, int type) {
   
        int count = 0;
        Date date = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        String dateStr = DateTool.returnANumberAgoDate(simpleDateFormat.format(date), ListEnum.NEGATIVE_SIX.getValue(), type);
        do {
   
            try {
   
                ReportDto reportDto = new ReportDto();
                reportDto.setDateStr(dateStr);
                list.add(reportDto);
                date = simpleDateFormat.parse(dateStr);
                Calendar calendar = Calendar.getInstance();
                calendar.setTime(date);
                calendar.add(Calendar.DATE, 1);
                date = calendar.getTime();
                dateStr = simpleDateFormat.format(date);
                count++;
            } catch (ParseException e) {
   
                log.error(e.getMessage());
            }
        } while (count < ListEnum.SEVEN.getValue());
        return list;
    }
    /**
     * 报表3-4，type=4,查询过去30天数据
     * @param list list
     * @param type type
     * @author liudz
     * @date 2020/3/24
     * @return list
     **/
    public static List<ReportDto> returnDateArrType4(List<ReportDto> list, int type) {
   
        int count = 0;
        Date date = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        String dateStr = DateTool.returnANumberAgoDate(simpleDateFormat.format(date), ListEnum.NEGATIVE_TWENTYNINE.getValue(), type);
        do {
   
            try {
   
                date = simpleDateFormat.parse(dateStr);
                String oldDateStr = dateStr;
                Calendar calendar = Calendar.getInstance();
                calendar.setTime(date);
                calendar.add(Calendar.DATE, ListEnum.FOUR.getValue());
                date = calendar.getTime();
                dateStr = simpleDateFormat.format(date);
                ReportDto reportDto = new ReportDto();
                reportDto.setDateStr(oldDateStr + "~" +  simpleDateFormat.format(date));
                list.add(reportDto);
                date = simpleDateFormat.parse(dateStr);
                calendar = Calendar.getInstance();
                calendar.setTime(date);
                calendar.add(Calendar.DATE, ListEnum.ONE.getValue());
                date = calendar.getTime();
                dateStr = simpleDateFormat.format(date);
                count++;
            } catch (ParseException e) {
   
                log.error(e.getMessage());
            }
        } while (count < ListEnum.SIX.getValue());
        return list;
    }
    /**
     * 报表3-5，type=5, 查询过去半年数据
     * @param list list
     * @param type type
     * @author liudz
     * @date 2020/3/24
     * @return list
     **/
    public static List<ReportDto> returnDateArrType5(List<ReportDto> list, int type) {
   
        int count = 0;
        Date date = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        SimpleDateFormat simpleDateFormat2 = new SimpleDateFormat("yyyy-MM");
        String dateStr = DateTool.returnANumberAgoDate(simpleDateFormat.format(date), ListEnum.NEGATIVE_FIVE.getValue(), type).substring(0, ListEnum.SEVEN.getValue());
        do {
   
            try {
   
                ReportDto reportDto = new ReportDto();
                reportDto.setDateStr(dateStr);
                list.add(reportDto);
                date = simpleDateFormat2.parse(dateStr);
                Calendar calendar = Calendar.getInstance();
                calendar.setTime(date);
                calendar.add(Calendar.MONTH, 1);
                date = calendar.getTime();
                dateStr = simpleDateFormat.format(date).substring(0, ListEnum.SEVEN.getValue());
                count++;
            } catch (ParseException e) {
   
                log.error(e.getMessage());
            }
        } while (count < ListEnum.SIX.getValue());
        return list;
    }
    /**
     * 报表3-6，type=6, 查询过去一年数据
     * @param list list
     * @param type type
     * @author liudz
     * @date 2020/3/24
     * @return list
     **/
    public static List<ReportDto> returnDateArrType6(List<ReportDto> list, int type) {
   
        int count = 0;
        Date date = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        SimpleDateFormat simpleDateFormat2 = new SimpleDateFormat("yyyy-MM");
        String dateStr = DateTool.returnANumberAgoDate(simpleDateFormat.format(date), ListEnum.NEGATIVE_ONE.getValue(), type).substring(0, ListEnum.SEVEN.getValue());
        do {
   
            try {
   
                ReportDto reportDto = new ReportDto();
                reportDto.setDateStr(dateStr);
                list.add(reportDto);
                date = simpleDateFormat2.parse(dateStr);
                Calendar calendar = Calendar.getInstance();
                calendar.setTime(date);
                calendar.add(Calendar.MONTH, 1);
                date = calendar.getTime();
                dateStr = simpleDateFormat.format(date).substring(0, ListEnum.SEVEN.getValue());
                count++;
            } catch (ParseException e) {
   
                log.error(e.getMessage());
            }
        } while (count < ListEnum.TWELVE.getValue());
        return list;
    }
}

==AlarmMessageServiceImpl==

/**
     *  报表数据3，其中（type=1,今日数据 type=2，过去一天数据 type=3，过去7填数据 type=4，过去30数据 type=5，过去半年数据 type=6，过去一年数据 ）
     * @param reportParam reportParam
     * @author liudz
     * @date 2019/12/23
     * @return list
     **/
    public List<ReportDto> getReportDataPartThree(ReportParam reportParam) {
   
        log.debug("--AlarmMessageServiceImpl--getReportDataPartThree--begin--reportParam:{}", reportParam);
        List<ReportDto> list = new ArrayList<>();
        if (reportParam.getType() == 1) {
   
            List<ReportDataParamThree> result = alarmMessageMapper.getReportDataPartThree1(reportParam);
            list = DateTool.returnDateMap(reportParam.getType());
            list = fillMapType1(list, result);
        } else if (reportParam.getType() == ListEnum.TWO.getValue()) {
   
            List<ReportDataParamThree> result = alarmMessageMapper.getReportDataPartThree2(reportParam);
            list = DateTool.returnDateMap(reportParam.getType());
            list = fillMapType1(list, result);
        } else if (reportParam.getType() == ListEnum.THREE.getValue()) {
   
            List<ReportDataParamThree> result = alarmMessageMapper.getReportDataPartThree3(reportParam);
            list = DateTool.returnDateMap(reportParam.getType());
            list = fillMapType3(list, result);
        } else if (reportParam.getType() == ListEnum.FOUR.getValue()) {
   
            List<ReportDataParamThree> result = alarmMessageMapper.getReportDataPartThree4(reportParam);
            list = DateTool.returnDateMap(reportParam.getType());
            list = fillMapType4(list, result);
        } else if (reportParam.getType() == ListEnum.FIVE.getValue()) {
   
            List<ReportDataParamThree> result = alarmMessageMapper.getReportDataPartThree5(reportParam);
            list = DateTool.returnDateMap(reportParam.getType());
            list = fillMapType5(list, result);
        } else if (reportParam.getType() == ListEnum.SIX.getValue()) {
   
            List<ReportDataParamThree> result = alarmMessageMapper.getReportDataPartThree6(reportParam);
            list = DateTool.returnDateMap(reportParam.getType());
            list = fillMapType6(list, result);
        }
        log.debug("--AlarmMessageServiceImpl--getReportDataPartThree--end--result:{}", reportParam);
        return list;
    }
    /**
     * 报表3-1，type=1,查询今天数据 或 报表3-2，type=2,查询昨天数据
     * @param list  list
     * @param result result
     * @author liudz
     * @date 2020/3/24
     * @return fillMap
     **/
    public List<ReportDto> fillMapType1(List<ReportDto> list, List<ReportDataParamThree> result) {
   
        ReportDto reportDto;
        for (int i = 0; i < list.size(); i++) {
   
            for (int j = 0; j < result.size(); j++) {
   
                String[] split = list.get(i).getDateStr().split("-");
                if (result.get(j).getDateStr().compareTo(split[0]) >= 0 && result.get(j).getDateStr().compareTo(split[1]) < 0) {
   
                    reportDto = new ReportDto();
                    reportDto.setDateStr(list.get(i).getDateStr());
                    reportDto.setCount(list.get(i).getCount() + result.get(j).getCount());
                    list.set(i, reportDto);
                }
            }
        }
        return list;
    }
    /**
     * 报表3-3，type=3,查询过去7天数据
     * @param list  list
     * @param result result
     * @author liudz
     * @date 2020/3/24
     * @return fillMap
     **/
    public List<ReportDto> fillMapType3(List<ReportDto> list, List<ReportDataParamThree> result) {
   
        for (ReportDto item : list) {
   
            for (ReportDataParamThree r : result) {
   
                if (item.getDateStr().equals(r.getDateStr())) {
   
                    item.setCount(r.getCount());
                    list.set(list.indexOf(item), item);
                }
            }
        }
        return list;
    }
    /**
     * 报表3-4，type=4,查询过去30天数据
     * @param list  list
     * @param result result
     * @author liudz
     * @date 2020/3/24
     * @return fillMap
     **/
    public List<ReportDto> fillMapType4(List<ReportDto> list, List<ReportDataParamThree> result) {
   
        ReportDto reportDto;
        for (int i = 0; i < list.size(); i++) {
   
            for (int j = 0; j < result.size(); j++) {
   
                String[] split = list.get(i).getDateStr().split("~");
                if (result.get(j).getDateStr().compareTo(split[0]) >= 0 && result.get(j).getDateStr().compareTo(split[1]) <= 0) {
   
                    reportDto = new ReportDto();
                    reportDto.setDateStr(list.get(i).getDateStr());
                    reportDto.setCount(list.get(i).getCount() + result.get(j).getCount());
                    list.set(i, reportDto);
                }
            }
        }
        return list;
    }
    /**
     * 报表3-5，type=5, 查询过去半年数据
     * @param list  list
     * @param result result
     * @author liudz
     * @date 2020/3/24
     * @return fillMap
     **/
    public List<ReportDto> fillMapType5(List<ReportDto> list, List<ReportDataParamThree> result) {
   
        for (ReportDto item : list) {
   
            for (ReportDataParamThree r : result) {
   
                if (item.getDateStr().equals(r.getDateStr())) {
   
                    item.setCount(r.getCount());
                    list.set(list.indexOf(item), item);
                }
            }
        }
        return list;
    }
    /**
     * 报表3-6，type=6, 查询过去一年数据
     * @param list  list
     * @param result result
     * @author liudz
     * @date 2020/3/24
     * @return fillMap
     **/
    public List<ReportDto> fillMapType6(List<ReportDto> list, List<ReportDataParamThree> result) {
   
        for (ReportDto item : list) {
   
            for (ReportDataParamThree r : result) {
   
                if (item.getDateStr().equals(r.getDateStr())) {
   
                    item.setCount(r.getCount());
                    list.set(list.indexOf(item), item);
                }
            }
        }
        return list;
    }

==AlarmMessageSqlProvider==

/**
     *  报表数据部分1，查询总览预警情况
     * @param  reportParam 请求参数
     * @author liudz
     * @date 2019/12/2
     * @return 执行结果
     **/
    public String getReportDataPartOne(ReportParam reportParam) {
   
        SQL sql = new SQL();
        if (DictionaryEnum.ZERO.getFiledString().equals(reportParam.getCategory())) {
   
            sql.SELECT("device_key, category, COUNT(*)");
        } else {
   
            sql.SELECT("task_name, category, COUNT(*), task_id");
        }
        sql.FROM("ge_alarm_message");
        sql.WHERE("cuser = #{cuser,jdbcType=BIGINT}");
        sql.WHERE("category = #{category,jdbcType=VARCHAR}");
        sql.WHERE("date(ctime) = CURDATE()");
        if (DictionaryEnum.ZERO.getFiledString().equals(reportParam.getCategory())) {
   
            sql.GROUP_BY("device_key");
        } else {
   
            sql.GROUP_BY("task_name, task_id");
        }
        return sql.toString();
    }
    /**
     *  报表数据部分2，查询详细预警情况
     * @param  reportParam 请求参数
     * @author liudz
     * @date 2019/12/2
     * @return 执行结果
     **/
    public String getReportDataPartTwo(ReportParam reportParam) {
   
        SQL sql = new SQL();
        sql.SELECT("id, task_name, task_id, content, time, product_key, device_key, ctime");
        sql.FROM("ge_alarm_message");
        sql.WHERE("cuser = #{cuser,jdbcType=BIGINT}");
        sql.WHERE("category = #{category,jdbcType=VARCHAR}");
        sql.WHERE("date(ctime) = CURDATE()");
        if (!StringUtils.isEmpty(reportParam.getDeviceKey()) && StringUtils.isEmpty(reportParam.getTaskId())) {
   
            sql.WHERE("device_key = #{deviceKey,jdbcType=VARCHAR}");
        }
        if (!StringUtils.isEmpty(reportParam.getTaskId()) && StringUtils.isEmpty(reportParam.getDeviceKey())) {
   
            sql.WHERE("task_id = #{taskId}");
        }
        sql.ORDER_BY("ctime desc");
        return sql.toString();
    }
    /**
     *  报表数据3-1：type=1,今日数据
     * @param  reportParam 请求参数
     * @author liudz
     * @date 2019/12/2
     * @return 执行结果
     **/
    public String getReportDataPartThree1(ReportParam reportParam) {
   
        SQL sql = new SQL();
        sql.SELECT("concat(DATE_FORMAT(ctime, '%H'), ':00') as dateStr,count(*) as count");
        sql.FROM("ge_alarm_message");
        sql.WHERE("cuser = #{cuser,jdbcType=BIGINT}");
        sql.WHERE("category = #{category,jdbcType=VARCHAR}");
        sql.WHERE("date(ctime) = CURDATE()");
        if (!StringUtils.isEmpty(reportParam.getDeviceKey()) && StringUtils.isEmpty(reportParam.getTaskId())) {
   
            sql.WHERE("device_key = #{deviceKey,jdbcType=VARCHAR}");
        }
        if (!StringUtils.isEmpty(reportParam.getTaskId()) && StringUtils.isEmpty(reportParam.getDeviceKey())) {
   
            sql.WHERE("task_id = #{taskId}");
        }
        sql.GROUP_BY("concat(DATE_FORMAT(ctime, '%H'), ':00')");
        return sql.toString();
    }
    /**
     *  报表数据3-2：type=2,过去24小时数据
     * @param  reportParam 请求参数
     * @author liudz
     * @date 2019/12/2
     * @return 执行结果
     **/
    public String getReportDataPartThree2(ReportParam reportParam) {
   
        SQL sql = new SQL();
        sql.SELECT("concat(DATE_FORMAT(ctime, '%H'), ':00') as dateStr,count(*) as count");
        sql.FROM("ge_alarm_message");
        sql.WHERE("cuser = #{cuser,jdbcType=BIGINT}");
        sql.WHERE("category = #{category,jdbcType=VARCHAR}");
        sql.WHERE("TO_DAYS(NOW()) - TO_DAYS(ctime) = 1");
        if (!StringUtils.isEmpty(reportParam.getDeviceKey()) && StringUtils.isEmpty(reportParam.getTaskId())) {
   
            sql.WHERE("device_key = #{deviceKey,jdbcType=VARCHAR}");
        }
        if (!StringUtils.isEmpty(reportParam.getTaskId()) && StringUtils.isEmpty(reportParam.getDeviceKey())) {
   
            sql.WHERE("task_id = #{taskId}");
        }
        sql.GROUP_BY("concat(DATE_FORMAT(ctime, '%H'), ':00')");
        return sql.toString();
    }
    /**
     *  报表数据3-3：type=3,过去7天数据
     * @param  reportParam 请求参数
     * @author liudz
     * @date 2019/12/2
     * @return 执行结果
     **/
    public String getReportDataPartThree3(ReportParam reportParam) {
   
        SQL sql = new SQL();
        sql.SELECT("SUBSTRING(ctime,1,10) as dateStr,count(*) as count");
        sql.FROM("ge_alarm_message");
        sql.WHERE("cuser = #{cuser,jdbcType=BIGINT}");
        sql.WHERE("category = #{category,jdbcType=VARCHAR}");
        sql.WHERE("DATE_SUB(CURDATE(), INTERVAL 6 DAY) <= date(ctime)");
        if (!StringUtils.isEmpty(reportParam.getDeviceKey()) && StringUtils.isEmpty(reportParam.getTaskId())) {
   
            sql.WHERE("device_key = #{deviceKey,jdbcType=VARCHAR}");
        }
        if (!StringUtils.isEmpty(reportParam.getTaskId()) && StringUtils.isEmpty(reportParam.getDeviceKey())) {
   
            sql.WHERE("task_id = #{taskId}");
        }
        sql.GROUP_BY("SUBSTRING(ctime,1,10)");
        return sql.toString();
    }
    /**
     *  报表数据3-4：type=4,过去30天数据
     * @param  reportParam 请求参数
     * @author liudz
     * @date 2019/12/2
     * @return 执行结果
     **/
    public String getReportDataPartThree4(ReportParam reportParam) {
   
        SQL sql = new SQL();
        sql.SELECT("SUBSTRING(ctime,1,10) as dateStr,count(*) as count");
        sql.FROM("ge_alarm_message");
        sql.WHERE("cuser = #{cuser,jdbcType=BIGINT}");
        sql.WHERE("category = #{category,jdbcType=VARCHAR}");
        sql.WHERE("DATE_SUB(CURDATE(), INTERVAL 30 DAY) <= date(ctime)");
        if (!StringUtils.isEmpty(reportParam.getDeviceKey()) && StringUtils.isEmpty(reportParam.getTaskId())) {
   
            sql.WHERE("device_key = #{deviceKey,jdbcType=VARCHAR}");
        }
        if (!StringUtils.isEmpty(reportParam.getTaskId()) && StringUtils.isEmpty(reportParam.getDeviceKey())) {
   
            sql.WHERE("task_id = #{taskId}");
        }
        sql.GROUP_BY("SUBSTRING(ctime,1,10)");
        return sql.toString();
    }
    /**
     *  报表数据3-5：type=5,过去半年数据
     * @param  reportParam 请求参数
     * @author liudz
     * @date 2019/12/2
     * @return 执行结果
     **/
    public String getReportDataPartThree5(ReportParam reportParam) {
   
        SQL sql = new SQL();
        sql.SELECT("DATE_FORMAT(ctime,'%Y-%m') as dateStr,count(*) as count");
        sql.FROM("ge_alarm_message");
        sql.WHERE("cuser = #{cuser,jdbcType=BIGINT}");
        sql.WHERE("category = #{category,jdbcType=VARCHAR}");
        sql.WHERE("DATE_SUB(concat(SUBSTRING(CURDATE(),1,7), '-01'), INTERVAL 5 MONTH) <= date(ctime)");
        if (!StringUtils.isEmpty(reportParam.getDeviceKey()) && StringUtils.isEmpty(reportParam.getTaskId())) {
   
            sql.WHERE("device_key = #{deviceKey,jdbcType=VARCHAR}");
        }
        if (!StringUtils.isEmpty(reportParam.getTaskId()) && StringUtils.isEmpty(reportParam.getDeviceKey())) {
   
            sql.WHERE("task_id = #{taskId}");
        }
        sql.GROUP_BY("DATE_FORMAT(ctime,'%Y-%m')");
        return sql.toString();
    }
    /**
     *  报表数据3-6：type=6,过去1年数据
     * @param  reportParam 请求参数
     * @author liudz
     * @date 2019/12/2
     * @return 执行结果
     **/
    public String getReportDataPartThree6(ReportParam reportParam) {
   
        SQL sql = new SQL();
        sql.SELECT("DATE_FORMAT(ctime,'%Y-%m') as dateStr,count(*) as count");
        sql.FROM("ge_alarm_message");
        sql.WHERE("cuser = #{cuser,jdbcType=BIGINT}");
        sql.WHERE("category = #{category,jdbcType=VARCHAR}");
        sql.WHERE("DATE_FORMAT(DATE_SUB(concat(SUBSTRING(CURDATE(),1,7), '-01') ,INTERVAL 1 year),'%Y-%m-%d') <= date(ctime)");
        if (!StringUtils.isEmpty(reportParam.getDeviceKey()) && StringUtils.isEmpty(reportParam.getTaskId())) {
   
            sql.WHERE("device_key = #{deviceKey,jdbcType=VARCHAR}");
        }
        if (!StringUtils.isEmpty(reportParam.getTaskId()) && StringUtils.isEmpty(reportParam.getDeviceKey())) {
   
            sql.WHERE("task_id = #{taskId}");
        }
        sql.GROUP_BY("DATE_FORMAT(ctime,'%Y-%m')");
        return sql.toString();
    }

image.png

重要信息

image.png
image.png
image.png
image.png

文章标签：
云数据库 RDS MySQL 版
Java
关系型数据库
MySQL
前端开发
SQL
关键词：
云数据库 RDS MySQL 版查询
云数据库 RDS MySQL 版数据
云数据库 RDS MySQL 版查询数据
Spring boot MySQL
Spring Boot查询数据
相关实践学习
如何在云端创建MySQL数据库
开始实验后，系统会自动创建一台自建MySQL的 源数据库 ECS 实例和一台 目标数据库 RDS。
全面了解阿里云能为你做什么
阿里云在全球各地部署高效节能的绿色数据中心，利用清洁计算为万物互联的新世界提供源源不断的能源动力，目前开服的区域包括中国（华北、华东、华南、香港）、新加坡、美国（美东、美西）、欧洲、中东、澳大利亚、日本。目前阿里云的产品涵盖弹性计算、数据库、存储与CDN、分析与搜索、云通信、网络、管理与监控、应用服务、互联网中间件、移动服务、视频服务等。通过本课程，来了解阿里云能够为你的业务带来哪些帮助 &nbsp; &nbsp; 相关的阿里云产品：云服务器ECS 云服务器 ECS（Elastic Compute Service）是一种弹性可伸缩的计算服务，助您降低 IT 成本，提升运维效率，使您更专注于核心业务创新。产品详情: https://www.aliyun.com/product/ecs
刘大猫.
目录
相关文章
德国都芳最好
|
1月前
|
缓存 关系型数据库 MySQL
MySQL索引策略与查询性能调优实战
在实际应用中，需要根据具体的业务需求和查询模式，综合运用索引策略和查询性能调优方法，不断地测试和优化，以提高MySQL数据库的查询性能。
德国都芳最好
92 9
大数据文摘
|
4天前
|
SQL 关系型数据库 MySQL
MySQL 窗口函数详解：分析性查询的强大工具
MySQL 窗口函数从 8.0 版本开始支持，提供了一种灵活的方式处理 SQL 查询中的数据。无需分组即可对行集进行分析，常用于计算排名、累计和、移动平均值等。基本语法包括 `function_name([arguments]) OVER ([PARTITION BY columns] [ORDER BY columns] [frame_clause])`，常见函数有 `ROW_NUMBER()`, `RANK()`, `DENSE_RANK()`, `SUM()`, `AVG()` 等。窗口框架定义了计算聚合值时应包含的行。适用于复杂数据操作和分析报告。
大数据文摘
37 11
栈江湖
|
1天前
|
存储 Oracle 关系型数据库
索引在手，查询无忧：MySQL索引简介
MySQL 是一款广泛使用的关系型数据库管理系统，在2024年5月的DB-Engines排名中得分1084，仅次于Oracle。本文介绍MySQL索引的工作原理和类型，包括B+Tree、Hash、Full-text索引，以及主键、唯一、普通索引等，帮助开发者优化查询性能。索引类似于图书馆的分类系统，能快速定位数据行，极大提高检索效率。
栈江湖
23 8
蓝易云
|
7天前
|
存储 关系型数据库 MySQL
mysql怎么查询longblob类型数据的大小
通过本文的介绍，希望您能深入理解如何查询MySQL中 `LONG BLOB`类型数据的大小，并结合优化技术提升查询性能，以满足实际业务需求。
蓝易云
36 6
高端源码库
|
15天前
|
JavaScript 安全 Java
java版药品不良反应智能监测系统源码，采用SpringBoot、Vue、MySQL技术开发
基于B/S架构，采用Java、SpringBoot、Vue、MySQL等技术自主研发的ADR智能监测系统，适用于三甲医院，支持二次开发。该系统能自动监测全院患者药物不良反应，通过移动端和PC端实时反馈，提升用药安全。系统涵盖规则管理、监测报告、系统管理三大模块，确保精准、高效地处理ADR事件。
高端源码库
30 1
一位隐者
|
20天前
|
Java 关系型数据库 MySQL
如何将Spring Boot + MySQL应用程序部署到Pivotal Cloud Foundry (PCF)
如何将Spring Boot + MySQL应用程序部署到Pivotal Cloud Foundry (PCF)
一位隐者
39 5
2G冲浪词条
|
19天前
|
SQL 关系型数据库 MySQL
mysql分页读取数据重复问题
在服务端开发中，与MySQL数据库进行数据交互时，常因数据量大、网络延迟等因素需分页读取数据。文章介绍了使用`limit`和`offset`参数实现分页的方法，并针对分页过程中可能出现的数据重复问题进行了详细分析，提出了利用时间戳或确保排序规则绝对性等解决方案。
2G冲浪词条
25 1
游客54bz4h3flp7ai
|
24天前
|
关系型数据库 MySQL 数据库
GBase 数据库如何像MYSQL一样存放多行数据
GBase 数据库如何像MYSQL一样存放多行数据
游客54bz4h3flp7ai
28 2
WangBai
|
1月前
|
缓存 NoSQL 关系型数据库
Redis和Mysql如何保证数据⼀致?
在项目中，为了解决Redis与Mysql的数据一致性问题，我们采用了多种策略：对于低一致性要求的数据，不做特别处理；时效性数据通过设置缓存过期时间来减少不一致风险；高一致性但时效性要求不高的数据，利用MQ异步同步确保最终一致性；而对一致性和时效性都有高要求的数据，则采用分布式事务（如Seata TCC模式）来保障。
WangBai
64 14
封神
|
分布式计算 关系型数据库 MySQL
E-Mapreduce如何处理RDS的数据
目前网站的一些业务数据存在了数据库中，这些数据往往需要做进一步的分析，如：需要跟一些日志数据关联分析，或者需要进行一些如机器学习的分析。在阿里云上，目前E-Mapreduce可以满足这类进一步分析的需求。
封神
4979 0

物联网

热门文章

最新文章

  • 1
    阿里云联合思普瑞上线平安社区服务平台 提供物联网一站式管理
  • 2
    PostgreSQL "物联网"应用 - 1 实时流式数据处理案例(万亿每天)
  • 3
    塑云科技：性能突破，基于KafKa+OTS+MaxCompute 完成了一次物联网系统技术重构
  • 4
    AliOS Things开发：让你的开发板支持AliOS Studio烧录
  • 5
    uDevice Center - IoT在线开发板/设备平台
  • 6
    一个简单算法可以帮助物联网,金融 用户 节约98%的数据存储成本 (PostgreSQL,Greenplum帮你做到)
  • 7
    高性能时序数据库 HiTSDB 启动公测，为物联网而生的数据库！
  • 8
    旋转门数据压缩算法在PostgreSQL中的实现 - 流式压缩在物联网、监控、传感器等场景的应用
  • 9
    【阿里云IoT+YF3300】1.时代大背景下的阿里云IoT物联网的现状和未来
  • 10
    【云栖大会】AliOS Things宣布开源，支持物联网设备快速上云
  • 1
    「Mac畅玩鸿蒙与硬件46」UI互动应用篇23 - 自定义天气预报组件
    59
  • 2
    docker基础篇：安装tomcat
    91
  • 3
    「Mac畅玩鸿蒙与硬件45」UI互动应用篇22 - 评分统计工具
    103
  • 4
    「Mac畅玩鸿蒙与硬件44」UI互动应用篇21 - 随机励志语录生成器
    57
  • 5
    docker高级篇（大厂进阶）：安装mysql主从复制
    46
  • 6
    三分钟轻松搞定固定资产盘点--首码RFID资产盘点小助手
    26
  • 7
    docker高级篇（大厂进阶）：安装redis集群
    51
  • 8
    《docker高级篇（大厂进阶）：4.Docker网络》包括：是什么、常用基本命令、能干嘛、网络模式、docker平台架构图解
    91
  • 9
    本地部署MES生产管理系统，贝锐花生壳快速实现安全远程访问
    54
  • 10
    《docker高级篇（大厂进阶）：5.Docker-compose容器编排》包括是什么能干嘛去哪下、Compose核心概念、Compose使用三个步骤、Compose常用命令、Compose编排微服务
    61

    • 相关课程

    更多
  • MySQL企业常见架构与调优经验分享
  • 云数据库MySQL版快速上手教程
  • 阿里云云原生数据仓库AnalyticDB MySQL版 使用教程
  • MySQL实战进阶
  • 数据库及SQL/MySQL基础
  • 云数据库MySQL快速入门

    • 相关电子书

    更多
  • 搭建电商项目架构连接MySQL
  • 搭建4层电商项目架构，实战连接MySQL
  • PolarDB MySQL引擎重磅功能及产品能力盛大发布

    • 相关实验场景

    更多
  • MySQL基础-学生管理系统数据库设计
  • 如何快速连接云数据库RDS MySQL
  • MySQL数据库快速部署实践
  • MySQL引擎及架构优化
  • 基于EBS部署高性能的MySQL服务
  • 使用CloudLens采集RDS日志并进行审计分析

    • 推荐镜像

    更多
  • mysql
  • mariadb
  • postgresql
    • 下一篇
    DataWorks