PostgreSQL GREATEST 条件表达式函数详解

一句话介绍

GREATEST 就像是一个"选最大值"的小助手，给它一堆值，它就告诉你哪个最大！

SELECT GREATEST(3, 7, 2, 9, 5);  -- 返回 9（最大的那个）

是不是很简单？但它的用处可不止这么简单哦！

基本语法

GREATEST(value1, value2, value3, ...)

通俗解释

• 输入：任意多个值（至少 2 个）
• 输出：这些值里面最大的那个
• 要求：所有值的类型要一样或兼容（比如都是数字，或者都是文本）

简单例子

-- 找最大数字
SELECT GREATEST(10, 20, 30);     -- 返回 30

-- 找最大文本（按字母顺序）
SELECT GREATEST('apple', 'banana', 'cherry');  -- 返回 'cherry'

-- 找最大日期
SELECT GREATEST('2024-01-01', '2024-06-15', '2024-03-20');  -- 返回 '2024-06-15'

核心特点（必看！）

特点 1：NULL 值是"捣蛋鬼"

重要规则：只要有一个值是 NULL，结果就是 NULL！

SELECT GREATEST(10, 20, NULL);  -- 返回 NULL（因为有个 NULL）
SELECT GREATEST(NULL, NULL);    -- 返回 NULL

怎么办？ 用 COALESCE 把 NULL 变成默认值：

-- 把 NULL 当成 0 来处理
SELECT GREATEST(COALESCE(score1, 0), COALESCE(score2, 0));

特点 2：类型必须一致

-- ✅ 正确：都是数字
SELECT GREATEST(10, 20.5, 30);  -- 返回 30

-- ✅ 正确：都是文本
SELECT GREATEST('A', 'B', 'C');  -- 返回 'C'

-- ❌ 错误：数字和文本混在一起
SELECT GREATEST(10, 'hello');   -- 报错！

特点 3：文本比较是按字母顺序

-- 字母越靠后，值越大
SELECT GREATEST('apple', 'banana');  -- 返回 'banana'（b 在 a 后面）

-- 大写字母在小写前面
SELECT GREATEST('A', 'a');  -- 返回 'a'（小写字母 ASCII 码更大）

-- 中文按 Unicode 编码比较
SELECT GREATEST('北京', '上海');  -- 取决于编码顺序

特点 4：可以有很多参数

-- 不只两个，可以有任意多个
SELECT GREATEST(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);  -- 返回 10

常见使用场景（超实用！）

场景 1：找最高分

假设你有个学生成绩表：

-- 表结构
CREATE TABLE student_scores (
    student_name VARCHAR(50),
    math_score INT,
    english_score INT,
    science_score INT
);

-- 插入数据
INSERT INTO student_scores VALUES 
    ('小明', 85, 92, 78),
    ('小红', 90, 88, 95),
    ('小刚', 76, 82, 80);

-- 找出每个学生的最高分科目分数
SELECT 
    student_name,
    math_score,
    english_score,
    science_score,
    GREATEST(math_score, english_score, science_score) AS highest_score
FROM student_scores;

结果：

student_name | math_score | english_score | science_score | highest_score
-------------|------------|---------------|---------------|--------------
小明         | 85         | 92            | 78            | 92
小红         | 90         | 88            | 95            | 95
小刚         | 76         | 82            | 80            | 82

场景 2：确保最低价格

电商场景中，保证显示的价格不低于某个最低价：

SELECT 
    product_name,
    original_price,
    sale_price,
    GREATEST(sale_price, 9.99) AS final_price  -- 最低价 9.99
FROM products;

效果：即使促销价是 5 元，最终价格也会显示 9.99 元（保护利润）。

场景 3：计算奖金（保底机制）

SELECT 
    employee_name,
    performance_bonus,
    GREATEST(performance_bonus, 1000) AS actual_bonus  -- 最少发 1000
FROM employees;

效果：绩效奖金再低也不会少于 1000 元。

场景 4：找最近的日期

SELECT 
    order_id,
    order_date,
    payment_date,
    shipping_date,
    GREATEST(order_date, payment_date, shipping_date) AS latest_date
FROM orders;

用途：找出订单流程中最新的操作时间。

场景 5：数据验证和修正

-- 确保年龄不为负数
SELECT 
    name,
    GREATEST(age, 0) AS valid_age  -- 如果是负数，变成 0
FROM users;

-- 确保库存不为负数
SELECT 
    product_name,
    GREATEST(stock_quantity, 0) AS available_stock
FROM inventory;

场景 6：多来源数据取最优

-- 从三个不同的评分系统中取最高分
SELECT 
    movie_title,
    imdb_rating,
    douban_rating,
    rotten_tomatoes_rating,
    GREATEST(imdb_rating, douban_rating, rotten_tomatoes_rating) AS best_rating
FROM movies;

场景 7：阶梯定价计算

-- 根据不同条件计算最终价格，确保不低于成本价
SELECT 
    product_id,
    cost_price,
    member_price,
    vip_price,
    GREATEST(
        LEAST(member_price, vip_price),  -- 先取会员价和VIP价的较小值
        cost_price                        -- 再和成本价比较，取较大值
    ) AS final_price
FROM products;

解释：给顾客最优惠的价格，但不能低于成本价！

高级用法

1. 与 CASE 结合使用

-- 根据用户等级应用不同的最低消费
SELECT 
    user_name,
    total_spent,
    CASE user_level
        WHEN 'VIP' THEN GREATEST(total_spent * 0.8, 100)   -- VIP 最低 100
        WHEN 'Gold' THEN GREATEST(total_spent * 0.9, 200)  -- 金卡最低 200
        ELSE total_spent                                    -- 普通用户无优惠
    END AS final_amount
FROM users;

2. 与 COALESCE 配合处理 NULL

-- 安全地找最大值，NULL 当作 0 处理
SELECT 
    student_name,
    GREATEST(
        COALESCE(math_score, 0),
        COALESCE(english_score, 0),
        COALESCE(science_score, 0)
    ) AS highest_score
FROM student_scores;

3. 在 UPDATE 中使用

-- 更新最低工资标准
UPDATE employees
SET salary = GREATEST(salary, 5000)  -- 工资低于 5000 的涨到 5000
WHERE department = 'IT';

4. 在 ORDER BY 中使用

-- 按最高分排序
SELECT * FROM students
ORDER BY GREATEST(math_score, english_score, science_score) DESC;

5. 与聚合函数结合

-- 每个班级的最高单科成绩
SELECT 
    class_id,
    MAX(GREATEST(math_avg, english_avg, science_avg)) AS class_best_score
FROM class_statistics
GROUP BY class_id;

GREATEST vs LEAST（好兄弟对比）

PostgreSQL 有两个相反的函数：

函数	作用	例子	结果
GREATEST	找最大值	GREATEST(3, 7, 2)	7
LEAST	找最小值	LEAST(3, 7, 2)	2

实际对比

-- 同时使用两个函数
SELECT 
    price,
    GREATEST(price, 10) AS min_price,   -- 确保不低于 10
    LEAST(price, 100) AS max_price,     -- 确保不高于 100
    GREATEST(LEAST(price, 100), 10) AS bounded_price  -- 限制在 10-100 之间
FROM products;

效果：把价格限制在 10 到 100 元之间！

实际应用示例（完整案例）

案例 1：电商平台价格策略

-- 场景：计算最终售价
-- 规则：
-- 1. 会员享受折扣价
-- 2. 但不能低于成本价
-- 3. 也不能高于建议零售价

SELECT 
    product_name,
    cost_price,              -- 成本价
    retail_price,            -- 建议零售价
    member_discount_price,   -- 会员折扣价
    
    -- 最终价格：在成本价和零售价之间，优先用会员价
    GREATEST(
        LEAST(member_discount_price, retail_price),  -- 不超过零售价
        cost_price                                     -- 不低于成本价
    ) AS final_price
    
FROM products;

案例 2：员工薪资调整系统

-- 场景：年度调薪
-- 规则：
-- 1. 绩效优秀的涨 20%
-- 2. 绩效良好的涨 10%
-- 3. 但至少涨 500 元
-- 4. 最高不超过 30000 元

SELECT 
    employee_name,
    current_salary,
    performance_level,
    
    -- 计算新工资
    GREATEST(
        LEAST(
            current_salary * CASE 
                WHEN performance_level = '优秀' THEN 1.2
                WHEN performance_level = '良好' THEN 1.1
                ELSE 1.05
            END,
            30000  -- 上限
        ),
        current_salary + 500  -- 下限（至少涨500）
    ) AS new_salary
    
FROM employees;

案例 3：游戏积分系统

-- 场景：计算玩家最终积分
-- 规则：
-- 1. 基础积分 +  bonus 积分
-- 2. 每日最多获得 1000 分
-- 3. 积分不能为负数

SELECT 
    player_id,
    base_points,
    bonus_points,
    
    -- 最终积分
    GREATEST(
        LEAST(base_points + bonus_points, 1000),  -- 最多 1000
        0                                           -- 最少 0
    ) AS final_points
    
FROM player_scores;

案例 4：酒店预订系统

-- 场景：计算房间价格
-- 规则：
-- 1. 旺季价格上浮 50%
-- 2. 淡季价格下浮 20%
-- 3. 但有最低价和最高价限制

SELECT 
    room_type,
    base_price,
    is_peak_season,
    
    -- 最终价格
    GREATEST(
        LEAST(
            base_price * CASE 
                WHEN is_peak_season THEN 1.5
                ELSE 0.8
            END,
            2000  -- 最高价
        ),
        200  -- 最低价
    ) AS final_price
    
FROM rooms;

性能小贴士

✅ 好的做法

-- GREATEST 很快，放心用
SELECT GREATEST(col1, col2, col3) FROM table;

-- 参数少的时候特别快
SELECT GREATEST(price, min_price) FROM products;

⚠️ 注意事项

-- 太多参数可能影响可读性（虽然性能没问题）
-- ❌ 不推荐：参数太多，难以阅读
SELECT GREATEST(a, b, c, d, e, f, g, h, i, j) FROM table;

-- ✅ 推荐：分成多次或使用其他方法
SELECT GREATEST(
    GREATEST(a, b, c),
    GREATEST(d, e, f),
    GREATEST(g, h, i, j)
) FROM table;

常见错误和解决方案

错误 1：NULL 导致结果为 NULL

-- ❌ 问题
SELECT GREATEST(10, 20, NULL);  -- 返回 NULL

-- ✅ 解决
SELECT GREATEST(10, 20, COALESCE(NULL, 0));  -- 返回 20

错误 2：类型不匹配

-- ❌ 问题
SELECT GREATEST(10, '20');  -- 报错！

-- ✅ 解决
SELECT GREATEST(10, 20::INT);  -- 返回 20
SELECT GREATEST(10::TEXT, '20');  -- 返回 '20'

错误 3：忘记至少需要两个参数

-- ❌ 问题
SELECT GREATEST(10);  -- 报错！

-- ✅ 解决
SELECT GREATEST(10, 0);  -- 返回 10

错误 4：文本比较不符合预期

-- ❌ 以为会返回 '100'（数值最大）
SELECT GREATEST('9', '100');  -- 返回 '9'（因为 '9' > '1'）

-- ✅ 如果要按数值比较，先转换类型
SELECT GREATEST('9'::INT, '100'::INT);  -- 返回 100

最佳实践总结

🎯 什么时候用 GREATEST？

1. 需要保底值：确保不低于某个最小值
2. 多选一取最大：从多个值中选最大的
3. 数据修正：把异常值（如负数）修正为合理值
4. 价格控制：设置价格上下限

💡 使用技巧

-- 技巧 1：设置范围（配合 LEAST）
GREATEST(LEAST(value, max_value), min_value)

-- 技巧 2：处理 NULL
GREATEST(COALESCE(value1, 0), COALESCE(value2, 0))

-- 技巧 3：条件保底
GREATEST(calculated_value, minimum_threshold)

📝 代码规范

-- ✅ 好的写法：清晰的注释
SELECT 
    GREATEST(price, cost_price) AS final_price  -- 确保不低于成本
FROM products;

-- ✅ 好的写法：合理的格式化
SELECT GREATEST(
    member_price,
    vip_price,
    regular_price
) AS best_price
FROM products;

快速参考卡片

┌─────────────────────────────────────┐
│     GREATEST 函数速查表              │
├─────────────────────────────────────┤
│ 功能：返回最大值                     │
│                                      │
│ 语法：GREATEST(v1, v2, v3, ...)    │
│                                      │
│ 特点：                               │
│ • NULL 会导致结果为 NULL             │
│ • 类型必须一致                       │
│ • 至少需要 2 个参数                  │
│                                      │
│ 常用场景：                           │
│ • 设置最低值（保底）                 │
│ • 多值选最大                         │
│ • 数据修正                           │
│ • 价格控制                           │
│                                      │
│ 黄金组合：                           │
│ • GREATEST + COALESCE（处理NULL）   │
│ • GREATEST + LEAST（设置范围）      │
└─────────────────────────────────────┘

常见问题 FAQ

Q1: GREATEST 和 MAX 有什么区别？

A:

• GREATEST：比较同一行的多个列/值
• MAX：比较不同行的同一个列

-- GREATEST：横向比较（同一行）
SELECT GREATEST(math, english, science) FROM students;

-- MAX：纵向比较（不同行）
SELECT MAX(math) FROM students;

Q2: 如果所有值都是 NULL 怎么办？

A: 结果就是 NULL。如果想避免，用 COALESCE：

SELECT COALESCE(GREATEST(a, b, c), 0) FROM table;

Q3: 可以比较日期吗？

A: 当然可以！日期也可以比较大小：

SELECT GREATEST('2024-01-01', '2024-06-15');  -- 返回 '2024-06-15'

Q4: 性能怎么样？

A: 非常快！GREATEST 是内置函数，几乎没性能开销。

Q5: 最多可以有多少个参数？

A: PostgreSQL 没有严格限制，但建议不超过 20-30 个，否则影响可读性。

总结

GREATEST 就是一个"选最大值"的实用工具：

✨ 简单易用 ：给它一堆值，它返回最大的

🛡️ 数据安全 ：可以设置保底值，防止异常数据

🎯 灵活多变 ：可以和很多函数配合使用

⚡ 性能优秀：内置函数，速度飞快

记住三个要点：

1. NULL 会让结果变 NULL（用 COALESCE 解决）
2. 类型要一致（数字、文本、日期各自比较）
3. 常和 LEAST 配合设置范围

经典用法：

-- 保底机制
GREATEST(value, minimum_value)

-- 范围限制
GREATEST(LEAST(value, max), min)

-- 处理 NULL
GREATEST(COALESCE(a, 0), COALESCE(b, 0))

用好 GREATEST，让你的 SQL 查询更健壮、更安全！