【AI】零基础：用提示词生成数据库查询语句的步骤

 

零基础：用提示词生成数据库查询语句的步骤

对于零基础的朋友来说，写数据库查询语句（比如 SQL）是个难题 —— 不知道字段名怎么写、条件逻辑怎么表达、语法规则有哪些。但借助 AI 工具（如 ChatGPT、文心一言、通义千问），通过设计合适的提示词，即使不懂 SQL 语法，也能生成正确的数据库查询语句。

本文会从 “基础认知”“5 个核心步骤”“3 大常见场景案例”“提示词优化技巧”“问题排查方法”“工具辅助建议” 6 个部分，详细讲解零基础如何用提示词生成数据库查询语句。每个步骤都有具体操作、示例和注意事项，确保你能一步步跟着做，最终独立生成符合需求的查询语句。

一、基础认知：用提示词生成查询语句前要知道的 3 件事

在开始学步骤前，先搞懂 3 个基础概念，避免后续操作中踩坑。

1.1 什么是 “数据库查询语句”？

数据库查询语句是用来从数据库中 “获取数据” 的指令，最常用的是 SQL（结构化查询语言）。比如 “从‘学生表’中找出‘年龄大于 18 岁’的学生姓名和学号”，对应的 SQL 查询语句可能是：SELECT 姓名, 学号 FROM 学生表 WHERE 年龄 > 18;

零基础不用记住具体语法，只需知道：查询语句的核心是 “告诉数据库，你要从哪个表（或哪些表）里，拿哪些数据，按什么条件拿”。

1.2 AI 生成查询语句的核心逻辑

AI 能生成查询语句，本质是通过提示词理解你的 “数据需求”，再结合数据库的 “表结构”（比如表名、字段名、字段类型），自动套用 SQL 语法规则生成语句。

比如你想 “查 2024 年 8 月的订单金额大于 1000 元的订单号”，提示词里必须包含 2 个关键信息：

• 数据需求：2024 年 8 月、订单金额 > 1000 元、要订单号；

• 表结构：订单表的表名（如 “订单表”）、相关字段名（如 “订单号”“订单金额”“下单时间”）。

AI 拿到这两个信息，就能生成对应的 SQL 语句。

1.3 零基础的 2 个核心优势

作为零基础，不用被复杂的 SQL 语法束缚，生成查询语句时只需关注 “需求描述” 和 “表结构”，有 2 个天然优势：

• 需求描述更直白：不会用专业术语掩盖真实需求，AI 更容易理解（比如不说 “筛选时间维度为 2024 年 8 月的记录”，而说 “找下单时间在 2024 年 8 月 1 日到 8 月 31 日之间的订单”）；

• 依赖提示词框架：只需套用固定的提示词模板，填入自己的需求和表结构，不用自己组织逻辑。

二、5 个核心步骤：零基础用提示词生成数据库查询语句

这是本文的重点，5 个步骤环环相扣，从 “明确需求” 到 “验证语句”，零基础跟着做就能生成正确的查询语句。

2.1 步骤 1：明确查询需求 —— 把 “要什么数据” 说清楚

很多人生成的查询语句不对，根源是没把需求说清楚。这一步要做的就是 “把模糊需求拆成具体、可执行的需求点”。

2.1.1 需求拆解的 3 个维度

不管什么查询需求，都从这 3 个维度拆解，确保不遗漏关键信息：

2.1.1.1 维度 1：要 “哪些字段” 的数据？

明确你最终要看到的 “列数据”，比如 “学生姓名、学号”“订单号、订单金额、下单时间”。不要说 “要学生的基本信息”，而要具体到字段名（如 “学生姓名、学号、年龄、班级”）。

示例：

• 模糊需求：查用户的购买信息；

• 具体字段：用户 ID、用户名、购买的商品 ID、商品名称、购买金额、购买时间。

2.1.1.2 维度 2：从 “哪个 / 哪些表” 查？

明确数据所在的表名，比如 “学生表”“订单表”“商品表”。如果数据来自多个表（比如 “订单表” 和 “商品表”），要一起列出来。

示例：

• 需求：查订单对应的商品名称；

• 涉及表：订单表（存订单号、商品 ID、下单时间）、商品表（存商品 ID、商品名称、单价）。

2.1.1.3 维度 3：按 “什么条件” 查？

明确筛选数据的条件，比如 “年龄> 18 岁”“下单时间在 2024 年 8 月”“金额 > 1000 元”。条件要包含 “字段名 + 比较关系 + 具体值”，不要说 “查最近的订单”，而说 “查下单时间在 2024 年 8 月 1 日到 2024 年 8 月 31 日之间的订单”。

示例：

• 模糊条件：查金额大的订单；

• 具体条件：订单金额 > 1000 元，且下单时间 >= '2024-08-01'。

2.1.2 需求描述的 “正确 vs 错误” 示例

需求类型	错误描述（模糊）	正确描述（具体）
单表查询	查学生信息	从 “学生表” 中查 “姓名、学号、年龄”，条件是 “年龄 > 18 岁”
多表查询	查订单和商品的信息	从 “订单表” 和 “商品表” 中查 “订单号、商品名称、订单金额”，条件是 “订单表。商品 ID = 商品表。商品 ID”（关联条件）
带排序需求	查订单并排好序	从 “订单表” 中查 “订单号、下单时间、订单金额”，条件是 “下单时间在 2024 年 8 月”，按 “订单金额从大到小排序”

2.2 步骤 2：整理表结构 —— 告诉 AI “数据存在哪里”

AI 不知道你的数据库里有哪些表、每个表有哪些字段，这一步要把 “表名、字段名、字段类型、字段含义” 整理清楚，填入提示词。

2.2.1 表结构整理的 4 个关键信息

每个表都要整理以下 4 个信息，用简单的文字或表格呈现：

2.2.1.1 信息 1：表名

明确表的名称，比如 “学生表”“订单表”“商品表”，要和数据库中的实际表名一致（注意大小写，比如数据库中是 “order”，不要写成 “Order”）。

2.2.1.2 信息 2：字段名

列出表中涉及查询需求的字段，比如查询 “学生年龄大于 18 岁的姓名和学号”，就列出 “姓名、学号、年龄” 这 3 个字段，不用列无关字段（如 “家庭地址”）。

2.2.1.3 信息 3：字段类型

说明每个字段的数据类型，比如 “年龄是整数（int）”“下单时间是日期（date）”“订单金额是小数（decimal）”。这影响查询语句的条件写法（比如日期要加引号，数字不用加）。

常见字段类型：

• 整数：int（如年龄、数量）；

• 小数：decimal（如金额、单价）；

• 字符串：varchar（如姓名、商品名称）；

• 日期：date（如下单日期）、datetime（如下单时间，包含时分秒）。

2.2.1.4 信息 4：字段含义（可选）

如果字段名不直观（比如 “uid” 代表 “用户 ID”），要说明字段含义，避免 AI 理解错。如果字段名直观（如 “姓名”“年龄”），可以省略这一步。

2.2.2 表结构整理的示例

以 “查询 2024 年 8 月订单金额大于 1000 元的订单号、商品名称、金额” 为例，涉及 “订单表” 和 “商品表”，表结构整理如下：

2.2.2.1 订单表（表名：order_table）

字段名	字段类型	字段含义
order_id	varchar	订单号
product_id	varchar	商品 ID（关联商品表）
order_amount	decimal	订单金额（元）
order_time	datetime	下单时间（包含时分秒）

2.2.2.2 商品表（表名：product_table）

字段名	字段类型	字段含义
product_id	varchar	商品 ID（关联订单表）
product_name	varchar	商品名称
product_price	decimal	商品单价（元）

2.3 步骤 3：设计提示词 —— 套用模板，填入信息

零基础不用自己写提示词，直接套用下面的 “通用模板”，把步骤 1 拆解的 “需求” 和步骤 2 整理的 “表结构” 填进去即可。

2.3.1 通用提示词模板

帮我生成数据库查询语句（SQL），具体要求如下：

1. 查询需求：

1.1 要获取的字段：【填入步骤1中明确的字段，如“订单号、商品名称、订单金额”】；

1.2 涉及的表：【填入步骤2整理的表名，如“订单表（order_table）、商品表（product_table）”】；

1.3 查询条件：【填入步骤1拆解的条件，如“订单时间在2024-08-01 00:00:00到2024-08-31 23:59:59之间，且订单金额>1000元”】；

1.4 其他要求（可选）：【填入排序、去重、分页等需求，如“按订单金额从大到小排序，只显示前10条数据”】。

2. 表结构信息：

【填入步骤2整理的表结构，用表格或文字描述，确保字段名、字段类型准确】

3. 生成要求：

3.1 生成的SQL语句要符合【填入数据库类型，如MySQL、SQL Server、Oracle】的语法；

3.2 标注语句中关键部分的含义（如关联条件、筛选条件），方便理解；

3.3 如果有多个表，要明确表之间的关联字段和关联方式（如“订单表.order_id = 商品表.order_id”，内连接）；

3.4 避免语法错误（如字段名加反引号、日期加单引号）。

2.3.2 提示词填写示例

以 “查询 2024 年 8 月订单金额大于 1000 元的订单号、商品名称、订单金额，按金额从大到小排序，用 MySQL 语法” 为例，填写后的提示词如下：

帮我生成数据库查询语句（SQL），具体要求如下：

1. 查询需求：

1.1 要获取的字段：订单号（order_id）、商品名称（product_name）、订单金额（order_amount）；

1.2 涉及的表：订单表（表名：order_table）、商品表（表名：product_table）；

1.3 查询条件：订单时间（order_time）在2024-08-01 00:00:00到2024-08-31 23:59:59之间，且订单金额（order_amount）> 1000.00；

1.4 其他要求：按订单金额（order_amount）从大到小排序（降序），只显示前10条数据。

2. 表结构信息：

2.1 订单表（order_table）：

- order_id：varchar（订单号）；

- product_id：varchar（商品ID，关联商品表的product_id）；

- order_amount：decimal（订单金额，单位：元）；

- order_time：datetime（下单时间，包含时分秒）。

2.2 商品表（product_table）：

- product_id：varchar（商品ID，关联订单表的product_id）；

- product_name：varchar（商品名称）；

- product_price：decimal（商品单价，单位：元，本次查询不用）。

3. 生成要求：

3.1 生成的SQL语句要符合MySQL的语法；

3.2 标注语句中关键部分的含义（如关联条件、筛选条件）；

3.3 明确两个表的关联方式（内连接，INNER JOIN）和关联字段（order_table.product_id = product_table.product_id）；

3.4 字段名加反引号（`），日期加单引号（'），避免语法错误。

2.3.3 填写提示词的 3 个注意事项

2.3.3.1 字段名和表名要 “完全一致”

必须和数据库中的实际名称一致，包括大小写（比如数据库中表名是 “Order_Table”，不要写成 “order_table”）、特殊符号（比如 “user_info” 不要写成 “userinfo”）。

2.3.3.2 条件中的 “值” 要符合字段类型

• 字符串类型（如商品名称）：值要加单引号，比如 “product_name = ' 手机 '”；

• 数字类型（如金额、年龄）：值不用加引号，比如 “order_amount> 1000”；

• 日期类型：值要加单引号，且格式要对（MySQL 中是 “'2024-08-01'”，SQL Server 中是 “'2024-08-01'”）。

2.3.3.3 多表查询必须加 “关联条件”

如果查询涉及多个表，一定要在提示词中说明 “关联字段”（如 “订单表的 product_id 关联商品表的 product_id”）和 “关联方式”（如内连接、左连接，零基础默认用内连接 INNER JOIN 即可），否则 AI 会生成 “笛卡尔积” 查询（数据重复且错误）。

2.4 步骤 4：提交提示词，获取查询语句

把步骤 3 设计好的提示词复制到 AI 工具中，提交后等待 AI 生成查询语句。这一步要注意 “查看 AI 的输出是否符合要求”，重点检查 3 个地方。

2.4.1 检查 1：语法是否正确

看生成的 SQL 语句是否有明显的语法错误，比如：

• 字段名、表名是否加了对应的符号（MySQL 加反引号 `，SQL Server 加方括号 []）；

• 日期是否加了单引号；

• 多表查询是否有 ON 关联条件（不是只用 WHERE）。

示例（MySQL 语法正确的语句）：

-- 内连接订单表和商品表，关联条件是商品ID

SELECT

`order_table`.`order_id` AS '订单号', -- 订单号字段，起别名方便阅读

`product_table`.`product_name` AS '商品名称', -- 商品名称字段

`order_table`.`order_amount` AS '订单金额' -- 订单金额字段

FROM

`order_table`

INNER JOIN

`product_table` ON `order_table`.`product_id` = `product_table`.`product_id` -- 关联条件：两个表的商品ID相等

WHERE

`order_table`.`order_time` BETWEEN '2024-08-01 00:00:00' AND '2024-08-31 23:59:59' -- 时间条件：2024年8月

AND `order_table`.`order_amount` > 1000.00 -- 金额条件：大于1000元

ORDER BY

`order_table`.`order_amount` DESC -- 按订单金额降序排序

LIMIT 10; -- 只显示前10条数据

2.4.2 检查 2：是否包含所有需求

看语句是否覆盖了步骤 1 中的所有需求，比如：

• 要获取的字段是否都在 SELECT 后面；

• 查询条件是否都在 WHERE 后面；

• 排序、分页等其他要求是否包含（如 ORDER BY、LIMIT）。

如果遗漏需求（比如没加排序），可以补充提示词：“刚才的查询语句漏了‘按订单金额从大到小排序’的需求，请补充这个条件，重新生成 SQL 语句。”

2.4.3 检查 3：标注是否清晰

看 AI 是否对关键部分做了标注（如关联条件、条件含义），如果标注不清晰，补充提示词：“请在生成的 SQL 语句中，用注释（--）标注每个部分的含义，比如关联条件、筛选条件、排序条件，方便我理解。”

2.5 步骤 5：验证语句 —— 确保能查出正确数据

生成语句后，不要直接在正式数据库中执行，先在测试环境验证，确保能查出正确数据。零基础可以按以下 3 个步骤验证。

2.5.1 步骤 1：在测试库中 “执行语句”

打开数据库工具（如 MySQL 的 Navicat、SQL Server 的 SSMS），连接测试数据库，粘贴生成的 SQL 语句，点击 “执行” 按钮，看是否能正常运行（没有语法错误提示）。

如果出现语法错误（如 “Unknown column 'order_id' in 'field list'”），大概率是字段名或表名写错，回到步骤 2 核对表结构，修正提示词后重新生成语句。

2.5.2 步骤 2：看 “查询结果” 是否符合预期

执行成功后，查看返回的结果数据，比如：

• 结果中的字段是否是你要的（如订单号、商品名称、金额）；

• 数据是否符合条件（如订单时间是否在 2024 年 8 月，金额是否大于 1000 元）；

• 排序是否正确（如金额从大到小）。

如果结果不符合预期（比如查出了 2024 年 7 月的订单），检查 WHERE 条件中的时间范围，补充提示词：“刚才的 SQL 语句中，时间条件查的是 2024 年 7 月，我需要的是 2024 年 8 月，请修正时间范围，重新生成语句。”

2.5.3 步骤 3：优化语句（可选）

如果查询结果正确，但执行速度慢（比如数据量大时查了 10 秒以上），可以让 AI 优化语句，补充提示词：“刚才的 SQL 语句能查出正确数据，但执行速度慢，我的数据库中 order_table 有 100 万条数据，请帮我优化语句（比如加索引提示、优化条件），确保执行时间小于 3 秒。”

AI 会生成优化后的语句，比如添加索引提示：

-- 优化：提示使用order_time和product_id的联合索引，提升查询速度

SELECT

`order_table`.`order_id` AS '订单号',

`product_table`.`product_name` AS '商品名称',

`order_table`.`order_amount` AS '订单金额'

FROM

`order_table` USE INDEX (`idx_order_time_product_id`) -- 提示使用索引

INNER JOIN

`product_table` ON `order_table`.`product_id` = `product_table`.`product_id`

WHERE

`order_table`.`order_time` BETWEEN '2024-08-01 00:00:00' AND '2024-08-31 23:59:59'

AND `order_table`.`order_amount` > 1000.00

ORDER BY

`order_table`.`order_amount` DESC

LIMIT 10;

三、3 大常见场景：零基础用提示词生成查询语句案例

结合实际工作中最常见的 3 个场景（单表查询、多表关联查询、带统计需求查询），给出完整的 “需求→表结构→提示词→生成语句→验证” 流程，零基础可以直接套用。

3.1 场景 1：单表查询 —— 查 “学生表” 中特定条件的学生信息

3.1.1 场景需求

从 “学生表” 中查询 “班级是‘高一（1）班’且年龄大于 16 岁” 的学生，要显示 “姓名、学号、年龄、性别”，按 “年龄从小到大排序”，用 MySQL 语法。

3.1.2 步骤 1：明确查询需求

• 1.1 要获取的字段：姓名（student_name）、学号（student_id）、年龄（student_age）、性别（student_gender）；

• 1.2 涉及的表：学生表（表名：student_table）；

• 1.3 查询条件：班级（student_class）= ' 高一（1）班 '，且年龄（student_age）> 16；

• 1.4 其他要求：按年龄（student_age）从小到大排序（升序）。

3.1.3 步骤 2：整理表结构

学生表（表名：student_table）：

字段名	字段类型	字段含义
student_id	varchar	学号（唯一）
student_name	varchar	姓名
student_age	int	年龄
student_gender	varchar	性别（男 / 女）
student_class	varchar	班级
student_address	varchar	家庭地址（不用）

3.1.4 步骤 3：设计提示词

帮我生成数据库查询语句（SQL），具体要求如下：

1. 查询需求：

1.1 要获取的字段：姓名（student_name）、学号（student_id）、年龄（student_age）、性别（student_gender）；

1.2 涉及的表：学生表（表名：student_table）；

1.3 查询条件：班级（student_class）= '高一（1）班'，且年龄（student_age）> 16；

1.4 其他要求：按年龄（student_age）从小到大排序（升序）。

2. 表结构信息：

学生表（student_table）：

- student_id：varchar（学号，唯一）；

- student_name：varchar（姓名）；

- student_age：int（年龄，整数）；

- student_gender：varchar（性别，值为‘男’或‘女’）；

- student_class：varchar（班级，如‘高一（1）班’）。

3. 生成要求：

3.1 符合MySQL语法；

3.2 用注释标注每个部分的含义；

3.3 字段名加反引号，字符串类型的值加单引号；

3.4 避免语法错误。

3.1.5 步骤 4：提交提示词，获取生成语句

AI 生成的 MySQL 语句：

-- 单表查询：从学生表中查特定班级和年龄的学生信息

SELECT

`student_table`.`student_name` AS '姓名', -- 学生姓名

`student_table`.`student_id` AS '学号', -- 学生学号

`student_table`.`student_age` AS '年龄', -- 学生年龄

`student_table`.`student_gender` AS '性别' -- 学生性别

FROM

`student_table` -- 涉及的表：学生表

WHERE

`student_table`.`student_class` = '高一（1）班' -- 条件1：班级是高一（1）班

AND `student_table`.`student_age` > 16 -- 条件2：年龄大于16岁

ORDER BY

`student_table`.`student_age` ASC; -- 按年龄升序排序（从小到大）

3.1.6 步骤 5：验证语句

• 执行语句：在 Navicat 中连接测试库，执行语句，没有语法错误；

• 查看结果：返回的学生都是 “高一（1）班”，年龄都大于 16 岁，字段包含 “姓名、学号、年龄、性别”，按年龄从小到大排序；

• 结论：语句正确，可使用。

3.2 场景 2：多表关联查询 —— 查 “订单表” 和 “用户表” 的关联数据

3.2.1 场景需求

从 “订单表” 和 “用户表” 中查询 “2024 年 8 月下单的用户信息和订单信息”，要显示 “用户名、用户手机号、订单号、订单金额、下单时间”，条件是 “订单金额 > 500 元”，用 MySQL 语法，按 “下单时间从新到旧排序”。

3.2.2 步骤 1：明确查询需求

• 1.1 要获取的字段：用户名（user_name）、用户手机号（user_phone）、订单号（order_id）、订单金额（order_amount）、下单时间（order_time）；

• 1.2 涉及的表：用户表（表名：user_table）、订单表（表名：order_table）；

• 1.3 查询条件：下单时间（order_time）在 2024-08-01 00:00:00 到 2024-08-31 23:59:59 之间，且订单金额（order_amount）> 500.00；

• 1.4 其他要求：按下单时间（order_time）从新到旧排序（降序），只显示前 20 条数据。

3.2.3 步骤 2：整理表结构

3.2.3.1 用户表（表名：user_table）

字段名	字段类型	字段含义
user_id	varchar	用户 ID（唯一，关联订单表）
user_name	varchar	用户名
user_phone	varchar	用户手机号
user_regtime	datetime	注册时间（不用）

3.2.3.2 订单表（表名：order_table）

字段名	字段类型	字段含义
order_id	varchar	订单号（唯一）
user_id	varchar	用户 ID（关联用户表）
order_amount	decimal	订单金额（元）
order_time	datetime	下单时间
order_status	varchar	订单状态（不用）

3.2.4 步骤 3：设计提示词

帮我生成数据库查询语句（SQL），具体要求如下：

1. 查询需求：

1.1 要获取的字段：用户名（user_name）、用户手机号（user_phone）、订单号（order_id）、订单金额（order_amount）、下单时间（order_time）；

1.2 涉及的表：用户表（表名：user_table）、订单表（表名：order_table）；

1.3 查询条件：下单时间（order_time）在2024-08-01 00:00:00到2024-08-31 23:59:59之间，且订单金额（order_amount）> 500.00；

1.4 其他要求：按下单时间（order_time）从新到旧排序（降序），只显示前20条数据。

2. 表结构信息：

2.1 用户表（user_table）：

- user_id：varchar（用户ID，唯一，关联订单表的user_id）；

- user_name：varchar（用户名）；

- user_phone：varchar（用户手机号）。

2.2 订单表（order_table）：

- order_id：varchar（订单号，唯一）；

- user_id：varchar（用户ID，关联用户表的user_id）；

- order_amount：decimal（订单金额，单位：元，保留2位小数）；

- order_time：datetime（下单时间，包含时分秒）。

3. 生成要求：

3.1 符合MySQL语法；

3.2 用内连接（INNER JOIN）关联两个表，关联字段是user_table.user_id = order_table.user_id；

3.3 用注释标注关联条件、筛选条件、排序条件；

3.4 字段名加反引号，日期和字符串值加单引号；

3.5 避免“笛卡尔积”查询，确保数据正确。

3.2.5 步骤 4：提交提示词，获取生成语句

AI 生成的 MySQL 语句：

-- 多表关联查询：用户表和订单表关联，查2024年8月大额订单

SELECT

`user_table`.`user_name` AS '用户名', -- 用户名（来自用户表）

`user_table`.`user_phone` AS '用户手机号', -- 用户手机号（来自用户表）

`order_table`.`order_id` AS '订单号', -- 订单号（来自订单表）

`order_table`.`order_amount` AS '订单金额（元）', -- 订单金额（来自订单表）

`order_table`.`order_time` AS '下单时间' -- 下单时间（来自订单表）

FROM

`user_table`

INNER JOIN

`order_table` ON `user_table`.`user_id` = `order_table`.`user_id` -- 关联条件：两个表的用户ID相等（内连接，只查有订单的用户）

WHERE

`order_table`.`order_time` BETWEEN '2024-08-01 00:00:00' AND '2024-08-31 23:59:59' -- 筛选条件1：2024年8月的订单

AND `order_table`.`order_amount` > 500.00 -- 筛选条件2：订单金额大于500元

ORDER BY

`order_table`.`order_time` DESC -- 排序条件：按下单时间降序（从新到旧）

LIMIT 20; -- 只显示前20条数据

3.2.6 步骤 5：验证语句

• 执行语句：没有语法错误，成功返回数据；

• 查看结果：每条数据都包含 “用户名、手机号、订单号、金额、时间”，时间都在 2024 年 8 月，金额都大于 500 元，按时间从新到旧排序；

• 结论：语句正确，可使用。

3.3 场景 3：带统计需求查询 —— 统计 “商品表” 中各分类的商品数量和平均价格

3.3.1 场景需求

从 “商品表” 中统计 “每个商品分类” 的 “商品数量” 和 “平均单价”，要显示 “分类名称、商品数量、平均单价”，条件是 “商品状态为‘在售’”，用 MySQL 语法，按 “商品数量从多到少排序”，平均单价保留 2 位小数。

3.3.2 步骤 1：明确查询需求

• 1.1 要获取的字段：分类名称（product_category）、商品数量（统计字段，别名：product_count）、平均单价（统计字段，别名：avg_price）；

• 1.2 涉及的表：商品表（表名：product_table）；

• 1.3 查询条件：商品状态（product_status）= ' 在售 '；

• 1.4 其他要求：按商品数量（product_count）从多到少排序（降序），平均单价（avg_price）保留 2 位小数。

3.3.3 步骤 2：整理表结构

商品表（表名：product_table）：

字段名	字段类型	字段含义
product_id	varchar	商品 ID（唯一）
product_name	varchar	商品名称
product_category	varchar	商品分类（如‘手机’‘电脑’）
product_price	decimal	商品单价（元）
product_status	varchar	商品状态（在售 / 下架）
product_stock	int	库存数量（不用）

3.3.4 步骤 3：设计提示词

帮我生成数据库查询语句（SQL），具体要求如下：

1. 查询需求：

1.1 要获取的字段：分类名称（product_category）、商品数量（用COUNT()统计，别名：product_count）、平均单价（用AVG()统计，别名：avg_price）；

1.2 涉及的表：商品表（表名：product_table）；

1.3 查询条件：商品状态（product_status）= '在售'；

1.4 其他要求：按商品数量（product_count）从多到少排序（降序），平均单价（avg_price）保留2位小数。

2. 表结构信息：

商品表（product_table）：

- product_id：varchar（商品ID，唯一，用于统计数量）；

- product_category：varchar（商品分类，按这个字段分组统计）；

- product_price：decimal（商品单价，用于计算平均价格，单位：元）；

- product_status：varchar（商品状态，值为‘在售’或‘下架’）。

3. 生成要求：

3.1 符合MySQL语法；

3.2 用GROUP BY按商品分类（product_category）分组统计，用HAVING过滤（如果需要）；

3.3 统计函数要加别名，方便阅读（COUNT(product_id) AS product_count，AVG(product_price) AS avg_price）；

3.4 用ROUND()函数将平均单价保留2位小数（ROUND(AVG(product_price), 2)）；

3.5 用注释标注分组条件、统计逻辑、排序条件；

3.6 避免分组错误（如GROUP BY中不包含非统计字段）。

3.3.5 步骤 4：提交提示词，获取生成语句

AI 生成的 MySQL 语句：

-- 带统计需求查询：按商品分类统计在售商品的数量和平均单价

SELECT

`product_table`.`product_category` AS '商品分类', -- 分组字段：商品分类

COUNT(`product_table`.`product_id`) AS '商品数量', -- 统计逻辑：按商品ID计数（避免重复），别名product_count

ROUND(AVG(`product_table`.`product_price`), 2) AS '平均单价（元）' -- 统计逻辑：计算平均单价，保留2位小数，别名avg_price

FROM

`product_table`

WHERE

`product_table`.`product_status` = '在售' -- 筛选条件：只统计在售商品

GROUP BY

`product_table`.`product_category` -- 分组条件：按商品分类分组，每个分类统计一次

ORDER BY

`商品数量` DESC; -- 排序条件：按商品数量降序（从多到少）

3.3.6 步骤 5：验证语句

• 执行语句：没有语法错误，成功返回统计结果；

• 查看结果：按 “手机”“电脑”“平板” 等分类分组，每个分类显示 “商品数量” 和 “平均单价（保留 2 位小数）”，数量从多到少排序，且都是在售商品；

• 结论：语句正确，可使用。

四、4 个提示词优化技巧：让 AI 生成的查询语句更精准

掌握基础步骤后，用以下 4 个技巧优化提示词，能让 AI 生成的查询语句更符合你的实际需求，减少验证和修改的时间。

4.1 技巧 1：加 “字段别名” 要求 —— 让查询结果更易读

默认情况下，AI 生成的语句可能用原字段名（如 “student_name”），查询结果的列名不直观。在提示词中明确 “给每个字段加别名”，能让结果更易读。

4.1.1 优化前提示词（无别名要求）

“查学生表中的 student_name、student_id、student_age，条件是 student_class=' 高一（1）班 '。”

4.1.2 优化后提示词（有别名要求）

“查学生表中的 student_name（别名：姓名）、student_id（别名：学号）、student_age（别名：年龄），条件是 student_class=' 高一（1）班 '，生成的 SQL 语句中每个字段都要加 AS 别名，比如 student_name AS ' 姓名 '。”

4.1.3 优化后生成的语句（更易读）

SELECT

`student_table`.`student_name` AS '姓名',

`student_table`.`student_id` AS '学号',

`student_table`.`student_age` AS '年龄'

FROM

`student_table`

WHERE

`student_table`.`student_class` = '高一（1）班';

4.2 技巧 2：加 “数据去重” 要求 —— 避免结果重复

如果数据库中有重复数据（比如同一学生有多条记录），查询结果会出现重复。在提示词中加 “去重” 要求，让 AI 用 DISTINCT 关键字过滤重复数据。

4.2.1 优化前提示词（无去重要求）

“查商品表中所有的 product_category（商品分类），条件是 product_status=' 在售 '。”

4.2.2 优化后提示词（有去重要求）

“查商品表中所有的 product_category（商品分类，别名：商品分类），条件是 product_status=' 在售 '，生成的 SQL 语句要加 DISTINCT 关键字，去除重复的分类（比如同一分类出现多次，只显示一次）。”

4.2.3 优化后生成的语句（无重复）

SELECT

DISTINCT `product_table`.`product_category` AS '商品分类' -- DISTINCT：去重，同一分类只显示一次

FROM

`product_table`

WHERE

`product_table`.`product_status` = '在售';

4.3 技巧 3：加 “数据库版本” 要求 —— 避免语法不兼容

不同数据库（MySQL、SQL Server、Oracle）的语法有差异（比如分页用 LIMIT 还是 TOP）。在提示词中明确 “数据库版本”，让 AI 生成对应的语法，避免不兼容。

4.3.1 优化前提示词（无数据库版本要求）

“查订单表中前 10 条 order_id，按 order_time 降序排序。”

4.3.2 优化后提示词（有数据库版本要求）

“查订单表中前 10 条 order_id（别名：订单号），按 order_time（下单时间）降序排序，生成的 SQL 语句要符合 SQL Server 2019 的语法（分页用 TOP 10），不要用 MySQL 的 LIMIT。”

4.3.3 优化后生成的语句（符合 SQL Server 语法）

-- SQL Server 2019语法：用TOP 10分页

SELECT TOP 10

`order_table`.`order_id` AS '订单号'

FROM

`order_table`

ORDER BY

`order_table`.`order_time` DESC;

4.4 技巧 4：加 “特殊逻辑” 说明 —— 覆盖个性化需求

如果查询有特殊逻辑（比如 “金额取整数”“时间只取日期部分”），在提示词中明确说明，让 AI 生成包含特殊逻辑的语句。

4.4.1 优化前提示词（无特殊逻辑说明）

“查订单表中 order_amount 和 order_time，条件是 order_time 在 2024 年 8 月。”

4.4.2 优化后提示词（有特殊逻辑说明）

“查订单表中 order_amount（别名：订单金额，特殊逻辑：用 FLOOR () 函数取整数，不保留小数）和 order_time（别名：下单日期，特殊逻辑：只取日期部分，忽略时分秒，用 DATE (order_time) 函数），条件是 order_time 在 2024 年 8 月，生成的 SQL 语句要包含这两个特殊逻辑。”

4.4.3 优化后生成的语句（包含特殊逻辑）

SELECT

FLOOR(`order_table`.`order_amount`) AS '订单金额（整数）', -- 特殊逻辑：FLOOR()取整数

DATE(`order_table`.`order_time`) AS '下单日期', -- 特殊逻辑：DATE()只取日期部分

FROM

`order_table`

WHERE

`order_table`.`order_time` BETWEEN '2024-08-01 00:00:00' AND '2024-08-31 23:59:59';

五、5 个常见问题：零基础用提示词生成查询语句踩坑解决

在实际操作中，零基础可能会遇到 “生成语句报错”“结果不对” 等问题，下面整理 5 个高频问题，给出具体的解决方法。

5.1 问题 1：生成的语句报 “Unknown column ' 字段名 ' in 'field list'”（字段不存在）

5.1.1 原因分析

提示词中的 “字段名” 和数据库中的实际字段名不一致（比如提示词中是 “studentName”，数据库中是 “student_name”），或字段名写错（比如 “student_age” 写成 “student_ages”）。

5.1.2 解决方案

• 步骤 1：回到步骤 2，核对数据库中的实际字段名（用数据库工具查看表结构，如 Navicat 中右键表→“设计表”）；

• 步骤 2：修正提示词中的字段名，确保和数据库完全一致；

• 步骤 3：重新提交提示词，生成新的语句。

示例：

• 原提示词字段名：studentName（错误）；

• 数据库实际字段名：student_name（正确）；

• 修正后提示词：student_name（别名：姓名）。

5.2 问题 2：多表查询报 “Unknown column ' 表名。字段名 ' in 'on clause'”（关联字段错误）

5.2.1 原因分析

提示词中 “表之间的关联字段” 写错（比如提示词中是 “order_table.productId = product_table.productId”，数据库中是 “order_table.product_id = product_table.product_id”），或关联的字段不属于对应的表（比如用 “order_table.user_id” 关联 “product_table.user_id”，但商品表中没有 user_id 字段）。

5.2.2 解决方案

• 步骤 1：核对两个表的实际关联字段（比如订单表的 product_id 关联商品表的 product_id，不是 user_id）；

• 步骤 2：修正提示词中的关联字段和表名，确保 “表名。字段名” 正确；

• 步骤 3：重新生成语句，确保关联条件正确。

示例：

• 原提示词关联条件：order_table.user_id = product_table.user_id（错误，商品表没有 user_id）；

• 修正后关联条件：order_table.product_id = product_table.product_id（正确）；

• 修正后提示词：明确关联方式（内连接）和关联字段（order_table.product_id = product_table.product_id）。

5.3 问题 3：统计查询报 “Column ' 字段名 ' is invalid in the select list because it is not contained in either an aggregate function or the GROUP BY clause”（分组错误）

5.3.1 原因分析

统计查询（用 GROUP BY）时，SELECT 后面的字段不是 “统计函数” 就是 “GROUP BY 中的字段”，提示词中可能包含了 “非统计、非分组” 的字段（比如按 product_category 分组，SELECT 后面却有 product_name 字段）。

5.3.2 解决方案

• 步骤 1：明确统计查询的 “分组字段”（如 product_category）和 “统计字段”（如 COUNT (product_id)、AVG (product_price)）；

• 步骤 2：修正提示词中的 “要获取的字段”，只保留 “分组字段” 和 “统计字段”，删除无关字段；

• 步骤 3：重新生成语句，确保 GROUP BY 中的字段包含 SELECT 中的非统计字段。

示例：

• 原提示词要获取的字段：product_category（分组）、product_name（无关，错误）、COUNT (product_id)（统计）；

• 修正后要获取的字段：product_category（分组）、COUNT (product_id)（统计，别名：商品数量）；

• 修正后提示词：删除 product_name 字段，只保留分组字段和统计字段。

5.4 问题 4：查询结果中 “日期字段显示为 datetime 格式（包含时分秒），但需求只要日期”

5.4.1 原因分析

提示词中没有说明 “日期字段只取日期部分”，AI 默认返回字段的完整格式（datetime 包含时分秒）。

5.4.2 解决方案

• 步骤 1：在提示词的 “其他要求” 中加入 “日期字段只取日期部分，用对应数据库的日期函数”（如 MySQL 用 DATE ()，SQL Server 用 CAST ()）；

• 步骤 2：重新生成语句，确保日期字段用了对应的函数；

• 步骤 3：执行语句，查看日期格式是否符合需求。

示例：

• 原提示词：order_time（别名：下单时间）；

• 修正后提示词：order_time（别名：下单日期，特殊逻辑：用 DATE (order_time) 函数取日期部分，忽略时分秒）；

• 修正后生成的语句：DATE (order_table.order_time) AS ' 下单日期 '。

5.5 问题 5：执行语句后 “没有返回数据，但数据库中确实有符合条件的数据”

5.5.1 原因分析

• 原因 1：查询条件中的 “值” 不符合字段类型（比如日期没加单引号，或格式错误，如 “2024/08/01” 写成 “2024-08-01” 在某些数据库中不兼容）；

• 原因 2：条件逻辑错误（比如用 “AND” 连接了互斥的条件，如 “age > 18 AND age < 16”）；

• 原因 3：多表关联用了 “左连接” 却过滤了右表数据（比如用 LEFT JOIN，却在 WHERE 中加了右表字段的条件，导致左连接变成内连接）。

5.5.2 解决方案

• 针对原因 1：检查条件中的值是否符合字段类型（日期加单引号，格式正确）；

• 针对原因 2：修正条件逻辑（如 “age> 16 AND age < 18”）；

• 针对原因 3：如果用左连接，右表的条件放在 ON 中，不是 WHERE 中；

• 步骤 4：重新生成语句，执行后查看结果。

示例：

• 原条件（原因 1）：order_time BETWEEN 2024-08-01 AND 2024-08-31（日期没加单引号，错误）；

• 修正后条件：order_time BETWEEN '2024-08-01' AND '2024-08-31'（日期加单引号，正确）；

• 执行后：成功返回符合条件的数据。

六、3 个工具辅助：零基础生成查询语句更高效

除了 AI 工具，用以下 3 个工具辅助，能让零基础生成查询语句更高效，减少手动操作和核对的时间。

6.1 工具 1：Navicat（数据库管理工具）—— 核对表结构

6.1.1 核心作用

帮助零基础查看数据库中的 “实际表名、字段名、字段类型”，避免提示词中表结构信息错误，减少语句报错。

6.1.2 操作步骤

6.1.2.1 步骤 1：连接数据库

打开 Navicat，点击 “连接”→选择数据库类型（如 MySQL）→输入 “连接名”“主机名”“端口”“用户名”“密码”→点击 “测试连接”→连接成功后，展开左侧数据库列表。

6.1.2.2 步骤 2：查看表结构

• 找到要查询的表（如 student_table），右键点击→选择 “设计表”；

• 在弹出的窗口中，查看 “字段名”“类型”“长度”“默认值” 等信息，和步骤 2 整理的表结构核对；

• 比如发现数据库中字段名是 “student_age”，提示词中写成了 “student_ages”，立即修正。

6.1.2.3 步骤 3：复制字段名（避免手动输入错误）

• 在 “设计表” 窗口中，选中字段名（如 student_name），右键→“复制”；

• 把复制的字段名粘贴到提示词中，确保和数据库完全一致，避免手动输入错误。

6.1.3 优势

• 可视化查看表结构，零基础也能轻松操作；

• 支持复制字段名、表名，避免手动输入错误；

• 能直接在工具中执行生成的 SQL 语句，方便验证。

6.2 工具 2：豆包（字节跳动）—— 生成提示词模板

6.2.1 核心作用

零基础不会设计提示词时，让豆包生成 “符合需求的提示词模板”，只需填入表结构和需求，不用自己组织逻辑。

6.2.2 操作步骤

6.2.2.1 步骤 1：打开豆包

打开豆包 APP 或网页版（豆包），登录账号。

6.2.2.2 步骤 2：输入 “生成提示词模板的需求”

在输入框中输入 “帮我生成一个‘零基础用提示词生成数据库查询语句’的提示词模板，我的需求是【填入你的场景需求，如‘单表查询学生信息，用 MySQL 语法，要显示姓名、学号、年龄，条件是班级 = 高一（1）班’】，模板要包含‘查询需求’‘表结构信息’‘生成要求’三个部分，方便我填入具体的表名和字段名。”

示例输入：

“帮我生成一个‘零基础用提示词生成数据库查询语句’的提示词模板，我的需求是‘多表关联查询，查订单表和用户表的关联数据，用 MySQL 语法，要显示用户名、订单号、订单金额，条件是 2024 年 8 月的订单，按金额降序排序’，模板要包含‘查询需求’‘表结构信息’‘生成要求’三个部分，方便我填入具体的表名和字段名。”

6.2.2.3 步骤 3：复制模板，填入信息

豆包会生成提示词模板，示例模板：

帮我生成数据库查询语句（SQL），具体要求如下：

1. 查询需求：

1.1 要获取的字段：【填入要显示的字段，如用户名（字段名）、订单号（字段名）、订单金额（字段名），加别名】；

1.2 涉及的表：【填入表名1（如用户表，表名：xxx）、表名2（如订单表，表名：xxx）】；

1.3 查询条件：【填入条件，如订单时间（字段名）在2024-08-01到2024-08-31之间】；

1.4 其他要求：【填入排序、分页等，如按订单金额（字段名）降序排序】。

2. 表结构信息：

2.1 表名1（如用户表）：

- 字段名1：【填入字段名、类型、含义，如用户ID（字段名：xxx，类型：varchar，关联表名2的xxx字段）】；

- 字段名2：【填入字段名、类型、含义，如用户名（字段名：xxx，类型：varchar）】；

2.2 表名2（如订单表）：

- 字段名1：【填入字段名、类型、含义，如订单号（字段名：xxx，类型：varchar）】；

- 字段名2：【填入字段名、类型、含义，如用户ID（字段名：xxx，类型：varchar，关联表名1的xxx字段）】；

- 字段名3：【填入字段名、类型、含义，如订单金额（字段名：xxx，类型：decimal）】；

- 字段名4：【填入字段名、类型、含义，如订单时间（字段名：xxx，类型：datetime）】。

3. 生成要求：

3.1 符合MySQL语法；

3.2 用【填入关联方式，如内连接INNER JOIN】关联两个表，关联条件是【填入表名1.字段名 = 表名2.字段名】；

3.3 用注释标注关联条件、筛选条件、排序条件；

3.4 字段名加【填入符号，如反引号`】，日期和字符串值加单引号；

3.5 避免语法错误和笛卡尔积查询。

你只需把 “【】” 中的内容换成自己的表结构和需求，就能得到完整的提示词。

6.2.3 优势

• 不用自己设计提示词框架，零基础也能快速生成；

• 模板包含所有关键部分（需求、表结构、生成要求），不会遗漏；

• 国内工具，不用外网，访问方便。

6.3 工具 3：SQL Format（在线工具）—— 格式化生成的语句

6.3.1 核心作用

AI 生成的语句可能格式混乱（如字段都在一行），用 SQL Format 在线工具格式化语句，让语句结构清晰，方便阅读和修改。

6.3.2 操作步骤

6.3.2.1 步骤 1：打开在线工具

在浏览器中输入网址（pgFormatter），进入 SQL Format 官网（免费，不用注册）。

6.3.2.2 步骤 2：粘贴生成的 SQL 语句

在左侧 “Input SQL” 文本框中，粘贴 AI 生成的 SQL 语句（如格式混乱的语句）：

SELECT `user_table`.`user_name` AS '用户名',`user_table`.`user_phone` AS '用户手机号',`order_table`.`order_id` AS '订单号',`order_table`.`order_amount` AS '订单金额' FROM `user_table` INNER JOIN `order_table` ON `user_table`.`user_id` = `order_table`.`user_id` WHERE `order_table`.`order_time` BETWEEN '2024-08-01' AND '2024-08-31' ORDER BY `order_table`.`order_amount` DESC;

6.3.2.3 步骤 3：选择格式化参数

• 在右侧 “Formatting Options” 中，选择 “Database”（如 MySQL）；

• 选择 “Indentation”（缩进方式，如 2 个空格）；

• 勾选 “Add comments”（可选，添加注释）；

• 其他参数默认即可。

6.3.2.4 步骤 4：生成格式化语句

点击 “Format SQL” 按钮，右侧 “Formatted SQL” 文本框中会生成格式清晰的语句：

SELECT

`user_table`.`user_name` AS '用户名',

`user_table`.`user_phone` AS '用户手机号',

`order_table`.`order_id` AS '订单号',

`order_table`.`order_amount` AS '订单金额'

FROM

`user_table`

INNER JOIN

`order_table` ON `user_table`.`user_id` = `order_table`.`user_id`

WHERE

`order_table`.`order_time` BETWEEN '2024-08-01' AND '2024-08-31'

ORDER BY

`order_table`.`order_amount` DESC;

6.3.2.5 步骤 5：复制使用

复制右侧格式化后的语句，在数据库工具中执行或修改。

6.3.3 优势

• 免费、不用注册，操作简单；

• 支持多种数据库（MySQL、SQL Server、Oracle）；

• 格式化后的语句结构清晰，方便阅读和排查错误。

  七、复杂查询场景的提示词设计

  掌握基础查询后，实际工作中可能会遇到 “带子查询”“带条件统计”“多表复杂关联” 等复杂场景。下面针对 3 个高频复杂场景，详细讲解提示词设计方法，让零基础也能生成对应的查询语句。

  7.1 场景 1：带子查询的查询 —— 查 “比平均订单金额高的订单信息”

  7.1.1 场景需求

  从 “订单表” 中查询 “订单金额高于所有订单平均金额” 的订单信息，要显示 “订单号、用户 ID、订单金额、下单时间”，用 MySQL 语法，按 “订单金额从大到小排序”，并在提示词中明确子查询的逻辑（先算平均金额，再筛选订单）。

  7.1.2 步骤 1：明确查询需求

• 1.1 要获取的字段：订单号（order_id）、用户 ID（user_id）、订单金额（order_amount）、下单时间（order_time）；
• 1.2 涉及的表：订单表（表名：order_table）；
• 1.3 查询条件：订单金额（order_amount）>（子查询：所有订单的平均金额，用 AVG (order_amount) 计算）；
• 1.4 其他要求：按订单金额（order_amount）降序排序，子查询要单独标注含义。

• 7.1.3 步骤 2：整理表结构

  订单表（表名：order_table）：

  字段名	字段类型	字段含义
  order_id	varchar	订单号（唯一）
  user_id	varchar	用户 ID
  order_amount	decimal	订单金额（元）
  order_time	datetime	下单时间
  order_status	varchar	订单状态（不用）

  7.1.4 步骤 3：设计提示词

  帮我生成带子查询的数据库查询语句（SQL），具体要求如下：

  1. 查询需求：

  1.1 要获取的字段：订单号（order_id，别名：订单号）、用户ID（user_id，别名：用户ID）、订单金额（order_amount，别名：订单金额）、下单时间（order_time，别名：下单时间）；

  1.2 涉及的表：订单表（表名：order_table）；

  1.3 查询条件：订单金额（order_amount）>（子查询：计算order_table表中所有订单的平均金额，用AVG(order_amount)函数，子查询别名：avg_total_amount）；

  1.4 其他要求：按订单金额（order_amount）从大到小排序（降序），子查询部分要单独用注释标注逻辑。

  2. 表结构信息：

  订单表（order_table）：

  - order_id：varchar（订单号，唯一）；

  - user_id：varchar（用户ID，关联用户表，本次查询不用关联）；

  - order_amount：decimal（订单金额，单位：元，保留2位小数）；

  - order_time：datetime（下单时间，包含时分秒）。

  3. 生成要求：

  3.1 符合MySQL语法，子查询要放在括号内，作为条件的一部分；

  3.2 用注释标注子查询的作用（如“-- 子查询：计算所有订单的平均金额”）；

  3.3 字段名加反引号，避免和MySQL关键字冲突；

  3.4 确保子查询能独立运行（即单独执行子查询能得到正确的平均金额）。

  7.1.5 步骤 4：获取并验证生成语句

  AI 生成的 MySQL 语句：

  -- 带子查询的查询：筛选出金额高于平均订单金额的订单

  SELECT

  `order_table`.`order_id` AS '订单号',

  `order_table`.`user_id` AS '用户ID',

  `order_table`.`order_amount` AS '订单金额',

  `order_table`.`order_time` AS '下单时间'

  FROM

  `order_table`

  WHERE

  `order_table`.`order_amount` > (

  -- 子查询：计算所有订单的平均金额，避免因NULL值影响结果，用IFNULL处理

  SELECT IFNULL(AVG(`order_amount`), 0) FROM `order_table`

  ) -- 子查询结果作为筛选条件，只保留金额高于平均值的订单

  ORDER BY

  `order_table`.`order_amount` DESC;

  验证：

• 执行子查询SELECT IFNULL(AVG(order_amount), 0) FROM order_table，得到平均金额（如 800 元）；
• 执行完整语句，返回的订单金额均大于 800 元，字段和排序符合需求，语句正确。

• 7.2 场景 2：带条件统计的查询 —— 统计 “各用户 2024 年 8 月的下单次数和总金额”

  7.2.1 场景需求

  从 “订单表” 中按 “用户 ID” 分组，统计 “2024 年 8 月每个用户的下单次数” 和 “下单总金额”，要显示 “用户 ID、下单次数、总金额”，条件是 “订单状态为‘已完成’”，用 MySQL 语法，按 “总金额降序排序”，统计结果中排除 “下单次数为 0” 的用户。

  7.2.2 步骤 1：明确查询需求

• 1.1 要获取的字段：用户 ID（user_id，别名：用户 ID）、下单次数（COUNT (order_id)，别名：下单次数）、总金额（SUM (order_amount)，别名：总金额）；
• 1.2 涉及的表：订单表（表名：order_table）；
• 1.3 查询条件：订单时间（order_time）在 2024-08-01 00:00:00 到 2024-08-31 23:59:59 之间，且订单状态（order_status）= ' 已完成 '；
• 1.4 其他要求：按用户 ID（user_id）分组，用 HAVING 排除 “下单次数 < 1” 的用户，总金额保留 2 位小数，按总金额降序排序。

• 7.2.3 步骤 2：整理表结构

  订单表（表名：order_table）：

  字段名	字段类型	字段含义
  order_id	varchar	订单号（唯一）
  user_id	varchar	用户 ID（分组字段）
  order_amount	decimal	订单金额（元）
  order_time	datetime	下单时间
  order_status	varchar	订单状态（已完成 / 待付款 / 已取消）

  7.2.4 步骤 3：设计提示词

  帮我生成带条件统计的数据库查询语句（SQL），具体要求如下：

  1. 查询需求：

  1.1 要获取的字段：用户ID（user_id，别名：用户ID）、下单次数（COUNT(`order_id`)，别名：下单次数，统计已完成订单的数量）、总金额（SUM(`order_amount`)，别名：总金额，统计已完成订单的总金额）；

  1.2 涉及的表：订单表（表名：order_table）；

  1.3 查询条件：订单时间（order_time）BETWEEN '2024-08-01 00:00:00' AND '2024-08-31 23:59:59'，且订单状态（order_status）= '已完成'；

  1.4 其他要求：按用户ID（user_id）分组，用HAVING子句筛选“下单次数 >= 1”的用户，总金额用ROUND()保留2位小数，按总金额降序排序。

  2. 表结构信息：

  订单表（order_table）：

  - order_id：varchar（订单号，唯一，用于统计下单次数，避免重复计数）；

  - user_id：varchar（用户ID，分组依据，确保每个用户统计一次）；

  - order_amount：decimal（订单金额，单位：元，用于计算总金额）；

  - order_time：datetime（下单时间，用于筛选8月的订单）；

  - order_status：varchar（订单状态，只统计‘已完成’的订单）。

  3. 生成要求：

  3.1 符合MySQL语法，GROUP BY和HAVING的顺序要正确（先GROUP BY再HAVING）；

  3.2 用注释标注分组逻辑、统计逻辑和HAVING筛选逻辑；

  3.3 统计函数要关联正确的字段（如用COUNT(order_id)统计次数，不用COUNT(*)，避免NULL值影响）；

  3.4 总金额必须保留2位小数，即使是整数也要补0（如1000写成1000.00）。

  7.2.5 步骤 4：获取并验证生成语句

  AI 生成的 MySQL 语句：

  -- 带条件统计的查询：按用户分组统计2024年8月已完成订单的次数和总金额

  SELECT

  `order_table`.`user_id` AS '用户ID',

  COUNT(`order_table`.`order_id`) AS '下单次数', -- 统计逻辑：按订单号计数，避免重复（已完成订单才会被统计）

  ROUND(SUM(`order_table`.`order_amount`), 2) AS '总金额（元）' -- 统计逻辑：求和后保留2位小数

  FROM

  `order_table`

  WHERE

  `order_table`.`order_time` BETWEEN '2024-08-01 00:00:00' AND '2024-08-31 23:59:59' -- 条件1：筛选8月的订单

  AND `order_table`.`order_status` = '已完成' -- 条件2：只统计已完成的订单

  GROUP BY

  `order_table`.`user_id` -- 分组逻辑：按用户ID分组，每个用户生成一条统计记录

  HAVING

  COUNT(`order_table`.`order_id`) >= 1 -- 筛选逻辑：排除下单次数为0的用户（即8月没有已完成订单的用户）

  ORDER BY

  ROUND(SUM(`order_table`.`order_amount`), 2) DESC; -- 排序逻辑：按总金额降序，和统计结果保持一致

  验证：

• 执行语句，返回的每条记录对应一个用户，下单次数均≥1，总金额保留 2 位小数；
• 随机抽查一个用户（如 user_id=1001），手动统计其 8 月已完成订单（3 次，总金额 2500.5 元），语句返回结果一致，正确。

• 7.3 场景 3：多表复杂关联查询 —— 查 “用户、订单、商品的关联数据，含分类统计”

  7.3.1 场景需求

  关联 “用户表”“订单表”“商品表”“商品分类表”，查询 “2024 年 8 月购买过‘手机’分类商品的用户信息、订单信息和商品信息”，要显示 “用户名、手机号、订单号、商品名称、商品分类、订单金额、下单时间”，条件是 “订单状态为‘已完成’”，用 MySQL 语法，按 “下单时间降序排序”，并确保 4 个表的关联逻辑正确。

  7.3.2 步骤 1：明确查询需求

• 1.1 要获取的字段：用户名（user_name）、手机号（user_phone）、订单号（order_id）、商品名称（product_name）、商品分类（category_name）、订单金额（order_amount）、下单时间（order_time）；
• 1.2 涉及的表：用户表（user_table）、订单表（order_table）、商品表（product_table）、商品分类表（category_table）；
• 1.3 查询条件：订单时间（order_time）在 2024-08-01 至 2024-08-31 之间，订单状态（order_status）= ' 已完成 '，商品分类（category_name）= ' 手机 '；
• 1.4 其他要求：4 个表用内连接关联，明确每个表的关联字段，按下单时间（order_time）降序排序，只显示前 30 条数据。

• 7.3.3 步骤 2：整理表结构

  7.3.3.1 用户表（表名：user_table）

  字段名	字段类型	字段含义
  user_id	varchar	用户 ID（关联订单表）
  user_name	varchar	用户名
  user_phone	varchar	手机号

  7.3.3.2 订单表（表名：order_table）

  字段名	字段类型	字段含义
  order_id	varchar	订单号（唯一）
  user_id	varchar	用户 ID（关联用户表）
  product_id	varchar	商品 ID（关联商品表）
  order_amount	decimal	订单金额（元）
  order_time	datetime	下单时间
  order_status	varchar	订单状态

  7.3.3.3 商品表（表名：product_table）

  字段名	字段类型	字段含义
  product_id	varchar	商品 ID（关联订单表、分类表）
  product_name	varchar	商品名称
  category_id	varchar	分类 ID（关联分类表）

  7.3.3.4 商品分类表（表名：category_table）

  字段名	字段类型	字段含义
  category_id	varchar	分类 ID（关联商品表）
  category_name	varchar	商品分类（如‘手机’‘电脑’）

  7.3.4 步骤 3：设计提示词

  帮我生成多表复杂关联的数据库查询语句（SQL），具体要求如下：

  1. 查询需求：

  1.1 要获取的字段：用户名（user_name，别名：用户名）、手机号（user_phone，别名：手机号）、订单号（order_id，别名：订单号）、商品名称（product_name，别名：商品名称）、商品分类（category_name，别名：商品分类）、订单金额（order_amount，别名：订单金额）、下单时间（order_time，别名：下单时间）；

  1.2 涉及的表：用户表（user_table）、订单表（order_table）、商品表（product_table）、商品分类表（category_table）；

  1.3 查询条件：order_table.order_time BETWEEN '2024-08-01 00:00:00' AND '2024-08-31 23:59:59'，order_table.order_status = '已完成'，category_table.category_name = '手机'；

  1.4 其他要求：4个表用内连接（INNER JOIN）关联，按order_time降序排序，LIMIT 30（只显示前30条）。

  2. 表结构信息与关联逻辑：

  2.1 关联顺序与字段：

  - user_table 和 order_table 关联：通过 user_id（user_table.user_id = order_table.user_id），获取用户对应的订单；

  - order_table 和 product_table 关联：通过 product_id（order_table.product_id = product_table.product_id），获取订单对应的商品；

  - product_table 和 category_table 关联：通过 category_id（product_table.category_id = category_table.category_id），获取商品对应的分类；

  2.2 各表关键字段：

  - user_table：user_id（关联）、user_name、user_phone；

  - order_table：order_id、user_id（关联）、product_id（关联）、order_amount、order_time、order_status；

  - product_table：product_id（关联）、product_name、category_id（关联）；

  - category_table：category_id（关联）、category_name（筛选‘手机’分类）。

  3. 生成要求：

  3.1 符合MySQL语法，每个JOIN都要加ON关联条件，避免笛卡尔积；

  3.2 用注释标注每个表的关联逻辑（如“-- 关联用户表和订单表：获取用户的订单信息”）；

  3.3 字段名前加表名前缀（如user_table.user_name），避免字段名重复（如多个表都有id字段）；

  3.4 条件中的字段要加表名前缀，明确归属（如order_table.order_status，不是order_status）；

  3.5 订单金额保留2位小数，下单时间显示完整（包含时分秒）。

  7.3.5 步骤 4：获取并验证生成语句

  AI 生成的 MySQL 语句：

  -- 多表复杂关联查询：用户-订单-商品-分类关联，筛选8月已完成的手机订单

  SELECT

  `user_table`.`user_name` AS '用户名',

  `user_table`.`user_phone` AS '手机号',

  `order_table`.`order_id` AS '订单号',

  `product_table`.`product_name` AS '商品名称',

  `category_table`.`category_name` AS '商品分类',

  ROUND(`order_table`.`order_amount`, 2) AS '订单金额（元）',

  `order_table`.`order_time` AS '下单时间'

  FROM

  `order_table` -- 以订单表为核心，关联其他表

  INNER JOIN

  `user_table` ON `order_table`.`user_id` = `user_table`.`user_id` -- 关联1：订单表→用户表，通过user_id获取用户信息

  INNER JOIN

  `product_table` ON `order_table`.`product_id` = `product_table`.`product_id` -- 关联2：订单表→商品表，通过product_id获取商品信息

  INNER JOIN

  `category_table` ON `product_table`.`category_id` = `category_table`.`category_id` -- 关联3：商品表→分类表，通过category_id获取分类信息

  WHERE

  `order_table`.`order_time` BETWEEN '2024-08-01 00:00:00' AND '2024-08-31 23:59:59' -- 条件1：8月的订单

  AND `order_table`.`order_status` = '已完成' -- 条件2：已完成的订单

  AND `category_table`.`category_name` = '手机' -- 条件3：手机分类的商品

  ORDER BY

  `order_table`.`order_time` DESC

  LIMIT 30; -- 只显示前30条数据

  验证：

• 执行语句，无语法错误，返回数据包含所有要求字段；
• 检查商品分类，均为 “手机”，订单状态均为 “已完成”，时间在 8 月，关联逻辑正确，语句可用。

• 八、提示词生成查询语句的进阶实践

  掌握基础和复杂场景后，通过以下进阶实践，能进一步提升提示词的精准度和效率，让 AI 生成的语句更贴合实际工作需求。

  8.1 实践 1：结合 “业务逻辑” 设计提示词

  实际工作中，查询需求往往和业务逻辑绑定（如 “会员用户的订单优惠计算”“库存不足的商品筛选”），在提示词中加入业务逻辑说明，能让 AI 生成更符合业务场景的语句。

  8.1.1 示例：筛选 “会员用户且订单享受 8 折优惠” 的订单

  提示词片段（加入业务逻辑）：

  “查询需求：筛选‘会员用户且订单享受 8 折优惠’的订单，业务逻辑说明：1. 会员用户：user_table.is_vip = 1；2. 8 折优惠：order_table.discount = 0.8（discount 字段表示折扣率，0.8 即 8 折）；3. 订单金额 = 商品原价 * 折扣率（order_table.order_amount = product_table.product_price * order_table.discount）。”

  生成的语句会自动包含业务逻辑对应的条件，避免遗漏关键筛选项。

  8.2 实践 2：用 “分步提示” 处理超复杂需求

  如果需求包含多个独立逻辑（如 “先统计各分类销量，再筛选销量前 3 的分类，最后查这些分类的商品详情”），可以分多次提交提示词，让 AI 逐步完成，避免一次提示词过于复杂导致错误。

  8.2.1 分步示例：

• 第一步提示词：“统计商品表中各分类的销量（按 category_id 分组，COUNT (product_id) AS sales_count），条件是 product_status = ' 在售 '，按 sales_count 降序排序，生成 SQL 语句。”（得到销量统计语句）；
• 第二步提示词：“基于上一步的统计结果，筛选销量前 3 的分类 ID（如 category_id=101、102、103），生成查询这些分类 ID 的 SQL 语句（SELECT category_id FROM (上一步统计语句) AS temp WHERE sales_count >= 前 3 名的最低销量）。”（得到分类 ID 筛选语句）；
• 第三步提示词：“查询销量前 3 分类的商品详情（product_id、product_name、product_price），条件是 category_id IN（第二步得到的分类 ID），生成 SQL 语句。”（得到最终商品详情语句）。

• 8.3 实践 3：建立 “提示词模板库” 复用逻辑

  针对工作中重复出现的查询场景（如 “月度订单统计”“用户消费排行”），建立提示词模板库，每次只需替换表名、字段名、时间范围等变量，大幅提升效率。

  8.3.1 模板库建立方法：

• 用 Excel 或飞书表格记录模板，列名包括 “场景名称”“提示词模板”“变量说明”“适用数据库”；
• 示例模板（月度订单统计）：

• 场景名称	提示词模板	变量说明	适用数据库
  月度订单统计	“帮我生成月度订单统计 SQL，查询需求：1. 字段：月份（DATE_FORMAT (order_time, '% Y-% m')，别名：月份）、订单数（COUNT (order_id)，别名：订单数）、总金额（SUM (order_amount)，别名：总金额）；2. 表：{{order_table}}；3. 条件：order_time BETWEEN '{{start_date}}' AND '{{end_date}}'；4. 其他：按月份分组，总金额保留 2 位小数。生成要求：符合 {{db_type}} 语法，加注释。”	{{order_table}}：订单表名；{{start_date}}：开始日期（如 2024-08-01）；{{end_date}}：结束日期（如 2024-08-31）；{{db_type}}：数据库类型（如 MySQL）	MySQL/SQL Server

  九、知识拓展与资源推荐

  为了帮助零基础读者进一步提升，这里推荐 3 个实用资源，涵盖 “数据库基础学习”“AI 提示词优化”“SQL 语句验证”，辅助你更深入掌握用提示词生成查询语句的能力。

  9.1 资源 1：数据库基础学习 ——MySQL 零基础教程（菜鸟教程）

  9.1.1 推荐理由

  虽然用提示词能生成语句，但了解基础的 SQL 语法（如 SELECT、FROM、WHERE、GROUP BY 的含义），能更准确地设计提示词、排查语句错误。菜鸟教程的 MySQL 教程用简单语言讲解基础语法，每个知识点配示例，适合零基础入门。

  9.1.2 访问地址

  MySQL 教程 | 菜鸟教程

  9.1.3 重点学习章节

• 第 3 章：MySQL SELECT 语句（了解字段选择逻辑）；
• 第 6 章：MySQL WHERE 子句（掌握条件筛选语法）；
• 第 10 章：MySQL GROUP BY 语句（理解分组统计逻辑）；
• 第 12 章：MySQL JOIN 语句（学习多表关联基础）。

• 9.2 资源 2：AI 提示词优化 —— 豆包提示词工程指南

  9.2.1 推荐理由

  该指南专门讲解如何设计精准的 AI 提示词，包含 “需求拆解”“逻辑描述”“格式要求” 等章节，其中 “技术类提示词设计” 部分对数据库查询语句的提示词优化有直接帮助，国内访问方便，免费查看。

  9.2.2 访问地址

  打开豆包 APP，搜索 “提示词工程指南” 即可查看（或网页版：豆包）

  9.2.3 重点学习部分

• 第 4 章：技术领域提示词设计（含数据库、代码类提示词案例）；
• 第 6 章：提示词优化技巧（如何让 AI 更准确理解需求）。

• 9.3 资源 3：SQL 语句验证与优化 ——SQL Fiddle（在线工具）

  9.3.1 推荐理由

  生成 SQL 语句后，若没有本地数据库环境，可用 SQL Fiddle 在线验证语句语法是否正确、执行结果是否符合预期。支持 MySQL、SQL Server、PostgreSQL 等多种数据库，可手动创建表结构、插入测试数据，再执行生成的语句。

  9.3.2 访问地址

  SQL Fiddle - Online SQL Compiler for learning & practice

  9.3.3 使用步骤

• 选择数据库类型（如 MySQL 8.0）；
• 在左侧 “Schema SQL” 中创建表结构（如CREATE TABLE order_table (order_id varchar(20), user_id varchar(20), order_amount decimal(10,2), order_time datetime);），插入测试数据（如INSERT INTO order_table VALUES ('O001', 'U001', 1200.50, '2024-08-10 14:30:00');）；
• 在右侧 “Query SQL” 中粘贴 AI 生成的语句，点击 “Run SQL”，查看执行结果和是否有语法错误。