"购买了 X 的客户也购买了 Y。"

我们在各处都能看到这样的推荐，从亚马逊的商品推荐到 Netflix 的"因为您观看了..."列表。这就是**市场篮子分析**（Market Basket Analysis），也称为关联规则挖掘（Association Rule Mining）。

虽然专业的数据科学家会在 Python 中使用 Apriori 或 FP-Growth 等算法，但你可以使用简单的 SQL 来查找频繁的商品配对，从而获得 90% 的价值。

![市场篮子网络显示频繁一起购买的商品](https://developer.qcloudimg.com/http-save/yehe-7570303/2a85b09bc67b172c354f0befe1345b35.png)

*图：市场篮子网络显示频繁一起购买的商品*

## 核心概念：自连接

要查找一起购买的商品，我们需要查看 `order_items` 表。具体来说，我们想要找到出现在**同一个** `order_id` 中的两个**不同**的商品。

这需要使用**自连接**（Self-Join）：将表与其自身连接。

```sql
SELECT
    a.product_id as product_A,
    b.product_id as product_B,
    COUNT(*) as frequency
FROM order_items a
JOIN order_items b 
    ON a.order_id = b.order_id     -- 同一订单
    AND a.product_id < b.product_id -- 不同商品（避免镜像）
GROUP BY product_A, product_B
ORDER BY frequency DESC;
```

**为什么使用 `a.product_id < b.product_id`？**

如果我们只使用 `!=`，我们会得到两次配对：(面包, 牛奶) 和 (牛奶, 面包)。使用 `<` 强制执行特定顺序，确保我们只计算一次配对。

### 查询解析

这个查询的工作原理：

1. **自连接**：`order_items a` 和 `order_items b` 是同一张表的两个别名
2. **连接条件**：
   - `a.order_id = b.order_id`：确保两个商品在同一订单中
   - `a.product_id < b.product_id`：避免重复计数（只保留 A < B 的配对）
3. **分组聚合**：按商品对分组，计算每对出现的次数
4. **排序**：按频率降序排列，找出最常一起购买的商品对

### 示例数据

假设我们有以下 `order_items` 表：

| order_id | product_id |
|----------|------------|
| 1        | 101        |
| 1        | 102        |
| 1        | 103        |
| 2        | 101        |
| 2        | 102        |
| 3        | 102        |
| 3        | 103        |
| 4        | 101        |
| 4        | 103        |

查询结果示例：

| product_A | product_B | frequency |
|-----------|-----------|-----------|
| 101       | 102       | 2         |
| 101       | 103       | 2         |
| 102       | 103       | 2         |

## 计算置信度

知道"面包和牛奶"一起购买了 500 次是有用的。但这个数字高吗？如果有 1,000,000 个订单，500 次就微不足道。如果只有 600 个订单，那就非常显著了。

我们通常计算**置信度**（Confidence）：*当客户购买产品 A 时，他们购买产品 B 的可能性有多大？*

### 置信度公式

```
Confidence(A → B) = (同时包含 A 和 B 的订单数) / (包含 A 的订单数)
```

### 计算置信度的 SQL 查询

```sql
WITH pair_counts AS (
    SELECT
        a.product_id as product_A,
        b.product_id as product_B,
        COUNT(DISTINCT a.order_id) as pair_count
    FROM order_items a
    JOIN order_items b 
        ON a.order_id = b.order_id
        AND a.product_id < b.product_id
    GROUP BY product_A, product_B
),
product_counts AS (
    SELECT
        product_id,
        COUNT(DISTINCT order_id) as product_count
    FROM order_items
    GROUP BY product_id
)
SELECT
    pc.product_A,
    pc.product_B,
    pc.pair_count,
    p1.product_count as count_A,
    ROUND(100.0 * pc.pair_count / p1.product_count, 2) as confidence_A_to_B,
    ROUND(100.0 * pc.pair_count / p2.product_count, 2) as confidence_B_to_A
FROM pair_counts pc
JOIN product_counts p1 ON pc.product_A = p1.product_id
JOIN product_counts p2 ON pc.product_B = p2.product_id
ORDER BY pc.pair_count DESC;
```

### 置信度示例

假设：
- 面包（product_id = 101）出现在 1000 个订单中
- 牛奶（product_id = 102）出现在 800 个订单中
- 面包和牛奶一起出现在 500 个订单中

计算结果：
- **Confidence(面包 → 牛奶) = 500 / 1000 = 50%**
  - 意义：购买面包的客户有 50% 的可能性也购买牛奶
- **Confidence(牛奶 → 面包) = 500 / 800 = 62.5%**
  - 意义：购买牛奶的客户有 62.5% 的可能性也购买面包

## 交互式演练

让我们在杂货店数据中找到最受欢迎的产品配对。

### 完整查询示例

```sql
-- 查找频繁配对
SELECT 
    p1.product_name as item_1,
    p2.product_name as item_2,
    COUNT(*) as times_bought_together
FROM order_items oi1
JOIN order_items oi2 
    ON oi1.order_id = oi2.order_id
    AND oi1.product_id < oi2.product_id
JOIN products p1 ON oi1.product_id = p1.product_id
JOIN products p2 ON oi2.product_id = p2.product_id
GROUP BY p1.product_name, p2.product_name
ORDER BY times_bought_together DESC
LIMIT 10;
```

### 示例数据

**products 表**：

| product_id | product_name |
|------------|--------------|
| 101        | 面包         |
| 102        | 牛奶         |
| 103        | 鸡蛋         |
| 104        | 黄油         |
| 105        | 咖啡         |

**order_items 表**（部分数据）：

| order_id | product_id |
|----------|------------|
| 1        | 101        |
| 1        | 102        |
| 2        | 101        |
| 2        | 103        |
| 3        | 102        |
| 3        | 103        |
| 4        | 101        |
| 4        | 104        |

### 查询结果示例

| item_1 | item_2 | times_bought_together |
|--------|--------|-----------------------|
| 面包   | 牛奶   | 245                   |
| 牛奶   | 鸡蛋   | 198                   |
| 面包   | 黄油   | 176                   |
| 咖啡   | 牛奶   | 154                   |
| 面包   | 鸡蛋   | 142                   |
| 黄油   | 鸡蛋   | 128                   |
| 咖啡   | 面包   | 115                   |
| 牛奶   | 黄油   | 98                    |
| 咖啡   | 鸡蛋   | 87                    |
| 咖啡   | 黄油   | 76                    |

### 结果解读

从结果可以看出：
1. **面包和牛奶**是最常一起购买的组合（245 次）
2. **牛奶和鸡蛋**是第二常见的组合（198 次）
3. **面包和黄油**也是热门组合（176 次）

这些洞察可以用于：
- 产品陈列优化
- 组合促销设计
- 个性化推荐

## 进一步应用：组合优惠

一旦你识别出这些配对（例如，"啤酒和尿布"），你可以采取行动：

### 1. 产品陈列

将它们放在货架（或网页）上彼此相邻的位置。

**示例**：
- 超市：将面包和牛奶放在相邻的货架上
- 电商：在面包的产品页面上显示牛奶的推荐

### 2. 捆绑销售

创建包含两个商品的"周末勇士套餐"。

**示例**：
- "早餐套餐"：面包 + 牛奶 + 鸡蛋，优惠价 $8.99
- "咖啡时光套餐"：咖啡 + 牛奶 + 面包，优惠价 $6.99

### 3. 个性化推荐

"您将尿布添加到购物车。别忘了啤酒！"

**实现方式**：
```sql
-- 当用户添加产品 A 到购物车时，推荐产品 B
SELECT 
    p2.product_name as recommended_product,
    ROUND(100.0 * COUNT(*) / (
        SELECT COUNT(DISTINCT order_id) 
        FROM order_items 
        WHERE product_id = :product_A
    ), 2) as confidence_percent
FROM order_items oi1
JOIN order_items oi2 
    ON oi1.order_id = oi2.order_id
    AND oi2.product_id != :product_A
JOIN products p2 ON oi2.product_id = p2.product_id
WHERE oi1.product_id = :product_A
GROUP BY p2.product_name
ORDER BY COUNT(*) DESC
LIMIT 5;
```

## 高级指标：支持度和提升度

除了置信度，还有两个重要的指标：

### 支持度（Support）

支持度衡量配对在所有订单中出现的频率。

**公式**：
```
Support(A, B) = (同时包含 A 和 B 的订单数) / (总订单数)
```

**SQL 实现**：
```sql
SELECT
    p1.product_name as item_1,
    p2.product_name as item_2,
    COUNT(*) as pair_count,
    ROUND(100.0 * COUNT(*) / (SELECT COUNT(DISTINCT order_id) FROM order_items), 2) as support_percent
FROM order_items oi1
JOIN order_items oi2 
    ON oi1.order_id = oi2.order_id
    AND oi1.product_id < oi2.product_id
JOIN products p1 ON oi1.product_id = p1.product_id
JOIN products p2 ON oi2.product_id = p2.product_id
GROUP BY p1.product_name, p2.product_name
HAVING COUNT(*) >= 10  -- 最小支持度阈值
ORDER BY support_percent DESC;
```

### 提升度（Lift）

提升度衡量配对的关联强度，考虑了两个商品的独立购买概率。

**公式**：
```
Lift(A, B) = Confidence(A → B) / P(B)
```

其中 P(B) 是商品 B 的购买概率。

**解释**：
- Lift = 1：A 和 B 独立，没有关联
- Lift > 1：A 和 B 正相关，一起购买的可能性高于独立购买
- Lift < 1：A 和 B 负相关，一起购买的可能性低于独立购买

**SQL 实现**：
```sql
WITH pair_stats AS (
    SELECT
        a.product_id as product_A,
        b.product_id as product_B,
        COUNT(DISTINCT a.order_id) as pair_count,
        (SELECT COUNT(DISTINCT order_id) FROM order_items) as total_orders
    FROM order_items a
    JOIN order_items b 
        ON a.order_id = b.order_id
        AND a.product_id < b.product_id
    GROUP BY product_A, product_B
),
product_stats AS (
    SELECT
        product_id,
        COUNT(DISTINCT order_id) as product_count,
        (SELECT COUNT(DISTINCT order_id) FROM order_items) as total_orders
    FROM order_items
    GROUP BY product_id
)
SELECT
    p1.product_name as item_1,
    p2.product_name as item_2,
    ps.pair_count,
    ROUND(100.0 * ps.pair_count / pr1.product_count, 2) as confidence_percent,
    ROUND(
        (1.0 * ps.pair_count / pr1.product_count) / 
        (1.0 * pr2.product_count / pr2.total_orders), 
        2
    ) as lift
FROM pair_stats ps
JOIN product_stats pr1 ON ps.product_A = pr1.product_id
JOIN product_stats pr2 ON ps.product_B = pr2.product_id
JOIN products p1 ON ps.product_A = p1.product_id
JOIN products p2 ON ps.product_B = p2.product_id
WHERE ps.pair_count >= 10
ORDER BY lift DESC;
```

## 实际应用场景

### 1. 电商平台

**场景**：在线零售商想要提高客单价和转化率。

**应用**：
- 在产品页面显示"经常一起购买"的商品
- 在购物车页面推荐相关商品
- 设计捆绑销售套餐

**SQL 查询**：
```sql
-- 为特定产品生成推荐列表
SELECT 
    p2.product_name,
    COUNT(*) as times_bought_together,
    ROUND(100.0 * COUNT(*) / (
        SELECT COUNT(DISTINCT order_id) 
        FROM order_items 
        WHERE product_id = 101  -- 面包
    ), 2) as confidence_percent
FROM order_items oi1
JOIN order_items oi2 ON oi1.order_id = oi2.order_id
JOIN products p2 ON oi2.product_id = p2.product_id
WHERE oi1.product_id = 101  -- 面包
    AND oi2.product_id != 101
GROUP BY p2.product_name
ORDER BY times_bought_together DESC
LIMIT 5;
```

### 2. 超市零售

**场景**：实体超市想要优化货架布局和促销活动。

**应用**：
- 将频繁一起购买的商品放在相邻货架
- 设计"买一送一"或"第二件半价"促销
- 优化购物路径设计

### 3. 订阅服务

**场景**：流媒体平台想要提高用户参与度。

**应用**：
- 推荐相关内容（"看了这个的人也看了..."）
- 创建主题播放列表
- 个性化首页推荐

### 4. 餐饮行业

**场景**：餐厅想要优化菜单和推荐套餐。

**应用**：
- 识别热门菜品组合
- 设计套餐菜单
- 训练服务员推荐搭配

## 跨数据库实现

不同数据库的实现略有差异，主要在于语法细节：

### PostgreSQL

```sql
-- PostgreSQL 支持标准 SQL 语法
SELECT
    p1.product_name as item_1,
    p2.product_name as item_2,
    COUNT(*) as times_bought_together
FROM order_items oi1
JOIN order_items oi2 
    ON oi1.order_id = oi2.order_id
    AND oi1.product_id < oi2.product_id
JOIN products p1 ON oi1.product_id = p1.product_id
JOIN products p2 ON oi2.product_id = p2.product_id
GROUP BY p1.product_name, p2.product_name
ORDER BY times_bought_together DESC
LIMIT 10;
```

### MySQL

```sql
-- MySQL 语法相同
SELECT
    p1.product_name as item_1,
    p2.product_name as item_2,
    COUNT(*) as times_bought_together
FROM order_items oi1
JOIN order_items oi2 
    ON oi1.order_id = oi2.order_id
    AND oi1.product_id < oi2.product_id
JOIN products p1 ON oi1.product_id = p1.product_id
JOIN products p2 ON oi2.product_id = p2.product_id
GROUP BY p1.product_name, p2.product_name
ORDER BY times_bought_together DESC
LIMIT 10;
```

### SQL Server

```sql
-- SQL Server 使用 TOP 而不是 LIMIT
SELECT TOP 10
    p1.product_name as item_1,
    p2.product_name as item_2,
    COUNT(*) as times_bought_together
FROM order_items oi1
JOIN order_items oi2 
    ON oi1.order_id = oi2.order_id
    AND oi1.product_id < oi2.product_id
JOIN products p1 ON oi1.product_id = p1.product_id
JOIN products p2 ON oi2.product_id = p2.product_id
GROUP BY p1.product_name, p2.product_name
ORDER BY times_bought_together DESC;
```

### SQLite

```sql
-- SQLite 支持标准语法
SELECT
    p1.product_name as item_1,
    p2.product_name as item_2,
    COUNT(*) as times_bought_together
FROM order_items oi1
JOIN order_items oi2 
    ON oi1.order_id = oi2.order_id
    AND oi1.product_id < oi2.product_id
JOIN products p1 ON oi1.product_id = p1.product_id
JOIN products p2 ON oi2.product_id = p2.product_id
GROUP BY p1.product_name, p2.product_name
ORDER BY times_bought_together DESC
LIMIT 10;
```

## 性能优化

对于大型数据集，市场篮子分析可能会很慢。以下是一些优化建议：

### 1. 创建索引

```sql
-- 为 order_items 表创建索引
CREATE INDEX idx_order_items_order_id ON order_items(order_id);
CREATE INDEX idx_order_items_product_id ON order_items(product_id);
CREATE INDEX idx_order_items_composite ON order_items(order_id, product_id);
```

### 2. 使用物化视图

```sql
-- 创建物化视图存储频繁配对
CREATE MATERIALIZED VIEW product_pairs AS
SELECT
    p1.product_name as item_1,
    p2.product_name as item_2,
    COUNT(*) as times_bought_together,
    ROUND(100.0 * COUNT(*) / (
        SELECT COUNT(DISTINCT order_id) FROM order_items
    ), 2) as support_percent
FROM order_items oi1
JOIN order_items oi2 
    ON oi1.order_id = oi2.order_id
    AND oi1.product_id < oi2.product_id
JOIN products p1 ON oi1.product_id = p1.product_id
JOIN products p2 ON oi2.product_id = p2.product_id
GROUP BY p1.product_name, p2.product_name
HAVING COUNT(*) >= 10;

-- 定期刷新物化视图
REFRESH MATERIALIZED VIEW product_pairs;
```

### 3. 限制时间范围

```sql
-- 只分析最近 90 天的数据
SELECT
    p1.product_name as item_1,
    p2.product_name as item_2,
    COUNT(*) as times_bought_together
FROM order_items oi1
JOIN order_items oi2 
    ON oi1.order_id = oi2.order_id
    AND oi1.product_id < oi2.product_id
JOIN orders o ON oi1.order_id = o.order_id
JOIN products p1 ON oi1.product_id = p1.product_id
JOIN products p2 ON oi2.product_id = p2.product_id
WHERE o.order_date >= CURRENT_DATE - INTERVAL '90 days'
GROUP BY p1.product_name, p2.product_name
ORDER BY times_bought_together DESC
LIMIT 10;
```

### 4. 设置最小支持度阈值

```sql
-- 只考虑至少一起购买 10 次的配对
SELECT
    p1.product_name as item_1,
    p2.product_name as item_2,
    COUNT(*) as times_bought_together
FROM order_items oi1
JOIN order_items oi2 
    ON oi1.order_id = oi2.order_id
    AND oi1.product_id < oi2.product_id
JOIN products p1 ON oi1.product_id = p1.product_id
JOIN products p2 ON oi2.product_id = p2.product_id
GROUP BY p1.product_name, p2.product_name
HAVING COUNT(*) >= 10  -- 最小支持度阈值
ORDER BY times_bought_together DESC;
```

## 最佳实践

### 1. 设置合理的阈值

不要返回所有配对，设置最小支持度或置信度阈值：

```sql
-- 只返回支持度 >= 1% 且置信度 >= 30% 的配对
HAVING 
    COUNT(*) >= (SELECT COUNT(DISTINCT order_id) FROM order_items) * 0.01
    AND 100.0 * COUNT(*) / (
        SELECT COUNT(DISTINCT order_id) 
        FROM order_items 
        WHERE product_id = oi1.product_id
    ) >= 30
```

### 2. 排除明显的配对

某些配对可能是显而易见的（如"笔记本电脑"和"鼠标"），可以排除：

```sql
-- 排除同一类别的商品
WHERE p1.category_id != p2.category_id
```

### 3. 考虑时间因素

购买模式可能随时间变化，定期更新分析：

```sql
-- 按月分析趋势
SELECT
    DATE_TRUNC('month', o.order_date) as month,
    p1.product_name as item_1,
    p2.product_name as item_2,
    COUNT(*) as times_bought_together
FROM order_items oi1
JOIN order_items oi2 
    ON oi1.order_id = oi2.order_id
    AND oi1.product_id < oi2.product_id
JOIN orders o ON oi1.order_id = o.order_id
JOIN products p1 ON oi1.product_id = p1.product_id
JOIN products p2 ON oi2.product_id = p2.product_id
GROUP BY month, p1.product_name, p2.product_name
ORDER BY month DESC, times_bought_together DESC;
```

### 4. 使用 CTE 提高可读性

对于复杂查询，使用 CTE（公共表表达式）：

```sql
WITH frequent_pairs AS (
    SELECT
        oi1.product_id as product_A,
        oi2.product_id as product_B,
        COUNT(*) as pair_count
    FROM order_items oi1
    JOIN order_items oi2 
        ON oi1.order_id = oi2.order_id
        AND oi1.product_id < oi2.product_id
    GROUP BY product_A, product_B
    HAVING COUNT(*) >= 10
)
SELECT
    p1.product_name as item_1,
    p2.product_name as item_2,
    fp.pair_count
FROM frequent_pairs fp
JOIN products p1 ON fp.product_A = p1.product_id
JOIN products p2 ON fp.product_B = p2.product_id
ORDER BY fp.pair_count DESC;
```

### 5. 创建可重用的视图

将常用查询保存为视图：

```sql
CREATE VIEW v_product_recommendations AS
SELECT
    oi1.product_id as base_product,
    oi2.product_id as recommended_product,
    COUNT(*) as times_bought_together,
    ROUND(100.0 * COUNT(*) / (
        SELECT COUNT(DISTINCT order_id) 
        FROM order_items 
        WHERE product_id = oi1.product_id
    ), 2) as confidence_percent
FROM order_items oi1
JOIN order_items oi2 
    ON oi1.order_id = oi2.order_id
    AND oi2.product_id != oi1.product_id
GROUP BY oi1.product_id, oi2.product_id
HAVING COUNT(*) >= 5;

-- 使用视图
SELECT 
    p1.product_name as base_product,
    p2.product_name as recommended_product,
    vr.confidence_percent
FROM v_product_recommendations vr
JOIN products p1 ON vr.base_product = p1.product_id
JOIN products p2 ON vr.recommended_product = p2.product_id
WHERE vr.base_product = 101  -- 面包
ORDER BY vr.confidence_percent DESC
LIMIT 5;
```

## 结论

你并不总是需要复杂的机器学习模型来构建推荐引擎。一个巧妙的 SQL 自连接通常足以揭示数据中最强的关联关系。

**关键要点**：

1. **自连接是核心**：使用 `product_id < product_id` 避免重复计数
2. **置信度比频率更重要**：考虑商品的独立购买概率
3. **支持度和提升度**：提供更全面的关联强度评估
4. **实际应用**：产品陈列、捆绑销售、个性化推荐
5. **性能优化**：索引、物化视图、时间范围限制、最小阈值

市场篮子分析是一种强大而实用的技术，可以帮助你：
- 提高客单价
- 优化产品布局
- 设计有效的促销活动
- 提升客户体验

从简单的 SQL 查询开始，你就可以获得有价值的业务洞察！

---

## 相关文章推荐

- [Geospatial Analysis: Calculating Distances in SQL](https://www.hisqlboy.com/blog/geospatial-analysis-calculating-distances-sql)
- [SQL for Data Analysis: The Ultimate Guide](https://www.hisqlboy.com/blog/sql-for-data-analysis)
- [SQL Window Frames: ROWS vs RANGE](https://www.hisqlboy.com/blog/sql-window-frames-rows-vs-range)

---

**版权声明**：本文转载自 [SQL Boy](https://www.hisqlboy.com/)，原文链接：https://www.hisqlboy.com/blog/market-basket-analysis-associations-sql

我们在各处都能看到这样的推荐，从亚马逊的商品推荐到 Netflix 的"因为您观看了..."列表。这就是市场篮子分析（Market Basket Analysis），也称为关联规则挖掘（Association Rule Mining）。

SQL 市场篮子分析：客户一起购买什么？

数据库

大数据

算法

学习如何使用SQL进行市场篮子分析，通过自连接查询找出频繁购买的商品组合，计算置信度、支持度和提升度等关键指标，优化产品推荐和促销策略，提升电商转化率和客单价。

机器学习

PostgreSQL

SQLite

Python

MySQL

2026新春采购季

tqdrem

腾讯云数据库特惠，新用户首单0.5折起


postgres

tencentdb-catalog

sqlserver

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云AI代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

功能1上新10个字符

功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符。

功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符。

功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符

功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符

功能4上新

文章&问答评论现已支持表情

全新交互，全新视觉，新增快捷键、悬浮工具栏、高亮块等功能并同时优化现有功能，全面提升创作效率和体验

社区富文本编辑器全新改版！诚邀体验～ 

精选全网热门MCP server，让你的AI更好用 🚀

💥开发者 MCP广场重磅上线！

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

SQL 市场篮子分析：客户一起购买什么？-腾讯云开发者社区-腾讯云

SQL 市场篮子分析：客户一起购买什么？

SQL 市场篮子分析：客户一起购买什么？

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐