Question

我有两张桌子，我需要完成表格Need_qty，而表格1 sending_qty的移动最少。

表1

sending_QTY STORE_ID_A
30           30105
16           21168
10           21032
9            30118
6            30011
5            21190
2            21016

表2

Need_QTY    STORE_ID_B
15           21005
10           30019
11           21006
16           30001
11           21015
7            21004

预期输出

STORE_ID_A |STORE_ID_B |TRANSFERRED_QTY_FROM_A |
-----------|-----------|-----------------------|
30105      |21005      |15                     |
30105      |30019      |10                     |
30105      |21006      |5                      |
21168      |21006      |6                      |
21168      |30001      |10                     |
21032      |30001      |6                      |
21032      |21015      |4                      |
30118      |21015      |7                      |
30118      |21004      |2                      |
30011      |21004      |5                      |

还有其他几种组合来实现这一目标，但我需要找到最小可能的转移，以便表2 need_qty得到满足有没有办法在没有程序方法的情况下实现这个目标？

到目前为止，我已尝试交叉加入以找到这些组合，但没有多少帮助

Answer 1

这可以通过使用包含整数分区的辅助表使用常规SQL来解决。为了这个例子，让我们假设这个辅助表有三列：分区，等级和数字。对于任何给定的数字，将存在可能的分区行，每个分区具有其等级。如果数字为5，则从该表中选择编号为5的所有行将显示：

partitions          rank        number
5                   1           5
4, 1                2           5
3, 2                2           5
3, 1, 1             3           5
2, 2, 1             3           5
2, 1, 1, 1          4           5
1, 1, 1, 1, 1       5           5

排名是行中使用的分区数，对您提供的问题很重要，因为它允许我们选择最小的传输。

对于数字5，我们有7行代表分区。对于更高的数字，返回的行将更高 - 数字12将有77个分区！ - 但是在我们使用数据库的规模中，这个分区辅助表很容易在数字1到99中查询，例如提供的示例。更高的数字是可扩展性的问题。

如果你想要创建这样一个表格的说明，我很乐意为你提供 - 但由于这是一个很长的解决方案，让我们暂时设置一下辅助表的生成。

让我们看看商店ID A，它有要发送的数量。他们的数量是：

对于每个商店数量，我们可以查询分区辅助表，并获取此数量及其排名的各种分区。然后我们可以创建自己的分区组合。例如，30将带来许多行，其中一行将是：

partitions         rank         number
15,10,5            3            30

和10将带来许多其他：

partitions         rank         number
6,4                2            10

您可以通过结果之间的交叉连接构建所有可能候选者的笛卡尔积，并且对于此产品的每一行，分区按升序排序，等级为分区等级的总和。

另一方面，您有商店ID B需要数量。你只需要做同样的处理，最后得到另一个相当大的笛卡尔积分排序分区产品。恭喜到目前为止。

现在，您只需要查看Store ID B分区集合完全包含在Store ID A分区集合中的分区行。这将使大型集合显着减少到几行潜在的转移。商店ID B中的一行（给出上面的示例）将是：

partitions                     rank
15,10,10,7,6,6,5,5,4,2         10

由于它出现在商店ID A和商店ID B.商店ID A中，它将是以下组合：

30 = 15,10,5     rank 3
16 = 10,6        rank 2
10 = 6,4         rank 2
9  = 7,2         rank 2
6  = 5,1         rank 2
5  = 5           rank 1
2  = 2           rank 1

给你一行：

partitions                     rank
15,10,10,7,6,6,5,5,5,4,2,2,1   13

最后一步是在商店ID B上选择排名最低的行。这将是最小的传输次数，您可以像上面那样输出它。

获得此奖励的奖励：如果您想查看我们是否可以完全耗尽商店ID A的整个库存（而不是满足商店ID B），请反转包含关系：确保分区集合A完全包含在分区集合中B.要查看将每个项目从A完全移动到B以满足B并耗尽A的最小转移，请在两个集合中查找相同的分区。

一些实际的SQL来模拟算法，至少部分是：

-- this function handles the sorting. It's not necessary but it help make the result look better.
WITH
FUNCTION SORT_PARTITIONS(p_id IN VARCHAR2) RETURN VARCHAR2 IS
result VARCHAR2(100);
BEGIN   
  select rtrim(XMLAGG(XMLELEMENT(E,str||',')).EXTRACT('//text()'),',') into result  
from (
with temp as  (
   select p_id num from dual       
 )
SELECT   trim(regexp_substr(str, '[^,]+', 1, level)) str
FROM (SELECT num str FROM temp) t
CONNECT BY instr(str, ',', 1, level - 1) > 0
order by to_number(str)
);
return result;
END;
-- this function handles containment - when we want to fulfil store ID B, and not necessarily deplete store ID A, or visa-versa.
FUNCTION PARTITION_CONTAINED(seta_partition IN VARCHAR2, setb_partition IN VARCHAR2) RETURN NUMBER IS
result NUMBER;
BEGIN
 with seta as 
(select str, count(str) cnt from (
SELECT trim(regexp_substr(str, '[^,]+', 1, level)) str
FROM (SELECT num str FROM (select SETA_PARTITION num from dual)) t
CONNECT BY instr(str, ',', 1, level - 1) > 0)
group by str),
setb as 
(select str, count(str) cnt from (
SELECT trim(regexp_substr(str, '[^,]+', 1, level)) str
FROM (SELECT num str FROM (select SETB_PARTITION num from dual)) t
CONNECT BY instr(str, ',', 1, level - 1) > 0)
group by str),
lenab as (select count(1) strab from seta, setb where seta.str=setb.str and seta.cnt>=setb.cnt),
lenb as (select count(1) strb from setb)
select strb-strab into result from lenb,lenab;
RETURN result;
END;
-- this store_a simply represents a small Cartesian product of two stores from the stores ID A table - one with quantity 5, the other with quantity 4. I found this was easier to set up. 
store_a as (select SORT_PARTITIONS(n1||','||n2) partitions_sending, rank1+rank2 rank_sending from (select num_partitions n1, rank rank1 from n_partitions where num=5),(select num_partitions n2, rank rank2 from n_partitions where num=4)),

-- this store_b represents the stores ID B's Cartesian product of partitions, again for simplicity. The receiving quantities are 3, 3 and 3.
store_b as (select SORT_PARTITIONS(n1||','||n2||','||n3) partitions_receive, rank1+rank2+rank3 rank_receive from (select num_partitions n1, rank rank1 from n_partitions where num=3),(select num_partitions n2, rank rank2 from n_partitions where num=3),(select num_partitions n3, rank rank3 from n_partitions where num=3))

-- and finally, the filtering that provides all possible transfers - with both "=" (which works for deplete and fulfil) and "partition_contained" which allows for fulfil or deplete. You can choose to leave both or just use partition contained, as it is more flexible.
SELECT * from store_a, store_b where store_a.partitions_sending=store_b.partitions_receive or partition_contained(store_a.partitions_sending,store_b.partitions_receive)=0 order by store_b.rank_receive, store_a.rank_sending asc;

最小传输Sql查询

1 个答案: