精华内容
下载资源
问答
  • 同比环比计算

    2020-08-03 15:37:59
    1.同比环比的区别和意义 1.1区别 同比:本期与同期做对比。例如 有当前月份的数据,获取上一年相同月份的数据进行比较 环比:本期与上期做对比。例如 有当前月份的数据,获取本年上月的数据进行比较 1.2意义 同比和...

    1.同比环比的区别和意义

    1.1区别

    同比:本期与同期做对比。例如 有当前月份的数据,获取上一年相同月份的数据进行比较

    环比:本期与上期做对比。例如 有当前月份的数据,获取本年上月的数据进行比较

    1.2意义

    同比和环比用于表示某一事物在对比时期内发展变化的方向和程度,以财务盈利为例,同比和环比可以反应企业当前的盈利情况,对比上月和去年是否上升还是下降

    2.同比环比实现代码

    SELECT CWBB_ZBBH 
          ,CQJ
          ,NLRZE_DQ
          ,LAG(NLRZE_DQ, 1, 0) OVER(PARTITION BY CWBB_ZBBH ORDER BY CQJ) AS NZYSR_HB-- 环比分析,与上个月份进行比较
          ,LAG(NLRZE_DQ, 12, 0) OVER(PARTITION BY CWBB_ZBBH ORDER BY CQJ) AS NZYSR_TB-- 同比分析,与上个年度相同月份进行比较   
      FROM DW_CW_CWBBZB
    

    环比分析是通过窗口函数的lag() over()先实现按照分析维度进行分组,按照日期进行排序,然后lag去拉去上一行的数据。
    同比分析是通过窗口函数的lag() over()先实现按照分析维度进行分组,按照日期进行排序,然后lag去拉去当前年月前12行的数据

    展开全文
  • Java计算同比环比

    2020-12-08 09:59:34
    同比环比计算基本概念和计算公式 同比率:本年数据比上一年数据增长或减少的比率 同比率计算公式:rate = (本年数据 - 前一年数据) / 前一年数据 实例:2020年10月游客数量为80W,2019年10月游客数量为100W,2018年...

    Java计算同比环比
    同比环比计算基本概念和计算公式
    同比率:本年数据比上一年数据增长或减少的比率
    同比率计算公式:rate = (本年数据 - 前一年数据) / 前一年数据
    实例:2020年10月游客数量为80W,2019年10月游客数量为100W,2018年10月游客数量为90W
    2020年同比率为:rate :(80 - 100)/100 * 100%= -20%
    2019年同比率为:rate :(100 - 900)/900 * 100%= +11%
    (“+” 为增长,“-”为降低)

    环比率:本月(季度)数据比上个月(季度)数据增长或减少的比率
    环比率计算公式:rate = (本月数据 - 上个月数据) / 上个月数据
    实例:2020年10月游客数量为100W,2020年9月游客数量为90W,2020年7月游客数量为80W
    2020年10月同比率为:rate :(100 - 90)/90 * 100%= +11%
    2019年10月同比率为:rate :(90- 80)/800 * 100%= +12.5%
    注:同比环比计算公式是相同的,但计算数据对应的时间是不同的

    代码实现逻辑
    通过Calendar等时间函数和HashMap,[ hashmap(key,value) key为时间,value为该时间对应的值]。将key和value一一对应的存入集合中,通过对key进行操作,再用key获取HashMap中相对应的value,套公式计算(重点在于对时间(key)的操作,通过key可直接获取value进行计算)

    详细逻辑步骤
    首先通过SQL语句获取数据库中相应的时间和该时间对应的数据,按时间分组排序

    SELECT
            DATAS.DATE AS NAME ,
            SUM( DATAS.VISITORSUM) AS VALUE,
            2 AS sfzj,
            '' AS bfb
            FROM
            (SELECT TOURIST.* ,CONCAT(YEAR,'年',QUARTER,'月') AS DATE
            FROM TOURISTFLOW TOURIST)DATAS
            GROUP BY DATAS.DATE
            ORDER BY DATAS.DATE
    

    接着设置时间范围,将最早的时间减去一年设为最小时间,最后的时间为最大时间,以此为范围即可保证覆盖所有数据

    // 设置时间范围
                // 获取最前的时间的第一个列表
                analyzeBean firstTimeSubway = analyzeByYear.get(0);
                String startTime = firstTimeSubway.getTime();
                // 获取最后时间的最后一个列表
                analyzeBean endTimeSubway = analyzeByYear.get(analyzeByYear.size() - 1);
                String endTime = endTimeSubway.getTime();
                // 时间格式转换
                SimpleDateFormat format = new SimpleDateFormat("yyyy年MM月");
                Date parse = format.parse(startTime);
                Date parse1 = format.parse(endTime);
                Calendar c = Calendar.getInstance();
                c.setTime(parse);
                c.add(Calendar.YEAR, -1);
                Date y = c.getTime();
                // 获取最前的时间的前一年的时间作为查询范围
                String firstTime = format.format(y);
                analyzeRequestBean.setStartTime(firstTime);
                Calendar c1 = Calendar.getInstance();
                c1.setTime(parse1);
                Date y1 = c1.getTime();
                // 获取最后一年的时间作为查询范围
                String lastTime = format.format(y1);
                analyzeRequestBean.setStartTime(lastTime);
    

    在将所有数据的结果集存入HashMap中 hash(key,value) key为时间,value为数据值

    hashMap.put(time, analyzeByYear.get(i).getValue());
    

    最后通过for循环和CaleCndar函数和Date函数对时间(key)进行相应的操作,再通过时间(key)到HashMap中找对应的值进行计算

    for (int i = 0; i < analyzeByYear.size(); i++) {
                    AnalyzeBean analyzeBean = analyzeByYear.get(i);
                    if (i == 0) {
                    	// 是否增长("0:降低 1:增加 2:既不增长也不降低")
                        analyzeBean.setSfzj(2);
                        analyzeBean.setBfb(null);
                    } else {
                        SimpleDateFormat format2 = new SimpleDateFormat("yyyy年MM月");
                        // 当前数据
                        Date parse2 = format2.parse(analyzeBean.getTime());
                        Calendar c2 = Calendar.gaetInstance();
                        c2.setTime(parse2);
                        c2.add(Calendar.YEAR, 0);
                        Date t = c2.getTime();
                        String time = format2.format(t);
                        Integer value = hashMap.get(time);
                        // 往年数据
                        Date parse3 = format2.parse(time);
                        Calendar c3 = Calendar.getInstance();
                        c3.setTime(parse3);
                        c3.add(Calendar.YEAR, -1);
                        Date year = c3.getTime();
                        String time1 = format2.format(year);
                        Integer value1 = hashMap.get(time1);
                        if (null != value1 && null != value) {
                            if (value.equals(value1)) {
                                analyzeBean.setSfzj(2);
                                analyzeBean.setBfb(null);
                            } else {
                                if (value > value1) {
                                    analyzeBean.setSfzj(1);
                                } else {
                                    analyzeBean.setSfzj(0);
                                }
                                // 2个值减法 绝对值
                                int abs = Math.abs(value - value1);
                                float a = (float) (abs) / (float) value1 * 100;
                                analyzeBean.setBfb(a + "");
                            }
                        } else {
                            analyzeBean.setSfzj(2);
                            analyzeBean.setBfb(null);
                        }
                    }
                }
    

    同比实例代码:

    // 求同比
        @Override
        public Result getAnalyzeByYear(AnalyzeRequestBean analyzeRequestBean) {
            try {
                // 检查参数
                if (null == analyzeRequestBean) {
                    return ResultUtil.fail(ResultEnum.PARAMS_ERROR);
                }
    a
                List<AnalyzeBean> analyzeByYear
                        = InfoMapper.getAnalyzeByYear(analyzeRequestBean);
    
                if (analyzeByYear == null || analyzeByYear.size() == 0) {
                    return ResultUtil.ok(null);
                }
    
                // 设置时间范围
                // 获取最前的时间的第一个列表
                analyzeBean firstTimeSubway = analyzeByYear.get(0);
                String startTime = firstTimeSubway.getTime();
                // 获取最后时间的最后一个列表
                analyzeBean endTimeSubway = analyzeByYear.get(analyzeByYear.size() - 1);
                String endTime = endTimeSubway.getTime();
                // 时间格式转换
                SimpleDateFormat format = new SimpleDateFormat("yyyy年MM月");
                Date parse = format.parse(startTime);
                Date parse1 = format.parse(endTime);
                Calendar c = Calendar.getInstance();
                c.setTime(parse);
                c.add(CaleCndar.YEAR, -1);
                Date y = c.getTime();
                // 获取最前的时间的前一年的时间作为查询范围
                String firstTime = format.format(y);
                analyzeRequestBean.setStartTime(firstTime);
                Calendar c1 = Calendar.getInstance();
                c1.setTime(parse1);
                Date y1 = c1.getTime();
                // 获取最后一年的时间作为查询范围
                String lastTime = format.format(y1);
                analyzeRequestBean.setStartTime(lastTime);
                // 把大范围的结果集都放入hashMap中
                HashMap<String, Integer> hashMap = new HashMap<>();
                for (int i = 0; i < analyzeByYear.size(); i++) {
                    analyzeBean analyzeBean = analyzeByYear.get(i);
                    SimpleDateFormat format1 = new SimpleDateFormat("yyyy年MM月");
                    Date parse2 = format1.parse(analyzeBean.getTime());
                    Calendar c2 = Calendar.getInstance();
                    c2.setTime(parse2);
                    c2.add(Calendar.YEAR, 0);
                    Date t = c2.getTime();
                    String time = format1.format(t);
                    hashMap.put(time, analyzeByYear.get(i).getValue());
                }
    
                for (int i = 0; i < analyzeByYear.size(); i++) {
                    AnalyzeBean analyzeBean = analyzeByYear.get(i);
                    if (i == 0) {
                    	// 是否增长("0:降低 1:增加 2:既不增长也不降低")
                        analyzeBean.setSfzj(2);
                        analyzeBean.setBfb(null);
                    } else {
                        SimpleDateFormat format2 = new SimpleDateFormat("yyyy年MM月");
                        // 当前数据
                        Date parse2 = format2.parse(analyzeBean.getTime());
                        Calendar c2 = Calendar.gaetInstance();
                        c2.setTime(parse2);
                        c2.add(Calendar.YEAR, 0);
                        Date t = c2.getTime();
                        String time = format2.format(t);
                        Integer value = hashMap.get(time);
                        // 往年数据
                        Date parse3 = format2.parse(time);
                        Calendar c3 = Calendar.getInstance();
                        c3.setTime(parse3);
                        c3.add(Calendar.YEAR, -1);
                        Date year = c3.getTime();
                        String time1 = format2.format(year);
                        Integer value1 = hashMap.get(time1);
                        if (null != value1 && null != value) {
                            if (value.equals(value1)) {
                                analyzeBean.setSfzj(2);
                                analyzeBean.setBfb(null);
                            } else {
                                if (value > value1) {
                                    analyzeBean.setSfzj(1);
                                } else {
                                    analyzeBean.setSfzj(0);
                                }
                                // 2个值减法 绝对值
                                int abs = Math.abs(value - value1);
                                float a = (float) (abs) / (float) value1 * 100;
                                analyzeBean.setBfb(a + "");
                            }
                        } else {
                            analyzeBean.setSfzj(2);
                            analyzeBean.setBfb(null);
                        }
                    }
                }
                return ResultUtil.ok(analyzeByYear);
            } catch (ParseException ex) {
                ex.printStackTrace();
            }
            return ResultUtil.ok(null);
    

    环比类似,只是把c.add(Calendar.YEAR, 0);换成c.add(Calendar.MONTH, 0)
    实现逻辑其实不难,只是我写复杂了,如有更好的方法欢迎留言交流讨论## Java计算同比环比

    展开全文
  • ORACLE计算同比环比

    千次阅读 2020-07-06 14:19:18
    同比环比概念和公式 同比: 同比一般情况下是今年第n月与去年第n月比 环比: 表示连续2个统计周期(比如连续两月)内的量的变化比。 同比增长率=(本期数-同期数)/|同期数|×100% 环比增长率=(本期数-上期数)/上期...

    同比环比概念和公式

    同比: 同比一般情况下是今年第n月与去年第n月比

    环比: 表示连续2个统计周期(比如连续两月)内的量的变化比。

    同比增长率=(本期数-同期数)/|同期数|×100%

    环比增长率=(本期数-上期数)/上期数×100%

    需求:

    计算2020年01月到2020年2月, 每个月的本期值和环比和同比率

    数据库 表和数据准备

    CREATE TABLE test (
      "ID" NUMBER NOT NULL ,
      "VALUE" NUMBER ,
      "YEARMONTH" VARCHAR2(6 CHAR) ,
      CONSTRAINT "SYS_C0086930" PRIMARY KEY ("ID")
    )
    
    
    INSERT INTO "test"("ID", "VALUE", "YEARMONTH") VALUES ('1', '100', '202002');
    INSERT INTO "test"("ID", "VALUE", "YEARMONTH") VALUES ('2', '80', '202001');
    INSERT INTO "test"("ID", "VALUE", "YEARMONTH") VALUES ('3', '120', '201912');
    INSERT INTO "test"("ID", "VALUE", "YEARMONTH") VALUES ('4', '142', '201911');
    INSERT INTO "test"("ID", "VALUE", "YEARMONTH") VALUES ('5', '70', '201910');
    INSERT INTO "test"("ID", "VALUE", "YEARMONTH") VALUES ('6', '51', '201901');
    
    

    oracle 需要用到的函数简绍:

    NVL(expr1, expr2)

    expr1为空时, 给默认值expr2
    

    TO_CHAR(number,‘格式’)

      格式化函数 如:FM99990.00 
    	9代表此位为0或没有值时,不显示. 0代表此位为0或者没有值时补0. 
        小数点前是99990五位,代表数字的整数位只能有5位,小数位00表示,保留2位小数
    

    ROUND(number[,decimals])

    number 待做截取处理的数值
    decimals 指明需保留小数点后面的位数。可选项,忽略它则截去所有的小数部分,并四舍五入。
    如果为负数则表示从小数点开始左边的位数,相应整数数字用0填充,小数被去掉. 
    对截取的数字要四舍五入。
    

    DECODE(条件,值1,返回值1,值2,返回值2,…值n,返回值n,缺省值)

    该函数的含义如下:
    
    
    IF 条件=值1 THEN
        RETURN(返回值1)
    ELSIF 条件=值2 THEN
        RETURN(返回值2)
        ......
    ELSIF 条件=值n THEN
        RETURN(返回值n)
    ELSE
        RETURN(缺省值)
    END IF
    

    计算同比和环比最重要的函数

    LAG(exp_str,offset,default) OVER(partition by expr2 order by expr3)

    LEAD(exp_str,offset,default) OVER(partition by expr2 order by expr3)

    exp_str 要做对比的字段
    offset 偏移量
    default 默认值
    
    partition by expr2 根据expr2分组
    order by expr3 根据expr3排序
    
    LAG函数: 向上取offset行的数据中exp_str字段,如果没有取default
    LEAD函数: 向下取offset行的数据种exp_str字段,如果没有取default
    OVER函数: 先对数据先进行分组和排序. 如: 这次测试,我们用日期进行排序,保证了LAG函数向上取offset行,能取到
    对应的环比和同比的日期的值
    
    
    

    再简绍一下,如何获取一个时间段内连续的日期

    这样保证了如果数据库中有些日期没有数据时,可以给一个默认值,使LAG和LEAD函数可以获取到正确的行数

    SELECT AA.monthlist, NVL(BB.CAP,0) CAP FROM -- 获取需要查询的时间范围内 连续月份的 数据值
    (SELECT
      TO_CHAR( ADD_MONTHS( TO_DATE( '201901', 'yyyyMM' ), ROWNUM - 1 ), 'yyyyMM' ) AS monthlist 
    FROM
      DUAL CONNECT BY ROWNUM <= months_between(
        to_date( '202001', 'yyyyMM' ),
        to_date( '201901', 'yyyyMM' )) + 1
    

    思路:

    第一步: 将需要的业务数据计算出来. 也就是将我们数据库中有的数据,按照日期分组.

    注意: 在这里我们从业务数据表中获取数据的时间范围,并不是我们需要求的2020年01月到2020年2月的数据,我们想要计算得到同比值那就必须得到最早开始时间(2020年1月)向前推12月的日期,即2019年1月. 这样我们才能

    同比增长率=(本期数2020年1月 - 同期数2019年1月 )/ 同期数2019年1月 ×100% .

    环比值所需要的数据(2019年12月)已经在范围内

    SELECT YEARMONTH, NVL(SUM(VALUE), 0) VALUE FROM  "test" 
    WHERE YEARMONTH >=  201901 AND YEARMONTH <= 202002 
    GROUP BY YEARMONTH ORDER BY YEARMONTH
    

    结果:

    YEARMONTH	VALUE
    201901		 51
    201910		 70
    201911		 142
    201912		 120
    202001		 80
    202002		 100
    

    第二步: 用我们上面简绍的获取连续月份的sql和上一步我们计算出来的业务数据连表, 并与连续月份的临时表为主表.

    ​ 这样我们就可以得到,我们需要的时间范围只能的所有日期和它的值

    ​ 注意: ①获取连续日期的sql的时间范围和上一步的相同,都必须包含到同比值

    SELECT AA.YEARMONTH, NVL(BB.VALUE, 0) VALUE FROM 
    	(SELECT
    	TO_CHAR( ADD_MONTHS( TO_DATE( '201901', 'yyyyMM' ), ROWNUM - 1 ), 'yyyyMM' ) AS YEARMONTH 
    	FROM DUAL 
    	CONNECT BY ROWNUM <= months_between( to_date( '202002', 'yyyyMM' ), to_date( '201901', 'yyyyMM' )) + 1) AA
    
    LEFT JOIN
    	(
    		SELECT YEARMONTH, NVL(SUM(VALUE), 0) VALUE FROM  "test" 
    		WHERE YEARMONTH >=  201901 AND YEARMONTH <= 202002 
    		GROUP BY YEARMONTH ORDER BY YEARMONTH
    	) BB 
    ON AA.YEARMONTH = BB.YEARMONTH	ORDER BY  AA.YEARMONTH
    

    结果:

    YEARMONTH	VALUE
    201901		51
    201902		0
    201903		0
    201904		0
    201905		0
    201906		0
    201907		0
    201908		0
    201909		0
    201910		70
    201911		142
    201912		120
    202001		80
    202002		100
    

    第三步: 使用LAG或LEAD函数,使现值,环比值(month-on-month)和同比值(year-on-year)成为一行数据.

    注意: 我们这里使用的LAG**(exp_str,offset,default)**函数, 它向上取offset行的值exp_str,如果没有就是default.

    SELECT
    CC.YEARMONTH,
    CC.VALUE,
    LAG ( CC.VALUE, 1, 0 ) OVER (  ORDER BY CC.YEARMONTH ) AS monthOnMonth,
    LAG ( CC.VALUE, 12, 0 ) OVER (  ORDER BY CC.YEARMONTH ) AS yearOnYear
    FROM (
    	SELECT AA.YEARMONTH, NVL(BB.VALUE, 0) VALUE FROM 
    		(SELECT
    		TO_CHAR( ADD_MONTHS( TO_DATE( '201901', 'yyyyMM' ), ROWNUM - 1 ), 'yyyyMM' ) AS YEARMONTH 
    		FROM DUAL 
    		CONNECT BY ROWNUM <= months_between( to_date( '202002', 'yyyyMM' ), to_date( '201901', 'yyyyMM' )) + 1) AA
    
    	LEFT JOIN
    		(
    			SELECT YEARMONTH, NVL(SUM(VALUE), 0) VALUE FROM  "test" 
    			WHERE YEARMONTH >=  201901 AND YEARMONTH <= 202002 
    			GROUP BY YEARMONTH ORDER BY YEARMONTH
    		) BB 
    	ON AA.YEARMONTH = BB.YEARMONTH	ORDER BY  AA.YEARMONTH
    
    ) CC
    

    结果: 我们可以观察结果,发现月份都获取到了正确的环比和同比值

    YEARMONTH	VALUE	MONTHONMONTH	YEARONYEAR
    201901		 51			 0				0
    201902		 0			 51				0
    201903		 0			 0				0
    201904		 0			 0				0
    201905		 0			 0				0
    201906		 0			 0				0
    201907		 0			 0				0
    201908		 0			 0				0
    201909		 0			 0				0
    201910   	 70	         0				0
    201911		 142	     70				0
    201912		 120		 142			0
    202001		80			 120			51
    202002		100			 80				0
    

    第四步: 计算出环比和同比的增长率

    按照公式

    同比增长率=(本期数-同期数)/|同期数|×100%

    环比增长率=(本期数-上期数)/上期数×100%

    注意: ① 我们在上一步中可以看到,我们的环比和同比值有可能为0, 但是根据公式,环比和同比值需要做被除数,而被除数又不能等于0,所以我们需要使用DECODE函数,如何值为0,环比和同比的增长率就为0

    ​ ② 在整个sql的最后面我们要加一个时间范围条件. 因为我们之前计算的都是根据最大日期范围计算的. 但是我们所需要的仅仅是 2020年1月到2020年2月的数据,所以加上时间范围条件.只获取我们所需的数据.

    SELECT 
    DD.YEARMONTH,
    DD.VALUE,
    TO_CHAR(NVL(ROUND(DECODE(DD.monthOnMonth,0,100,(DD.VALUE - DD.monthOnMonth )/DD.monthOnMonth * 100),2), 0), 'fm9999999990.00') || '%' 环比增长率,
    TO_CHAR(NVL(ROUND(DECODE(DD.yearOnYear,0,100,(DD.VALUE - DD.yearOnYear)/DD.yearOnYear * 100),2), 0),'fm9999999990.00')  || '%' 同比增长率
    FROM (
    	SELECT
    	CC.YEARMONTH,
    	CC.VALUE,
    	LAG ( CC.VALUE, 1, 0 ) OVER (  ORDER BY CC.YEARMONTH ) AS monthOnMonth,
    	LAG ( CC.VALUE, 12, 0 ) OVER (  ORDER BY CC.YEARMONTH ) AS yearOnYear
    	FROM (
    		SELECT AA.YEARMONTH, NVL(BB.VALUE, 0) VALUE FROM 
    			(SELECT
    			TO_CHAR( ADD_MONTHS( TO_DATE( '201901', 'yyyyMM' ), ROWNUM - 1 ), 'yyyyMM' ) AS YEARMONTH 
    			FROM DUAL 
    			CONNECT BY ROWNUM <= months_between( to_date( '202002', 'yyyyMM' ), to_date( '201901', 'yyyyMM' )) + 1) AA
    
    		LEFT JOIN
    			(
    				SELECT YEARMONTH, NVL(SUM(VALUE), 0) VALUE FROM  "test" 
    				WHERE YEARMONTH >=  201901 AND YEARMONTH <= 202002 
    				GROUP BY YEARMONTH ORDER BY YEARMONTH
    			) BB 
    		ON AA.YEARMONTH = BB.YEARMONTH	ORDER BY  AA.YEARMONTH
    
    	) CC
    ) DD WHERE DD.YEARMONTH >= 202001 AND DD.YEARMONTH <=202002
    
    

    👆 就是最终的推导出的sql,该sql还可以优化和简化, sql优化和简化不是本篇的重点,如有需要请根据实际情况处理.

    展开全文
  • Tableau同比环比计算方法

    千次阅读 2020-08-27 09:26:32
    笔者借鉴学习了6种tableau同比环比计算方法 方法1:官方提供的快速表计算:年度同比增长 方法2:筛选年份同比上一年 方法3:通过设定日期月度范围来比较销售额 方法4:

    笔者借鉴学习了6种tableau同比或环比计算方法

    方法1:官方提供的快速表计算:年度同比增长

    方法2:筛选年份同比上一年
    在这里插入图片描述
    方法3:通过设定日期月度范围来比较销售额
    在这里插入图片描述

    方法4:与去年、2年前、3年前对比
    在这里插入图片描述

    方法5:

    展开全文
  • MySQL 计算同比环比

    2021-01-15 21:03:20
    使用 case when 语句计算这张联合表相应列的比值, 即为同比环比数据 实际语句示例: # 计算同比 select s1.id,currDate,currSum currSumFee,prevDate,prevSum prevSumFee, CASE WHEN prevSum>0 THEN (currSum-...
  • mysql计算同比环比

    2020-05-21 20:50:11
    sql 计算同比环比 – 同比 SELECT t1.now_year AS 年份, t1.now_month AS 月份, CASE WHEN now_month_num IS NULL OR now_month_num = 0 THEN 0 ELSE now_month_num END 本月销售量, CASE WHEN last_month_num IS ...
  • pandas计算同比环比增长

    万次阅读 2019-06-18 17:29:17
    我有2017.1-2018.12的销售数据,计算每一个月的 同比环比增长,没有的话 用null代替 注释: 同比环比 都是为了显示数据的变化速度,但是基数不同,同比侧重长期数据趋势变化,环比侧重于短期内数据趋势变化 ...
  • 同比环比计算公式?

    万次阅读 2017-09-15 15:57:53
    同比增长计算公式: 同比增长率=(本期数-同期数)÷同期数×100% 环比增长率=(本期数-上期数)/上期数×100%。 简单地说,就是同比环比与定基比,都可以用百分数或倍数表示。 定基比发展速度,也简称总速度,一般...
  • MDX同比环比计算

    千次阅读 2017-07-22 21:39:40
    同比: Iif(IsEmpty(([table_profit].[报告期].CurrentMember.Parent.PrevMember, [Measures].[净利率(%)])) OR IsEmpty([Measures].[净利率(%)]) OR ([table_profit].[报告期].CurrentMember.Parent....
  • mysql实现同比环比计算

    千次阅读 2019-07-25 23:15:08
    同比: select t5.m,FORMAT(((t5.newhan-t5.oldhan)/t5.oldhan)*100,2) from ( select t3.month as m,t3.avg_han as newhan,t2.avg_han1 as oldhan from (select date_format(time, '%Y-%m') as month,avg(han) ...
  • 同比数据计算公式: 同比:一般情况下是今年第n月与去年第n月比 计算方式:同比增长率=(本期数-同期数)÷同期数×100% 所以要有个本期数据与同期数据一一对应的表,那就要本期数据与同期数据分离 环比数据计算...

空空如也

空空如也

1 2 3 4 5 ... 15
收藏数 284
精华内容 113
关键字:

同比环比计算