sql - 如何在SQL中选择相似的集合-6ren

sql - 如何在SQL中选择相似的集合

转载作者：行者123 更新时间：2023-12-01 18:45:33

我有以下表格:

Order
----
ID (pk)

OrderItem
----
OrderID (fk -> Order.ID)
ItemID (fk -> Item.ID)
Quantity

Item
----
ID (pk)

如何编写一个查询，以选择与特定 Orders至少相似85％的所有 Order？

我考虑过使用 Jaccard Index统计信息来计算两个 Orders的相似度。 (通过将每组 OrderItems的交集除以每组 OrderItems的并集)

但是，如果不为两个 Orders的每个可能组合存储计算出的Jaccard Index，我想不出一种方法。 还有另一种方法吗？

另外，是否有办法将每个匹配的 Quantity的 OrderItem的差异包括在内？

附加信息:

邮政编码总数:〜79k
邮政编码总数:〜1.76m
平均每个 Orders的 OrderItems:21.5
邮政编码总数:〜13k

注意

85％的相似度数字只是对客户实际需求的最佳猜测，将来可能会改变。适用于任何相似性的解决方案将是更可取的。

最佳答案

您指定

How can I write a query that can select all orders that are at least 85% similar to a specific order?

与“所有订单对”相比，这是一个重要的简化
彼此相似度至少为85％”。

我们将使用一些TDQD(测试驱动的查询设计)和一些分析来帮助我们。

初赛

要遥不可及，两个订单中必须至少包含一项
共同。该查询可用于确定哪些订单至少具有
具有指定顺序的一项:

SELECT DISTINCT I1.OrderID AS ID
  FROM OrderItem AS I1
  JOIN OrderItem AS I2 ON I2.ItemID = I1.ItemID AND I2.OrderID = <specified order ID>
 WHERE I1.OrderID != <specified order ID>

尽管这样会大大减少要检查的其他订单的列表
如果指定的订单包含您最受欢迎的商品之一，
可能很多其他订单也这样做了。

除了DISTINCT，您可以使用:

SELECT I1.OrderID AS ID, COUNT(*) AS Num_Common
  FROM OrderItem AS I1
  JOIN OrderItem AS I2 ON I2.ItemID = I1.ItemID AND I2.OrderID = <specified order ID>
 WHERE I1.OrderID != <specified order ID>
 GROUP BY I1.OrderID

这将为您提供共有的订单项数
以指定的顺序。我们还需要每个项目的数量
订购:

SELECT OrderID AS ID, COUNT(*) AS Num_Total
  FROM OrderItem
 GROUP BY OrderID;

相同顺序

对于100％的相似度，这两个订单共有相同的商品
因为每个都有物品。这可能找不到很多对订单，
虽然。我们可以找到与商品完全相同的订单
指定的顺序足够容易:

SELECT L1.ID
  FROM (SELECT OrderID AS ID, COUNT(*) AS Num_Total
          FROM OrderItem
         GROUP BY OrderID
       ) AS L1
  JOIN (SELECT I1.OrderID AS ID, COUNT(*) AS Num_Common
          FROM OrderItem AS I1
          JOIN OrderItem AS I2 ON I2.ItemID = I1.ItemID AND I2.OrderID = <specified order ID>
         WHERE I1.OrderID != <specified order ID>
         GROUP BY I1.OrderID
       ) AS L2 ON L1.ID = L2.ID AND L1.Num_Total = L2.Num_Common;

编辑:结果证明不够严格；为了使订单相同，指定订单中的商品数也必须与共同的商品数相同:

SELECT L1.ID, L1.Num_Total, L2.ID, L2.Num_Common, L3.ID, L3.Num_Total
  FROM (SELECT OrderID AS ID, COUNT(*) AS Num_Total
          FROM OrderItem
         GROUP BY OrderID
       ) AS L1
  JOIN (SELECT I1.OrderID AS ID, COUNT(*) AS Num_Common
          FROM OrderItem AS I1
          JOIN OrderItem AS I2 ON I2.ItemID = I1.ItemID AND I2.OrderID = <specified order ID>
         WHERE I1.OrderID != <specified order ID>
         GROUP BY I1.OrderID
       ) AS L2 ON L1.ID = L2.ID AND L1.Num_Total = L2.Num_Common
  JOIN (SELECT OrderID AS ID, COUNT(*) AS Num_Total
          FROM OrderItem
         WHERE OrderID = <specified order ID>
         GROUP BY OrderID
       ) AS L3 ON L2.Num_Common = L3.Num_Total;

相似的订单—分析公式

应用 Jaccard Similarity
在Wikipedia上定义为两个顺序A和B，其中| A |是伯爵
顺序A中的项目数，Jaccard相似度J(A，B)=
|A∩B| ÷|A∪B|，其中|A∩B|是共有的项目数
这两个命令和|A∪B|是不同项目的总数
订购。

如果项目数在85％，则满足Jaccard相似度标准
任一订单均小于某个阈值，则订单必须相同。
例如，假设订单A和B都有5个商品，但是有一个
两者之间的项目有所不同，它为您提供4个共同的项目(|A∩B|)
和总共6个项目(|A∪B|)，因此Jaccard相似度J(A，B)仅
66⅔％。

如果两个订单中的每一个都有N个商品，则对于85％的相似度，
一项不同，(N-1)÷(N + 1)≥0.85，这意味着N> 12
(准确地说是12⅓)。对于分数F = J(A，B)，一项不同
均值(N-1)÷(N + 1)≥F，对于N给出N≥(1
+ F)÷(1-F)。随着相似性要求的提高，订单
对于越来越大的N值，必须相同。

进一步概括一下，假设我们有不同的大小顺序
包含N和M个项目(不失一般性，N |A∩B|的值现在是N，且|A∪B|的最小值是M(意思是
所有较小顺序的项目都将以较大顺序显示)。让我们
定义M = N + ∆，并且在
较小的顺序，而不是较大的顺序。它遵循
有∆ +∂项以较大的顺序出现，但不在
较小的订单。

根据定义，|A∩B| =N-∂，并且|A∪B| =(N-∂)+∂+
(N + ∆-(N-∂))，其中三个相加项代表(1)
两个订单之间有共同的项目，(2)仅在
(3)仅以较大顺序排列的商品数。
简化为:|A∪B| = N + ∆ +∂。

关键方程式

对于相似分数F，我们对订单对感兴趣，其中
J(A，B)≥F，因此:

(N-∂) ÷ (N+∆+∂) ≥ F

F ≤ (N-∂) ÷ (N+∆+∂)

我们可以使用电子表格来绘制它们之间的关系。为一个
给定数量的较小顺序(x轴)的项目
相似，我们可以画出∂的最大值，使我们有一个
F的相似性。公式为:

∂ = (N(1-F) - F∆) ÷ (1+F)

对于常数F，这是一个在N和∆中的线性方程。它是非线性的
对于不同的F值。显然，∂必须为非负数
整数。

给定F = 0.85，对于相同大小(∆ = 0)的订单，对于1≤N <
13，∂= 0；对于13≤N <25，∂≤1;对于25≤N <37，∂≤2，
对于37≤N <50，∂≤3。

对于相差1(∆ = 1)的阶，对于1≤N <18，∂= 0；为18
≤N <31，∂≤1;对于31≤N <43，∂≤2;等等，如果∆ = 6，
在订单仍然与8 = 1类似的85％之前需要N = 47。那
表示小订单有47个项目，其中46个与
53件的大订单。

相似的订单-应用分析

到现在为止还挺好。我们如何将这一理论应用于选择订单
类似于指定的订单？

首先，我们观察到指定的订单可能与
相似的顺序，或者更大或更小。这使事情变得有些复杂。

上式的参数为:

N –较小顺序的项目数

∆ —较大项数与N

之间的差

F —固定的

∂—较小顺序中的项目数与较大顺序中不匹配

在顶部开发的查询中使用较小的变体即可得到的值:

NC-共同

中的项目数

NA —指定顺序的项目数

NB —比较顺序中的项目数

对应的查询:

SELECT OrderID AS ID, COUNT(*) AS NA
  FROM OrderItem
 WHERE OrderID = <specified order ID>
 GROUP BY OrderID;

SELECT OrderID AS ID, COUNT(*) AS NB
  FROM OrderItem
 WHERE OrderID != <specified order ID>
 GROUP BY OrderID;

SELECT I1.OrderID AS ID, COUNT(*) AS NC
  FROM OrderItem AS I1
  JOIN OrderItem AS I2 ON I2.ItemID = I1.ItemID AND I2.OrderID = <specified order ID>
 WHERE I1.OrderID != <specified order ID>
 GROUP BY I1.OrderID

为了方便起见，我们希望获得N和N + ∆(因此还有∆)值，因此
我们可以使用UNION通过以下方式适当地安排事物:

NS = N —较小顺序的项目数

NL = N + ∆-较大顺序的项目数

在第二版UNION查询中，具有:

NC = N-∂-共同

中的项目数

这两个查询都保留两个订单ID号，以便您可以追溯到
其余的订单信息稍后。

SELECT v1.ID AS OrderID_1, v1.NA AS NS, v2.ID AS OrderID_2, v2.NB AS NL
  FROM (SELECT OrderID AS ID, COUNT(*) AS NA
          FROM OrderItem
         WHERE OrderID = <specified order ID>
         GROUP BY OrderID
       ) AS v1
  JOIN (SELECT OrderID AS ID, COUNT(*) AS NB
          FROM OrderItem
         WHERE OrderID != <specified order ID>
         GROUP BY OrderID
       ) AS v2
    ON v1.NA <= v2.NB
UNION
SELECT v2.ID AS OrderID_1, v2.NB AS NS, v1.ID AS OrderID_2, v1.NA AS NL
  FROM (SELECT OrderID AS ID, COUNT(*) AS NA
          FROM OrderItem
         WHERE OrderID = <specified order ID>
         GROUP BY OrderID
       ) AS v1
  JOIN (SELECT OrderID AS ID, COUNT(*) AS NB
          FROM OrderItem
         WHERE OrderID != <specified order ID>
         GROUP BY OrderID
       ) AS v2
    ON v1.NA > v2.NB

这为我们提供了一个表格表达式，其中包含OrderID_1，NS，OrderID_2，
NL，其中NS是“较小顺序”中的商品数，而NL是
较大顺序的项目数。由于没有重叠
v1和v2表表达式生成的订单号，没有
需要担心OrderID值为
相同。在NC中也最容易处理添加NC的操作:

SELECT v1.ID AS OrderID_1, v1.NA AS NS, v2.ID AS OrderID_2, v2.NB AS NL, v3.NC AS NC
  FROM (SELECT OrderID AS ID, COUNT(*) AS NA
          FROM OrderItem
         WHERE OrderID = <specified order ID>
         GROUP BY OrderID
       ) AS v1
  JOIN (SELECT OrderID AS ID, COUNT(*) AS NB
          FROM OrderItem
         WHERE OrderID != <specified order ID>
         GROUP BY OrderID
       ) AS v2
    ON v1.NA <= v2.NB
  JOIN (SELECT I1.OrderID AS ID, COUNT(*) AS NC
          FROM OrderItem AS I1
          JOIN OrderItem AS I2 ON I2.ItemID = I1.ItemID AND I2.OrderID = <specified order ID>
         WHERE I1.OrderID != <specified order ID>
         GROUP BY I1.OrderID
       ) AS v3
    ON v3.ID = v2.ID
UNION
SELECT v2.ID AS OrderID_1, v2.NB AS NS, v1.ID AS OrderID_2, v1.NA AS NL, v3.NC AS NC
  FROM (SELECT OrderID AS ID, COUNT(*) AS NA
          FROM OrderItem
         WHERE OrderID = <specified order ID>
         GROUP BY OrderID
       ) AS v1
  JOIN (SELECT OrderID AS ID, COUNT(*) AS NB
          FROM OrderItem
         WHERE OrderID != <specified order ID>
         GROUP BY OrderID
       ) AS v2
    ON v1.NA > v2.NB
  JOIN (SELECT I1.OrderID AS ID, COUNT(*) AS NC
          FROM OrderItem AS I1
          JOIN OrderItem AS I2 ON I2.ItemID = I1.ItemID AND I2.OrderID = <specified order ID>
         WHERE I1.OrderID != <specified order ID>
         GROUP BY I1.OrderID
       ) AS v3
    ON v3.ID = v1.ID

这为我们提供了一个表格表达式，其中包含OrderID_1，NS，OrderID_2，
NL，NC，其中NS是“较小顺序”中的商品数，而NL是
较大顺序的项目数，而NC是项目数
共同点。

给定NS，NL，NC，我们正在寻找满足以下条件的订单:

(N-∂) ÷ (N+∆+∂) ≥ F.

N –较小顺序的项目数

∆ —较大项数与N

之间的差

F —固定的

∂—较小顺序中的项目数与较大顺序中不匹配

NS = N —较小顺序的项目数

NL = N + ∆-较大顺序的项目数

NC = N-∂-共同

中的项目数

因此，条件必须是:

NC / (NL + (NS - NC)) ≥ F

LHS上的术语必须被评估为浮点数，而不是
整数表达式。将其应用于上面的UNION查询，将产生:

SELECT OrderID_1, NS, OrderID_2, NL, NC,
        CAST(NC AS NUMERIC) / CAST(NL + NS - NC AS NUMERIC) AS Similarity
  FROM (SELECT v1.ID AS OrderID_1, v1.NA AS NS, v2.ID AS OrderID_2, v2.NB AS NL, v3.NC AS NC
          FROM (SELECT OrderID AS ID, COUNT(*) AS NA
                  FROM OrderItem
                 WHERE OrderID = <specified order ID>
                 GROUP BY OrderID
               ) AS v1
          JOIN (SELECT OrderID AS ID, COUNT(*) AS NB
                  FROM OrderItem
                 WHERE OrderID != <specified order ID>
                 GROUP BY OrderID
               ) AS v2
            ON v1.NA <= v2.NB
          JOIN (SELECT I1.OrderID AS ID, COUNT(*) AS NC
                  FROM OrderItem AS I1
                  JOIN OrderItem AS I2 ON I2.ItemID = I1.ItemID AND I2.OrderID = <specified order ID>
                 WHERE I1.OrderID != <specified order ID>
                 GROUP BY I1.OrderID
               ) AS v3
            ON v3.ID = v2.ID
        UNION
        SELECT v2.ID AS OrderID_1, v2.NB AS NS, v1.ID AS OrderID_2, v1.NA AS NL, v3.NC AS NC
          FROM (SELECT OrderID AS ID, COUNT(*) AS NA
                  FROM OrderItem
                 WHERE OrderID = <specified order ID>
                 GROUP BY OrderID
               ) AS v1
          JOIN (SELECT OrderID AS ID, COUNT(*) AS NB
                  FROM OrderItem
                 WHERE OrderID != <specified order ID>
                 GROUP BY OrderID
               ) AS v2
            ON v1.NA > v2.NB
          JOIN (SELECT I1.OrderID AS ID, COUNT(*) AS NC
                  FROM OrderItem AS I1
                  JOIN OrderItem AS I2 ON I2.ItemID = I1.ItemID AND I2.OrderID = <specified order ID>
                 WHERE I1.OrderID != <specified order ID>
                 GROUP BY I1.OrderID
               ) AS v3
            ON v3.ID = v1.ID
       ) AS u
 WHERE CAST(NC AS NUMERIC) / CAST(NL + NS - NC AS NUMERIC) >= 0.85 -- F

您可能会注意到，该查询仅使用OrderItem表。的
不需要订单和项目表。

警告:部分测试过的SQL(提示符)。上面的SQL现在似乎对微小的数据集产生了合理的答案。我调整了相似度要求(先是0.25，然后是0.55)，然后得出了合理的值和适当的选择性。但是，我的测试数据按最大顺序只有8项，并且肯定没有涵盖所描述数据的全部范围。由于我最常使用的DBMS不支持CTE，因此下面的SQL未经过测试。但是，我有一定的信心，除非我犯了一个大错误，否则版本1中的CTE代码(具有许多重复的指定订单ID)应该是干净的。我认为版本2也可以，但是...未经测试。

可能存在更紧凑的表达查询的方式，可能使用
OLAP功能。

如果要对此进行测试，我将创建一个包含几个表
具有代表性的订单项集，检查相似性度量
返回是明智的。如图所示，我会或多或少地处理查询，
逐步建立复杂的查询。如果表达式之一是
显示有缺陷，然后在该查询中进行适当的调整
直到缺陷得到修复。

显然，性能将是一个问题。最里面的查询不是
可怕的复杂，但它们并非微不足道。但是，测量
将显示这是一个严重的问题还是令人讨厌的问题。正在学习
查询计划可能会有所帮助。似乎很可能应该有
OrderItem.OrderID上的索引；查询不太可能执行良好
如果没有这样的索引。这不太可能成为问题，因为它
是外键列。

使用'WITH子句'( Common Table Expressions)可能会带来一些好处。他们将明确表示在UNION子查询的两半中隐含的重复。

使用公用表表达式

使用通用表表达式可以在以下情况下向优化器说明
表达式是相同的，可能会帮助它更好地执行。他们也
帮助人们阅读您的查询。上面的查询宁愿乞求
使用CTE。

版本1:重复指定的订单号

WITH SO AS (SELECT OrderID AS ID, COUNT(*) AS NA       -- Specified Order (SO)
              FROM OrderItem
             WHERE OrderID = <specified order ID>
             GROUP BY OrderID
           ),
     OO AS (SELECT OrderID AS ID, COUNT(*) AS NB       -- Other orders (OO)
              FROM OrderItem
             WHERE OrderID != <specified order ID>
             GROUP BY OrderID
           ),
     CI AS (SELECT I1.OrderID AS ID, COUNT(*) AS NC    -- Common Items (CI)
              FROM OrderItem AS I1
              JOIN OrderItem AS I2 ON I2.ItemID = I1.ItemID AND I2.OrderID = <specified order ID>
             WHERE I1.OrderID != <specified order ID>
             GROUP BY I1.OrderID
           )
SELECT OrderID_1, NS, OrderID_2, NL, NC,
        CAST(NC AS NUMERIC) / CAST(NL + NS - NC AS NUMERIC) AS Similarity
  FROM (SELECT v1.ID AS OrderID_1, v1.NA AS NS, v2.ID AS OrderID_2, v2.NB AS NL, v3.NC AS NC
          FROM SO AS v1
          JOIN OO AS v2 ON v1.NA <= v2.NB
          JOIN CI AS v3 ON v3.ID  = v2.ID
        UNION
        SELECT v2.ID AS OrderID_1, v2.NB AS NS, v1.ID AS OrderID_2, v1.NA AS NL, v3.NC AS NC
          FROM SO AS v1
          JOIN OO AS v2 ON v1.NA  > v2.NB
          JOIN CI AS v3 ON v3.ID  = v1.ID
       ) AS u
 WHERE CAST(NC AS NUMERIC) / CAST(NL + NS - NC AS NUMERIC) >= 0.85 -- F

版本2:避免重复指定的订单号

WITH SO AS (SELECT OrderID AS ID, COUNT(*) AS NA       -- Specified Order (SO)
              FROM OrderItem
             WHERE OrderID = <specified order ID>
             GROUP BY OrderID
           ),
     OO AS (SELECT OI.OrderID AS ID, COUNT(*) AS NB    -- Other orders (OO)
              FROM OrderItem AS OI
              JOIN SO ON OI.OrderID != SO.ID
             GROUP BY OI.OrderID
           ),
     CI AS (SELECT I1.OrderID AS ID, COUNT(*) AS NC    -- Common Items (CI)
              FROM OrderItem AS I1
              JOIN SO AS S1 ON I1.OrderID != S1.ID
              JOIN OrderItem AS I2 ON I2.ItemID = I1.ItemID
              JOIN SO AS S2 ON I2.OrderID  = S2.ID
             GROUP BY I1.OrderID
           )
SELECT OrderID_1, NS, OrderID_2, NL, NC,
        CAST(NC AS NUMERIC) / CAST(NL + NS - NC AS NUMERIC) AS Similarity
  FROM (SELECT v1.ID AS OrderID_1, v1.NA AS NS, v2.ID AS OrderID_2, v2.NB AS NL, v3.NC AS NC
          FROM SO AS v1
          JOIN OO AS v2 ON v1.NA <= v2.NB
          JOIN CI AS v3 ON v3.ID  = v2.ID
        UNION
        SELECT v2.ID AS OrderID_1, v2.NB AS NS, v1.ID AS OrderID_2, v1.NA AS NL, v3.NC AS NC
          FROM SO AS v1
          JOIN OO AS v2 ON v1.NA  > v2.NB
          JOIN CI AS v3 ON v3.ID  = v1.ID
       ) AS u
 WHERE CAST(NC AS NUMERIC) / CAST(NL + NS - NC AS NUMERIC) >= 0.85 -- F

这些都不容易读；两者都比完整写出CTE的大型SELECT容易。

最少的测试数据

这不足以进行良好的测试。它给出了一点点信心(并且确实显示了“相同顺序”查询的问题。

CREATE TABLE Order (ID SERIAL NOT NULL PRIMARY KEY);
CREATE TABLE Item  (ID SERIAL NOT NULL PRIMARY KEY);
CREATE TABLE OrderItem
(
    OrderID INTEGER NOT NULL REFERENCES Order,
    ItemID INTEGER NOT NULL REFERENCES Item,
    Quantity DECIMAL(8,2) NOT NULL
);

INSERT INTO Order VALUES(1);
INSERT INTO Order VALUES(2);
INSERT INTO Order VALUES(3);
INSERT INTO Order VALUES(4);
INSERT INTO Order VALUES(5);
INSERT INTO Order VALUES(6);
INSERT INTO Order VALUES(7);

INSERT INTO Item VALUES(111);
INSERT INTO Item VALUES(222);
INSERT INTO Item VALUES(333);
INSERT INTO Item VALUES(444);
INSERT INTO Item VALUES(555);
INSERT INTO Item VALUES(666);
INSERT INTO Item VALUES(777);
INSERT INTO Item VALUES(888);
INSERT INTO Item VALUES(999);

INSERT INTO OrderItem VALUES(1, 111, 1);
INSERT INTO OrderItem VALUES(1, 222, 1);
INSERT INTO OrderItem VALUES(1, 333, 1);
INSERT INTO OrderItem VALUES(1, 555, 1);

INSERT INTO OrderItem VALUES(2, 111, 1);
INSERT INTO OrderItem VALUES(2, 222, 1);
INSERT INTO OrderItem VALUES(2, 333, 1);
INSERT INTO OrderItem VALUES(2, 555, 1);

INSERT INTO OrderItem VALUES(3, 111, 1);
INSERT INTO OrderItem VALUES(3, 222, 1);
INSERT INTO OrderItem VALUES(3, 333, 1);
INSERT INTO OrderItem VALUES(3, 444, 1);
INSERT INTO OrderItem VALUES(3, 555, 1);
INSERT INTO OrderItem VALUES(3, 666, 1);

INSERT INTO OrderItem VALUES(4, 111, 1);
INSERT INTO OrderItem VALUES(4, 222, 1);
INSERT INTO OrderItem VALUES(4, 333, 1);
INSERT INTO OrderItem VALUES(4, 444, 1);
INSERT INTO OrderItem VALUES(4, 555, 1);
INSERT INTO OrderItem VALUES(4, 777, 1);

INSERT INTO OrderItem VALUES(5, 111, 1);
INSERT INTO OrderItem VALUES(5, 222, 1);
INSERT INTO OrderItem VALUES(5, 333, 1);
INSERT INTO OrderItem VALUES(5, 444, 1);
INSERT INTO OrderItem VALUES(5, 555, 1);
INSERT INTO OrderItem VALUES(5, 777, 1);
INSERT INTO OrderItem VALUES(5, 999, 1);

INSERT INTO OrderItem VALUES(6, 111, 1);
INSERT INTO OrderItem VALUES(6, 222, 1);
INSERT INTO OrderItem VALUES(6, 333, 1);
INSERT INTO OrderItem VALUES(6, 444, 1);
INSERT INTO OrderItem VALUES(6, 555, 1);
INSERT INTO OrderItem VALUES(6, 777, 1);
INSERT INTO OrderItem VALUES(6, 888, 1);
INSERT INTO OrderItem VALUES(6, 999, 1);

INSERT INTO OrderItem VALUES(7, 111, 1);
INSERT INTO OrderItem VALUES(7, 222, 1);
INSERT INTO OrderItem VALUES(7, 333, 1);
INSERT INTO OrderItem VALUES(7, 444, 1);
INSERT INTO OrderItem VALUES(7, 555, 1);
INSERT INTO OrderItem VALUES(7, 777, 1);
INSERT INTO OrderItem VALUES(7, 888, 1);
INSERT INTO OrderItem VALUES(7, 999, 1);
INSERT INTO OrderItem VALUES(7, 666, 1);

关于sql - 如何在SQL中选择相似的集合，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/13132270/

文章推荐： java - 使用 JAX-RS 和 Liferay (Apache CXF) 实现 PATCH 端点

文章推荐： java - 无法在 Windows 上启动 Neo4j，没有错误消息

文章推荐： java - 为注释字段设置默认空值时出错

行者123

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城

sql - 如何在SQL中选择相似的集合