如何使用postgresql做顺序扣减库存

Ⅰ.废话在前面

首先这篇笔记源自于最近的一次需求，这个临时性需求是根据两份数据(库存数据以及出库数据） 算出实际库存给到业务，至于库存为什么不等于剩余库存，这个一两句话也说不清(主要是我不懂。。。)，算出来的实际库存是以产品&批次为主展示实际库存(库存按日期分批次不求总)，所以给的出库数据（需要扣减的）一个按产品代码汇总的数据，顺带一提的是两张表是以产品代码连接的 ； 最终，算出来的实际库存除了会有库存表日期和数量外还得有 扣减数量列 以及 扣减后数量（实际库存)，扣减顺序是按照批次的日期升序扣减，批次日期为空的首先扣减（需考虑到排序）；还有就是：没有任何扣减数量（没有出库的）的产品 最终的 扣减后数量（批次库存数量-出库数量） 为库存数量，扣减数为零 ~

好了，我先给出测试的表数据以及最终结果的样子，各位思考思考哈~

Ⅱ.表数据及实际库存(结果)

  • 库存数据

    select * from t_product_inventory;

    id type 产品代码 日期 数量
    7 in 99999279 2018-11-01 24480
    8 in 99999279 2018-11-03 20832
    9 in 99999279 2018-12-02 21360
    10 in 99999279 2019-06-14 18768
    11 in 99999279 2019-06-16 9552
    12 in 99999279 2019-07-12 2304
    13 in 99999279 2019-09-05 3696
    14 in 99999279 2019-09-06 16
    15 in 99999279 2019-10-22 48
    16 in 99999279 2019-11-03 14112
    17 in 99999279 2019-12-02 2160
    18 in 99999279 2019-12-04 720
    19 in 99999279 2019-12-12 12960
    20 in 99999290 2019-12-23 6336
    21 in 99999290 2019-12-26 50
    29 in 99999777 2021-04-08 10011

  • 出库数据

    select * from t_product_out;

    id type 产品代码 数量
    1 out 99999279 77777
    2 out 99999290 10000

  • 实际库存（结果）

    id-- --产品代码-- --日期(库存批次日期)-- --数量(库存)-- --数量_出-- --出_入差异（出-库存)
    7 99999279 24480 24480 0
    8 99999279 2018-11-03 20832 20832 0
    9 99999279 2018-12-02 21360 21360 0
    10 99999279 2019-06-14 18768 11105 7663
    11 99999279 2019-06-16 9552 0 9552
    12 99999279 2019-07-12 2304 0 2304
    13 99999279 2019-09-05 3696 0 3696
    14 99999279 2019-09-06 16 0 16
    15 99999279 2019-10-22 48 0 48
    16 99999279 2019-11-03 14112 0 14112
    17 99999279 2019-12-02 2160 0 2160
    18 99999279 2019-12-04 720 0 720
    19 99999279 2019-12-12 12960 0 12960
    20 99999290 2019-12-23 6336 6336 0
    21 99999290 2019-12-26 50 50 3614
    29 99999777 2021-04-08 10011 0 10011

Ⅲ.思考及实现

首先要说sql的思考过程还是比较复杂滴（当然可以确定是我自跟儿写的），而整个过程几乎就是走一步看一步的解决问题的过程，掉了多少头发可想而知了。。。

First.我们确定在sql中处理，那首先想到的是得有个连表吧，另外排序也会是最easy的吧，let me try ~

  SELECT

  	i.id,

  	i.type,

  	i."产品代码",

  	i."日期",

  	i."数量",

  	o."出_汇总"

  FROM t_product_inventory i

   LEFT JOIN (

   SELECT t_product_out."产品代码",

  	sum(t_product_out."数量") AS "出_汇总"

  	FROM t_product_out

  	GROUP BY t_product_out."产品代码"

  ) o ON i."产品代码" = o."产品代码"

  ORDER BY i."产品代码", i."日期" NULLS FIRST;
id type 产品代码 日期 数量 出_汇总
7 in 99999279 24480 77777
8 in 99999279 2018-11-03 20832 77777
9 in 99999279 2018-12-02 21360 77777
10 in 99999279 2019-06-14 18768 77777
11 in 99999279 2019-06-16 9552 77777
12 in 99999279 2019-07-12 2304 77777
13 in 99999279 2019-09-05 3696 77777
14 in 99999279 2019-09-06 16 77777
15 in 99999279 2019-10-22 48 77777
16 in 99999279 2019-11-03 14112 77777
17 in 99999279 2019-12-02 2160 77777
18 in 99999279 2019-12-04 720 77777
19 in 99999279 2019-12-12 12960 77777
20 in 99999290 2019-12-23 6336 6386
21 in 99999290 2019-12-26 50 6386
29 in 99999777 2021-04-08 10011

[注意：因为所给的出库数据是没有重复的，以上是可以略去sum聚合这个操作的，因为两张表是按产品代码做关联的（很显然)，另外就是日期是可以降序排列的，但是在日期有null值的情况下null所在的记录默认是降序排在最后的，所以要 order by 要指定 NULLS FIRST 这样才能为后面null批次的做优先扣减 ]

Second. 我们已经通过连表做好出库的数据列，排序也做好了，现在。。。让我想想

觉得还是先回顾下需求吧，我们的需求是每个产品下每一个批次顺序扣减的最终结果（还有批次扣减的数），其中扣减数量应该就是=当前批次(库存)数量-出库数量，公式是确定的，看起来似乎简单，然而难点是如何算出这个”扣减数量（出库数量）“呢？？？ 。。。 想想，我们用当前产品出库总数按批次往下减，这样会出现一个问题是批次剩余数量=出库总数-当前批次数量，而且这个批次剩余数量并不能累加，只能用出库数量依次递减才是，。。。好了，这又是一个难点，继续思考下，目前我们是不是没法做(至少是没法简单的)获取到 库存数量-出库数量；幸运的是。。。如果将产品库存数量依次递减，这样不就可以算出库存差异了（事实上这样也有各种各样的问题）。。。让我们试试看吧

SELECT

	i.id,

	i.type,

	i."产品代码",

	i."日期",

	i."数量",

	o."出_汇总",

	sum(i."数量") OVER (PARTITION BY i."产品代码" ORDER BY i."日期" NULLS FIRST, i."数量") AS "入_递增"

FROM (t_product_inventory i

 LEFT JOIN ( SELECT t_product_out."产品代码",

		sum(t_product_out."数量") AS "出_汇总"

		FROM t_product_out

		GROUP BY t_product_out."产品代码") o

 ON (((i."产品代码")::text = (o."产品代码")::text)))

ORDER BY i."产品代码", i."日期" NULLS FIRST;
id type 产品代码 日期 数量 出_汇总 入_递增
7 in 99999279 24480 77777 24480
8 in 99999279 2018-11-03 20832 77777 45312
9 in 99999279 2018-12-02 21360 77777 66672
10 in 99999279 2019-06-14 18768 77777 85440
11 in 99999279 2019-06-16 9552 77777 94992
12 in 99999279 2019-07-12 2304 77777 97296
13 in 99999279 2019-09-05 3696 77777 100992
14 in 99999279 2019-09-06 16 77777 101008
15 in 99999279 2019-10-22 48 77777 101056
16 in 99999279 2019-11-03 14112 77777 115168
17 in 99999279 2019-12-02 2160 77777 117328
18 in 99999279 2019-12-04 720 77777 118048
19 in 99999279 2019-12-12 12960 77777 131008
20 in 99999290 2019-12-23 6336 10000 6336
21 in 99999290 2019-12-26 50 10000 6386
29 in 99999777 2021-04-08 10011 10011

[看,我们将各个产品库存数量按照批次的顺序依次递增累加了（入_递增这一列），注意窗口函数内需要排序！]

Third. 好了，让我们趁热将差异也算出来吧

SELECT t1.id,

  t1.type,

  t1."产品代码",

  t1."日期",

  t1."数量",

  t1."出_汇总",

  t1."入_递增",

      CASE

          WHEN (((t1."出_汇总" - t1."入_递增") > (0)::numeric) /*AND (t1.rk <> t1.rk_ct)*/) THEN (0)::numeric

          ELSE (t1."入_递增" - t1."出_汇总")

      END AS "出_入差异"

 FROM (

	SELECT i.id,

          i.type,

          i."产品代码",

          i."日期",

          i."数量",

          o."出_汇总",

          sum(i."数量") OVER (PARTITION BY i."产品代码" ORDER BY i."日期" NULLS FIRST, i."数量") AS "入_递增"

         FROM (t_product_inventory i

           LEFT JOIN ( SELECT t_product_out."产品代码",

                  sum(t_product_out."数量") AS "出_汇总"

                 FROM t_product_out

                GROUP BY t_product_out."产品代码") o ON (((i."产品代码")::text = (o."产品代码")::text)))

        ORDER BY i."产品代码", i."日期" NULLS FIRST

) t1
id type 产品代码 日期 数量 出_汇总 入_递增 出_入差异
7 in 99999279 24480 77777 24480 0
8 in 99999279 2018-11-03 20832 77777 45312 0
9 in 99999279 2018-12-02 21360 77777 66672 0
10 in 99999279 2019-06-14 18768 77777 85440 7663
11 in 99999279 2019-06-16 9552 77777 94992 17215
12 in 99999279 2019-07-12 2304 77777 97296 19519
13 in 99999279 2019-09-05 3696 77777 100992 23215
14 in 99999279 2019-09-06 16 77777 101008 23231
15 in 99999279 2019-10-22 48 77777 101056 23279
16 in 99999279 2019-11-03 14112 77777 115168 37391
17 in 99999279 2019-12-02 2160 77777 117328 39551
18 in 99999279 2019-12-04 720 77777 118048 40271
19 in 99999279 2019-12-12 12960 77777 131008 53231
20 in 99999290 2019-12-23 6336 10000 6336 0
21 in 99999290 2019-12-26 50 10000 6386 0
29 in 99999777 2021-04-08 10011 10011

[看似一切都没有问题，所以中间我特意将 99999290 这款产品临时改为10000，这样你就会看到2019-12-26这个 出_入差异 值为零，零，怎么可能为零呢。。。不要计较了一定是sql有缺陷]

Third+. 对于以上sql出现的缺陷我准备做个Plus版以修复它~

**首先要确定的是 99999290 -> 2019-12-26 这个批次的差异应该是3614，造成这样的原因无非就是(最后一个批次的)出库数大于库存数~，看出问题了就不能无视缺陷的存在，所以对于最后一个批次如果出库数量仍然大于当前批次的数量，他的差异（出_入差异）应该就是负数；等等，那我如何确定每个产品的最后一个批次呢，让我们试着用sql找找看 **

  SELECT t1.id,

			t1.type,

			t1."产品代码",

			t1."日期",

			t1."数量",

			t1."出_汇总",

			t1.rk,

			t1.rk_ct,

			t1."入_递增",

			CASE

			  WHEN (((t1."出_汇总" - t1."入_递增") > (0)::numeric) AND (t1.rk <> t1.rk_ct)) THEN (0)::numeric

			  ELSE (t1."入_递增" - t1."出_汇总")

			END AS "出_入差异"

		 FROM (

		 SELECT i.id,

				i.type,

				i."产品代码",

				i."日期",

				i."数量",

				o."出_汇总",

				row_number() OVER (PARTITION BY i."产品代码" ORDER BY i."日期" NULLS FIRST, i."数量") AS rk,

				count(1) OVER (PARTITION BY i."产品代码") AS rk_ct,

				sum(i."数量") OVER (PARTITION BY i."产品代码" ORDER BY i."日期" NULLS FIRST, i."数量") AS "入_递增"

				FROM (t_product_inventory i

				 LEFT JOIN ( SELECT t_product_out."产品代码",

					sum(t_product_out."数量") AS "出_汇总"

					FROM t_product_out

					GROUP BY t_product_out."产品代码") o ON (((i."产品代码")::text = (o."产品代码")::text)))

				ORDER BY i."产品代码", i."日期" NULLS FIRST

) t1;
id type 产品代码 日期 数量 出_汇总 rk rk_ct 入_递增 出_入差异
7 in 99999279 24480 77777 1 13 24480 0
8 in 99999279 2018-11-03 20832 77777 2 13 45312 0
9 in 99999279 2018-12-02 21360 77777 3 13 66672 0
10 in 99999279 2019-06-14 18768 77777 4 13 85440 7663
11 in 99999279 2019-06-16 9552 77777 5 13 94992 17215
12 in 99999279 2019-07-12 2304 77777 6 13 97296 19519
13 in 99999279 2019-09-05 3696 77777 7 13 100992 23215
14 in 99999279 2019-09-06 16 77777 8 13 101008 23231
15 in 99999279 2019-10-22 48 77777 9 13 101056 23279
16 in 99999279 2019-11-03 14112 77777 10 13 115168 37391
17 in 99999279 2019-12-02 2160 77777 11 13 117328 39551
18 in 99999279 2019-12-04 720 77777 12 13 118048 40271
19 in 99999279 2019-12-12 12960 77777 13 13 131008 53231
20 in 99999290 2019-12-23 6336 10000 1 2 6336 0
21 in 99999290 2019-12-26 50 10000 2 2 6386 -3614
29 in 99999777 2021-04-08 10011 1 1 10011

[看，以上处理方式是不是赞，前面的缺陷完美滴解决，总结重点就是：通过窗口函数算出最后一列，这一列通过rk以及rk_ct比较得来的，想想看是不是很妙 ]

Next. oh ~ 糟糕

[_虽然我们可能注意到了出库数超出的情况，但是你可能忽略了最后一个问题，如果某个产品最近根本就没有出库呢...不妨看看 99999777 这款产品 是不是...是不是。。 ，当然对于出库数不存在的解决办法就相当easy了，当然如果你认真揣度过上面的sql的话。。。应该就不存在困难，如果不看以下sql，试试看~（相信你可以哟） _]

 SELECT

    tt1.id,

    tt1.type,

    tt1."产品代码",

    tt1."日期",

    tt1."数量",

    tt1."出_汇总",

    tt1.rk,

    tt1.rk_ct,

    tt1."入_递增",

    tt1."出_入差异",

    case when  tt1."出_汇总" is null  then 0 else

    ((tt1."数量")::numeric - COALESCE((tt1."出_入差异" - lag(tt1."出_入差异", 1, (0)::numeric) OVER (PARTITION BY tt1."产品代码" ORDER BY tt1."日期" NULLS FIRST, tt1."数量")),0)) end AS "数量_出",

    case when  tt1."出_汇总" is null  then tt1."数量" else

    (COALESCE(tt1."出_入差异",0) - lag(tt1."出_入差异", 1, (0)::numeric) OVER (PARTITION BY tt1."产品代码" ORDER BY tt1."日期" NULLS FIRST, tt1."数量")) end AS "出_入差异_result"

   FROM (

	 SELECT t1.id,

            t1.type,

            t1."产品代码",

            t1."日期",

            t1."数量",

            t1."出_汇总",

            t1.rk,

            t1.rk_ct,

            t1."入_递增",

                CASE

                    WHEN (((t1."出_汇总" - t1."入_递增") > (0)::numeric) AND (t1.rk <> t1.rk_ct)) THEN (0)::numeric

                    ELSE (t1."入_递增" - t1."出_汇总")

                END AS "出_入差异"

           FROM (

	       SELECT

       		i.id,

                    i.type,

                    i."产品代码",

                    i."日期",

                    i."数量",

                    o."出_汇总",

                    row_number() OVER (PARTITION BY i."产品代码" ORDER BY i."日期" NULLS FIRST, i."数量") AS rk,

                    count(1) OVER (PARTITION BY i."产品代码") AS rk_ct,

                    sum(i."数量") OVER (PARTITION BY i."产品代码" ORDER BY i."日期" NULLS FIRST, i."数量") AS "入_递增"

                   FROM (t_product_inventory i

                     LEFT JOIN ( SELECT t_product_out."产品代码",

                            sum(t_product_out."数量") AS "出_汇总"

                           FROM t_product_out

                          GROUP BY t_product_out."产品代码") o ON (((i."产品代码")::text = (o."产品代码")::text)))

                  ORDER BY i."产品代码", i."日期" NULLS FIRST

              ) t1

) tt1

  ORDER BY tt1."产品代码", tt1."日期" NULLS FIRST;
id type 产品代码 日期 数量 出_汇总 rk rk_ct 入_递增 出_入差异 数量_出 出_入差异_result
7 in 99999279 24480 77777 1 13 24480 0 24480 0
8 in 99999279 2018-11-03 20832 77777 2 13 45312 0 20832 0
9 in 99999279 2018-12-02 21360 77777 3 13 66672 0 21360 0
10 in 99999279 2019-06-14 18768 77777 4 13 85440 7663 11105 7663
11 in 99999279 2019-06-16 9552 77777 5 13 94992 17215 0 9552
12 in 99999279 2019-07-12 2304 77777 6 13 97296 19519 0 2304
13 in 99999279 2019-09-05 3696 77777 7 13 100992 23215 0 3696
14 in 99999279 2019-09-06 16 77777 8 13 101008 23231 0 16
15 in 99999279 2019-10-22 48 77777 9 13 101056 23279 0 48
16 in 99999279 2019-11-03 14112 77777 10 13 115168 37391 0 14112
17 in 99999279 2019-12-02 2160 77777 11 13 117328 39551 0 2160
18 in 99999279 2019-12-04 720 77777 12 13 118048 40271 0 720
19 in 99999279 2019-12-12 12960 77777 13 13 131008 53231 0 12960
20 in 99999290 2019-12-23 6336 10000 1 2 6336 0 6336 0
21 in 99999290 2019-12-26 50 10000 2 2 6386 -3614 3664 -3614
29 in 99999777 2021-04-08 10011 1 1 10011 0 10011

[注意: 以上 出_入差异_result 这一列即为最终求解哈，为了这一列费老多力了]

最后

** 很多时候我们以为的似乎并不是那么难，只是你很少去思考而已，当然呐，以上只是个人拙见，解决方法肯定还有很多，各位不妨试试看囖~ **

笔记:如何使用postgresql做顺序扣减库存的更多相关文章

  1. redis分布式锁扣减库存弊端: 吞吐量低, 解决方法:使用 分段锁 分布式分段锁并发扣减库存--代码实现

    package tech.codestory.zookeeper.aalvcai.ConcurrentHashMapLock; import lombok.AllArgsConstructor; im ...

  2. EF+MySQL乐观锁控制电商并发下单扣减库存，在高并发下的问题

    下订单减库存的方式 现在,连农村的大姐都会用手机上淘宝购物了,相信电商对大家已经非常熟悉了,如果熟悉电商开发的同学,就知道在买家下单购买商品的时候,是需要扣减库存的,当然有2种扣减库存的方式, 一种是 ...

  3. 使用UpdLock来扣减库存

    UPDLOCK.UPDLOCK 的优点是允许您读取数据(不阻塞其它事务)并在以后更新数据,同时确保自从上次读取数据后数据没有被更改. 当我们用UPDLOCK来读取记录时可以对取到的记录加上更新锁,从而 ...

  4. 利用redis实现分布式事务锁,解决高并发环境下库存扣减

    利用redis实现分布式事务锁,解决高并发环境下库存扣减   问题描述: 某电商平台,首发一款新品手机,每人限购2台,预计会有10W的并发,在该情况下,如果扣减库存,保证不会超卖 解决方案一 利用数据 ...

  5. ENode框架Conference案例分析系列之 - 订单处理减库存的设计

    前言 前面的文章,我介绍了Conference案例的业务.上下文划分.领域模型.架构,以及代码整体流程.接下来想针对案例中一些重要的场景,分别做进一步的分析.本文想先介绍一下Conference案例的 ...

  6. 高并发场景系列(一) 利用redis实现分布式事务锁,解决高并发环境下减库存

    原文:http://blog.csdn.net/heyewu4107/article/details/71009712 高并发场景系列(一) 利用redis实现分布式事务锁,解决高并发环境下减库存 问 ...

  7. 自实现CAS原理JAVA版，模拟下单库存扣减

    在做电商系统时,库存是一个非常严格的数据,根据CAS(check and swap)原来下面对库存扣减提供两种方法,一种是redis,一种用java实现CAS. 第一种 redis实现: 以下这个类是 ...

  8. QML学习笔记（五）— 做一个简单的待做事项列表

    做一个简单的QML待做事项列表,能够动态添加和删除和编辑数据 GitHub:八至 作者:狐狸家的鱼 本文链接:QML学习笔记(五)— 做一个待做事项列表 主要用到QML:ListView 效果 全部代 ...

  9. 修复回写PR时到料日期重复扣减检验周期的问题:

    问题描述: 修复回写PR时到料日期重复扣减检验周期的问题:系统回写的外购半成品PR交货日期未按采购周期回写,从8-10日开始均于10天交期回写,例以下9-5日今天回写的PR,采购周期12天,结果回写到 ...

随机推荐

  1. 关于hashcode和equals方法说明

    一.前言 我们都知道,要比较两个对象是否相等时需要调用对象的equals()方法,即判断对象引用所指向的对象地址是否相等,对象地址相等时,那么与对象相关的对象句柄.对象头.对象实例数据.对象类型数据等 ...

  2. WebAssembly正逐渐成为FaaS的主力

    相信很多人都知道PaaS(平台即服务)和IaaS(基础设施即服务).而随着云计算时代的发展,逐渐出现了大量的XaaS形式的概念,这些技术从原先的硬件服务器,虚拟化服务,再到容器化逐渐转变.使得软件发布 ...

  3. javascript学习（二）--函数

    一.在JavaScript中,定义函数的方式如下: 1.第一种方式: function abs(x) { if (x >= 0) { return x; } else { return -x; ...

  4. 开源低代码平台开发实践二：从 0 构建一个基于 ER 图的低代码后端

    前后端分离了! 第一次知道这个事情的时候,内心是困惑的. 前端都出去搞 SPA,SEO 们同意吗? 后来,SSR 来了. 他说:"SEO 们同意了!" 任何人的反对,都没用了,时代 ...

  5. Android开发在Activity外申请权限调用相机打开相册

    问题描述: 最近在项目中遇到一个需要调用相册和打开相机的需求,但是,在Android 6.0以后,调用相册属于危险权限,需要开发者动态获取,这就意味着我们申请权限是与Activity绑定的,但如果一个 ...

  6. Vue--之调试

    vue.文件的调试 方法:在chrome浏览器中,F12,在Sources中ctrl+F 查找leftMenu.vue, 打断点,F8完成加载

  7. 多个filter如何决定调用顺序

    答案是:web-inf中的web.xml决定

  8. java封装基础详解

    java封装基础详解 java的封装性即是信息隐藏,把对象的属性和行为结合成一个相同的独立单体,并尽可能地隐藏对象的内部细节. 封装的特性是对属性来讲的. 封装的目标就是要实现软件部件的"高 ...

  9. java小程序之随机任务发布器

    需求 自定义任务 随机定时 随机排序 集合输出 搭建 简单项目,所以我使用java 的maven来搭建一个控制台程序,并且使用excel来记录任务 创建任务类(sub) package com.mic ...

  10. Java进阶练习题整理（1）

    1. 检查时异常.非检查时异常.运行时异常. Throwable是一切异常.错误类的超类,Throwable有两个子类,Error(错误)和Exception(异常).Exception异常又分为Ru ...