Appearance
PostgreSQL 数组函数和操作符详解
PostgreSQL 提供了丰富的数组操作符和函数，使得在数据库中处理数组数据变得简单高效。本文将详细介绍这些工具的使用方法，并结合实际业务场景提供完整的示例。
数组操作符概览
INFO
PostgreSQL 数组支持专用操作符进行包含、重叠、连接等操作。除此之外，标准的比较操作符也适用于数组，会逐个元素进行比较。
数组比较机制
在深入了解具体操作符之前，让我们先了解 PostgreSQL 如何比较数组：
核心数组操作符
1. 包含操作符 (@> 和 <@)
@> 操作符：检查是否包含
语法： array1 @> array2 → boolean
功能： 检查第一个数组是否包含第二个数组的所有元素。
sql
-- 检查商品标签是否包含特定标签
SELECT ARRAY['electronics', 'mobile', 'smartphone', 'android'] @> ARRAY['mobile', 'android'];
-- 结果: true
-- 检查用户权限是否包含所需权限
SELECT ARRAY['read', 'write', 'admin'] @> ARRAY['read', 'write'];
-- 结果: truesql
-- 电商场景：查找包含特定标签的商品
CREATE TABLE products (
id SERIAL PRIMARY KEY,
name VARCHAR(100),
tags TEXT[]
);
INSERT INTO products (name, tags) VALUES
('iPhone 15', ARRAY['electronics', 'mobile', 'smartphone', 'apple']),
('Samsung TV', ARRAY['electronics', 'tv', 'samsung', 'smart']),
('Laptop', ARRAY['electronics', 'computer', 'portable']);
-- 查找同时具有 'electronics' 和 'mobile' 标签的商品
SELECT name, tags
FROM products
WHERE tags @> ARRAY['electronics', 'mobile'];
-- 输出:
-- name | tags
-- iPhone 15 | {electronics,mobile,smartphone,apple}<@ 操作符：检查是否被包含
语法： array1 <@ array2 → boolean
功能： 检查第一个数组是否被第二个数组包含。
sql
-- 检查用户当前权限是否在允许范围内
SELECT ARRAY['read', 'write'] <@ ARRAY['read', 'write', 'admin', 'super'];
-- 结果: true
-- 检查请求的权限是否超出用户权限
SELECT ARRAY['admin', 'delete'] <@ ARRAY['read', 'write'];
-- 结果: falsesql
-- 用户权限验证系统
CREATE TABLE user_permissions (
user_id INTEGER,
permissions TEXT[]
);
CREATE TABLE role_permissions (
role_name VARCHAR(50),
max_permissions TEXT[]
);
INSERT INTO user_permissions VALUES
(1, ARRAY['read', 'write']),
(2, ARRAY['read', 'write', 'delete']);
INSERT INTO role_permissions VALUES
('editor', ARRAY['read', 'write', 'edit']),
('admin', ARRAY['read', 'write', 'edit', 'delete', 'admin']);
-- 检查用户权限是否符合角色要求
SELECT u.user_id, u.permissions, r.role_name
FROM user_permissions u
CROSS JOIN role_permissions r
WHERE u.permissions <@ r.max_permissions;2. 重叠操作符 (&&)
语法： array1 && array2 → boolean
功能： 检查两个数组是否有任何共同元素。
sql
-- 检查技能匹配
SELECT ARRAY['java', 'python', 'sql'] && ARRAY['python', 'javascript', 'react'];
-- 结果: true (共同元素: python)
-- 检查兴趣爱好重叠
SELECT ARRAY['reading', 'music', 'sports'] && ARRAY['gaming', 'coding'];
-- 结果: false (无共同元素)sql
CREATE TABLE job_requirements (
job_id SERIAL PRIMARY KEY,
title VARCHAR(100),
required_skills TEXT[]
);
CREATE TABLE candidates (
candidate_id SERIAL PRIMARY KEY,
name VARCHAR(100),
skills TEXT[]
);
INSERT INTO job_requirements (title, required_skills) VALUES
('Backend Developer', ARRAY['java', 'spring', 'mysql', 'redis']),
('Frontend Developer', ARRAY['javascript', 'react', 'css', 'html']),
('Full Stack Developer', ARRAY['java', 'javascript', 'react', 'mysql']);
INSERT INTO candidates (name, skills) VALUES
('Alice', ARRAY['java', 'python', 'mysql']),
('Bob', ARRAY['javascript', 'react', 'node.js']),
('Charlie', ARRAY['java', 'javascript', 'react', 'mysql']);
-- 查找技能匹配的候选人和职位
SELECT j.title, c.name, j.required_skills, c.skills
FROM job_requirements j
CROSS JOIN candidates c
WHERE j.required_skills && c.skills
ORDER BY j.job_id, c.candidate_id;
-- 分析过程：
-- 1. && 操作符检查两个数组是否有交集
-- 2. 只要候选人具备职位要求的任一技能，就会被匹配
-- 3. 可以进一步优化，要求匹配更多技能3. 连接操作符 (||)
数组连接是处理动态数据组合的重要操作。
数组与数组连接
sql
-- 合并两个数组
SELECT ARRAY[1,2,3] || ARRAY[4,5,6];
-- 结果: {1,2,3,4,5,6}
-- 多维数组连接
SELECT ARRAY[1,2,3] || ARRAY[[4,5,6],[7,8,9]];
-- 结果: {{1,2,3},{4,5,6},{7,8,9}}sql
CREATE TABLE daily_logs (
date DATE,
error_codes INTEGER[]
);
INSERT INTO daily_logs VALUES
('2024-01-01', ARRAY[404, 500, 403]),
('2024-01-02', ARRAY[404, 502]),
('2024-01-03', ARRAY[500, 503, 404]);
-- 合并一周的错误代码
SELECT array_cat(
array_cat(
(SELECT error_codes FROM daily_logs WHERE date = '2024-01-01'),
(SELECT error_codes FROM daily_logs WHERE date = '2024-01-02')
),
(SELECT error_codes FROM daily_logs WHERE date = '2024-01-03')
) AS weekly_errors;
-- 更优雅的方式使用聚合函数
SELECT array_agg(error_code) AS all_errors
FROM (
SELECT unnest(error_codes) AS error_code
FROM daily_logs
WHERE date BETWEEN '2024-01-01' AND '2024-01-03'
) t;元素与数组连接
sql
-- 在数组开头添加元素
SELECT 0 || ARRAY[1,2,3];
-- 结果: {0,1,2,3}
-- 在数组末尾添加元素
SELECT ARRAY[1,2,3] || 4;
-- 结果: {1,2,3,4}sql
CREATE TABLE shopping_carts (
user_id INTEGER PRIMARY KEY,
product_ids INTEGER[]
);
INSERT INTO shopping_carts VALUES (1, ARRAY[101, 102, 103]);
-- 添加新商品到购物车
UPDATE shopping_carts
SET product_ids = product_ids || 104
WHERE user_id = 1;
-- 在开头添加优先商品
UPDATE shopping_carts
SET product_ids = 100 || product_ids
WHERE user_id = 1;
SELECT * FROM shopping_carts WHERE user_id = 1;
-- 结果: product_ids = {100,101,102,103,104}核心数组函数
1. 数组构建和修改函数
array_append() - 添加元素到末尾
sql
SELECT array_append(ARRAY[1,2,3], 4);
-- 结果: {1,2,3,4}
SELECT array_append(ARRAY['apple', 'banana'], 'orange');
-- 结果: {apple,banana,orange}sql
CREATE TABLE articles (
id SERIAL PRIMARY KEY,
title VARCHAR(200),
tags TEXT[]
);
INSERT INTO articles (title, tags) VALUES
('PostgreSQL Tutorial', ARRAY['database', 'sql']);
-- 动态添加标签
UPDATE articles
SET tags = array_append(tags, 'postgresql')
WHERE id = 1;
UPDATE articles
SET tags = array_append(tags, 'tutorial')
WHERE id = 1;
SELECT title, tags FROM articles WHERE id = 1;
-- 结果: tags = {database,sql,postgresql,tutorial}array_prepend() - 添加元素到开头
sql
SELECT array_prepend(0, ARRAY[1,2,3]);
-- 结果: {0,1,2,3}sql
CREATE TABLE message_queue (
queue_id INTEGER PRIMARY KEY,
messages TEXT[]
);
INSERT INTO message_queue VALUES (1, ARRAY['msg2', 'msg3', 'msg4']);
-- 添加高优先级消息到队列开头
UPDATE message_queue
SET messages = array_prepend('urgent_msg', messages)
WHERE queue_id = 1;
SELECT * FROM message_queue;
-- 结果: messages = {urgent_msg,msg2,msg3,msg4}array_cat() - 连接数组
sql
SELECT array_cat(ARRAY[1,2,3], ARRAY[4,5,6]);
-- 结果: {1,2,3,4,5,6}sql
CREATE TABLE batch_results (
batch_id INTEGER,
processed_ids INTEGER[]
);
INSERT INTO batch_results VALUES
(1, ARRAY[1,2,3,4,5]),
(2, ARRAY[6,7,8,9,10]),
(3, ARRAY[11,12,13,14,15]);
-- 合并所有批次的处理结果
SELECT array_cat(
array_cat(
(SELECT processed_ids FROM batch_results WHERE batch_id = 1),
(SELECT processed_ids FROM batch_results WHERE batch_id = 2)
),
(SELECT processed_ids FROM batch_results WHERE batch_id = 3)
) AS all_processed;2. 数组查询和分析函数
array_length() - 获取数组长度
WARNING
对于空数组或不存在的维度，array_length() 返回 NULL 而不是 0。这是一个常见的陷阱！
sql
SELECT array_length(ARRAY[1,2,3,4,5], 1);
-- 结果: 5
SELECT array_length(ARRAY[]::int[], 1);
-- 结果: NULL (注意不是0)
SELECT array_length(ARRAY['single'], 2);
-- 结果: NULL (第二维不存在)sql
CREATE TABLE survey_responses (
response_id SERIAL PRIMARY KEY,
user_id INTEGER,
answers TEXT[]
);
INSERT INTO survey_responses (user_id, answers) VALUES
(1, ARRAY['yes', 'no', 'maybe', 'yes']),
(2, ARRAY['no', 'yes']),
(3, ARRAY[]::TEXT[]);
-- 检查回答完整性 (期望4个答案)
SELECT
response_id,
user_id,
array_length(answers, 1) AS answer_count,
CASE
WHEN array_length(answers, 1) = 4 THEN '完整'
WHEN array_length(answers, 1) IS NULL THEN '空回答'
ELSE '不完整'
END AS status
FROM survey_responses;
-- 输出分析:
-- response_id | user_id | answer_count | status
-- 1 | 1 | 4 | 完整
-- 2 | 2 | 2 | 不完整
-- 3 | 3 | NULL | 空回答array_position() 和 array_positions() - 查找元素位置
sql
SELECT array_position(ARRAY['sun','mon','tue','wed','thu','fri','sat'], 'wed');
-- 结果: 4
-- 从指定位置开始查找
SELECT array_position(ARRAY[1,2,3,2,4,2], 2, 3);
-- 结果: 4 (从第3个位置开始找到的第一个2)sql
SELECT array_positions(ARRAY['A','B','A','C','A'], 'A');
-- 结果: {1,3,5}
SELECT array_positions(ARRAY[1,2,3,4], 5);
-- 结果: {} (空数组，不是NULL)sql
CREATE TABLE access_logs (
log_id SERIAL PRIMARY KEY,
status_codes INTEGER[]
);
INSERT INTO access_logs (status_codes) VALUES
(ARRAY[200, 404, 200, 500, 200, 404]),
(ARRAY[200, 200, 200]),
(ARRAY[404, 500, 503, 404]);
-- 分析错误状态码的分布
SELECT
log_id,
status_codes,
array_length(array_positions(status_codes, 404), 1) AS error_404_count,
array_length(array_positions(status_codes, 500), 1) AS error_500_count,
array_positions(status_codes, 404) AS error_404_positions
FROM access_logs;
-- 分析过程:
-- 1. array_positions() 找到所有404错误的位置
-- 2. array_length() 计算错误出现次数
-- 3. 显示具体错误位置便于调试3. 数组维度和结构函数
array_dims() - 获取数组维度信息
sql
SELECT array_dims(ARRAY[[1,2,3], [4,5,6]]);
-- 结果: [1:2][1:3] (2行3列)
SELECT array_dims(ARRAY[1,2,3,4,5]);
-- 结果: [1:5] (一维数组，5个元素)sql
CREATE TABLE matrices (
matrix_id SERIAL PRIMARY KEY,
data INTEGER[][]
);
INSERT INTO matrices (data) VALUES
(ARRAY[[1,2,3], [4,5,6]]),
(ARRAY[[1,2], [3,4], [5,6]]),
(ARRAY[[1,2,3,4]]);
SELECT
matrix_id,
array_dims(data) AS dimensions,
array_ndims(data) AS dimension_count,
cardinality(data) AS total_elements
FROM matrices;
-- 输出:
-- matrix_id | dimensions | dimension_count | total_elements
-- 1 | [1:2][1:3] | 2 | 6
-- 2 | [1:3][1:2] | 2 | 6
-- 3 | [1:4] | 1 | 4cardinality() - 计算元素总数
sql
SELECT cardinality(ARRAY[[1,2],[3,4]]);
-- 结果: 4
SELECT cardinality(ARRAY[]::int[]);
-- 结果: 0sql
CREATE TABLE user_activities (
user_id INTEGER,
daily_actions TEXT[][]
);
INSERT INTO user_activities VALUES
(1, ARRAY[['login','browse','purchase'], ['login','browse']]),
(2, ARRAY[['login'], ['login','browse','share','logout']]);
-- 统计用户活动总量
SELECT
user_id,
cardinality(daily_actions) AS total_actions,
array_length(daily_actions, 1) AS active_days
FROM user_activities;4. 数组处理和转换函数
array_remove() 和 array_replace() - 删除和替换元素
sql
SELECT array_remove(ARRAY[1,2,3,2,4], 2);
-- 结果: {1,3,4} (移除所有的2)
SELECT array_remove(ARRAY['apple',NULL,'banana',NULL], NULL);
-- 结果: {apple,banana} (移除所有NULL值)sql
SELECT array_replace(ARRAY[1,2,5,4], 5, 3);
-- 结果: {1,2,3,4}sql
CREATE TABLE raw_data (
id SERIAL PRIMARY KEY,
values INTEGER[]
);
INSERT INTO raw_data (values) VALUES
(ARRAY[1, -999, 3, 4, -999, 6]), -- -999 表示无效数据
(ARRAY[2, 5, -999, 8, 9]);
-- 清洗数据：移除无效值并替换特殊标记
UPDATE raw_data
SET values = array_remove(
array_replace(values, -999, NULL),
NULL
);
SELECT * FROM raw_data;
-- 清洗后的数据:
-- id | values
-- 1 | {1,3,4,6}
-- 2 | {2,5,8,9}unnest() - 数组展开
unnest() 是最强大的数组函数之一，可以将数组转换为行集。
sql
SELECT unnest(ARRAY[1,2,3]);
-- 结果:
-- 1
-- 2
-- 3
SELECT unnest(ARRAY[['foo','bar'],['baz','quux']]);
-- 结果:
-- foo
-- bar
-- baz
-- quuxsql
SELECT * FROM unnest(
ARRAY[1,2,3],
ARRAY['a','b','c']
) AS t(num, letter);
-- 结果:
-- num | letter
-- 1 | a
-- 2 | b
-- 3 | csql
CREATE TABLE product_reviews (
product_id INTEGER,
reviewer_names TEXT[],
ratings INTEGER[]
);
INSERT INTO product_reviews VALUES
(1, ARRAY['Alice', 'Bob', 'Charlie'], ARRAY[5, 4, 5]),
(2, ARRAY['David', 'Eve'], ARRAY[3, 4]);
-- 展开分析每个评论
SELECT
product_id,
reviewer_name,
rating,
CASE
WHEN rating >= 4 THEN '好评'
WHEN rating = 3 THEN '中评'
ELSE '差评'
END AS review_type
FROM (
SELECT
product_id,
unnest(reviewer_names) AS reviewer_name,
unnest(ratings) AS rating
FROM product_reviews
) expanded_reviews
ORDER BY product_id, rating DESC;
-- 分析过程:
-- 1. unnest() 将数组展开为行
-- 2. 每个评论者和对应评分配对
-- 3. 添加评分分类便于统计分析5. 实用工具函数
array_to_string() - 数组转字符串
sql
SELECT array_to_string(ARRAY[1,2,3,4], ',');
-- 结果: '1,2,3,4'
SELECT array_to_string(ARRAY['apple','banana',NULL,'orange'], '|', 'N/A');
-- 结果: 'apple|banana|N/A|orange'sql
CREATE TABLE employee_skills (
emp_id INTEGER,
name VARCHAR(100),
skills TEXT[]
);
INSERT INTO employee_skills VALUES
(1, 'Alice', ARRAY['Java', 'Python', 'SQL']),
(2, 'Bob', ARRAY['JavaScript', 'React', 'Node.js']);
-- 生成技能报告
SELECT
name,
array_to_string(skills, ' | ') AS skill_summary,
array_length(skills, 1) AS skill_count
FROM employee_skills;
-- 输出:
-- name | skill_summary | skill_count
-- Alice | Java | Python | SQL | 3
-- Bob | JavaScript | React | Node.js | 3array_fill() - 创建填充数组
sql
SELECT array_fill(0, ARRAY[3]);
-- 结果: {0,0,0}
SELECT array_fill('default', ARRAY[2,3]);
-- 结果: {{default,default,default},{default,default,default}}
-- 指定起始索引
SELECT array_fill(1, ARRAY[3], ARRAY[5]);
-- 结果: [5:7]={1,1,1}sql
-- 创建用户权限模板
CREATE OR REPLACE FUNCTION create_user_template(user_count INTEGER)
RETURNS TABLE(user_id INTEGER, permissions TEXT[]) AS $$
BEGIN
RETURN QUERY
SELECT
generate_series(1, user_count),
array_fill('read'::TEXT, ARRAY[1]) AS default_permissions;
END;
$$ LANGUAGE plpgsql;
-- 批量创建用户
SELECT * FROM create_user_template(5);
-- 输出:
-- user_id | permissions
-- 1 | {read}
-- 2 | {read}
-- 3 | {read}
-- 4 | {read}
-- 5 | {read}高级应用场景
1. 数组索引和性能优化
TIP
PostgreSQL 支持对数组创建 GIN 索引，大大提升包含查询的性能。
sql
-- 创建产品表
CREATE TABLE products (
id SERIAL PRIMARY KEY,
name VARCHAR(200),
tags TEXT[],
categories INTEGER[]
);
-- 为数组字段创建 GIN 索引
CREATE INDEX idx_products_tags ON products USING GIN (tags);
CREATE INDEX idx_products_categories ON products USING GIN (categories);
-- 插入测试数据
INSERT INTO products (name, tags, categories) VALUES
('MacBook Pro', ARRAY['laptop', 'apple', 'professional'], ARRAY[1, 2, 3]),
('iPhone 15', ARRAY['smartphone', 'apple', 'mobile'], ARRAY[1, 4]),
('Samsung Galaxy', ARRAY['smartphone', 'samsung', 'android'], ARRAY[1, 4, 5]);sql
-- 使用索引的高效查询
EXPLAIN (ANALYZE, BUFFERS)
SELECT name, tags
FROM products
WHERE tags @> ARRAY['apple'];
-- 复合条件查询
SELECT name, tags, categories
FROM products
WHERE tags && ARRAY['smartphone', 'laptop']
AND categories @> ARRAY[1];2. 复杂业务场景：推荐系统
sql
CREATE TABLE users (
user_id SERIAL PRIMARY KEY,
name VARCHAR(100),
interests TEXT[]
);
CREATE TABLE items (
item_id SERIAL PRIMARY KEY,
title VARCHAR(200),
tags TEXT[],
popularity_score INTEGER
);
INSERT INTO users (name, interests) VALUES
('Alice', ARRAY['technology', 'programming', 'ai']),
('Bob', ARRAY['sports', 'fitness', 'health']),
('Charlie', ARRAY['technology', 'gaming', 'music']);
INSERT INTO items (title, tags, popularity_score) VALUES
('AI Programming Course', ARRAY['technology', 'programming', 'ai', 'course'], 95),
('Fitness Tracker Review', ARRAY['sports', 'fitness', 'health', 'review'], 80),
('Gaming Setup Guide', ARRAY['technology', 'gaming', 'guide'], 75),
('Music Production Tutorial', ARRAY['music', 'tutorial', 'creative'], 70);sql
-- 基于兴趣匹配的推荐算法
WITH user_recommendations AS (
SELECT
u.user_id,
u.name,
i.item_id,
i.title,
i.popularity_score,
-- 计算兴趣匹配度
array_length(
(SELECT array_agg(interest)
FROM unnest(u.interests) AS interest
WHERE interest = ANY(i.tags)
), 1
) AS interest_match_count,
-- 计算推荐分数
(array_length(
(SELECT array_agg(interest)
FROM unnest(u.interests) AS interest
WHERE interest = ANY(i.tags)
), 1
) * 100 + i.popularity_score) AS recommendation_score
FROM users u
CROSS JOIN items i
WHERE u.interests && i.tags -- 至少有一个兴趣匹配
)
SELECT
name AS user_name,
title AS recommended_item,
interest_match_count,
recommendation_score,
RANK() OVER (PARTITION BY user_id ORDER BY recommendation_score DESC) AS rank
FROM user_recommendations
WHERE interest_match_count > 0
ORDER BY user_id, recommendation_score DESC;
-- 分析过程:
-- 1. 使用 && 操作符快速筛选有兴趣重叠的项目
-- 2. 计算精确的兴趣匹配数量
-- 3. 结合流行度计算推荐分数
-- 4. 按用户分组排序，生成个性化推荐列表3. 时间序列数据处理
sql
CREATE TABLE sensor_readings (
sensor_id INTEGER,
timestamp TIMESTAMP,
values NUMERIC[]
);
INSERT INTO sensor_readings VALUES
(1, '2024-01-01 10:00:00', ARRAY[23.5, 24.1, 23.8, 24.2]),
(1, '2024-01-01 11:00:00', ARRAY[24.0, 24.5, 24.3, 24.8]),
(2, '2024-01-01 10:00:00', ARRAY[18.2, 18.5, 18.1, 18.7]);
-- 数组数据的统计分析
SELECT
sensor_id,
timestamp,
values,
array_length(values, 1) AS reading_count,
-- 计算平均值
(SELECT AVG(val) FROM unnest(values) AS val) AS avg_value,
-- 计算最大值和最小值
(SELECT MAX(val) FROM unnest(values) AS val) AS max_value,
(SELECT MIN(val) FROM unnest(values) AS val) AS min_value,
-- 计算值的范围
(SELECT MAX(val) - MIN(val) FROM unnest(values) AS val) AS value_range
FROM sensor_readings
ORDER BY sensor_id, timestamp;性能优化最佳实践
1. 索引策略
2. 查询优化技巧
sql
-- ❌ 低效：没有使用数组操作符
SELECT * FROM products
WHERE 'electronics' = ANY(tags);
-- ✅ 高效：使用包含操作符
SELECT * FROM products
WHERE tags @> ARRAY['electronics'];sql
-- ❌ 低效：逐行更新
UPDATE user_permissions
SET permissions = array_append(permissions, 'new_permission')
WHERE user_id IN (1,2,3,4,5);
-- ✅ 高效：批量更新
UPDATE user_permissions
SET permissions = permissions || ARRAY['new_permission']
WHERE user_id = ANY(ARRAY[1,2,3,4,5]);常见陷阱和注意事项
WARNING
重要提醒
- NULL 处理：
array_length()对空数组返回 NULL，不是 0 - 维度限制：PostgreSQL 数组维度有限制，通常不超过 6 维
- 性能考虑：大数组的操作可能很慢，考虑分页或分块处理
- 索引选择：并非所有数组操作都能使用索引，了解哪些能用很重要
sql
-- 安全的数组长度检查
SELECT
COALESCE(array_length(some_array, 1), 0) AS safe_length
FROM some_table;
-- 空数组检查
SELECT
CASE
WHEN some_array IS NULL THEN 'NULL'
WHEN array_length(some_array, 1) IS NULL THEN 'Empty'
ELSE 'Has Data'
END AS array_status
FROM some_table;sql
-- 确保数组类型匹配
SELECT ARRAY[1,2,3] || ARRAY[4,5,6]; -- ✅ 正确
SELECT ARRAY[1,2,3] || ARRAY['4','5']; -- ❌ 类型不匹配
-- 使用类型转换
SELECT ARRAY[1,2,3] || ARRAY['4','5']::INTEGER[]; -- ✅ 正确总结
PostgreSQL 的数组功能为处理复杂的多值数据提供了强大的工具集。通过合理使用数组操作符和函数，可以简化数据模型设计，提高查询效率，并实现复杂的业务逻辑。
关键要点：
- 选择合适的操作符：根据业务需求选择
@>、<@、&&等操作符 - 合理使用索引：为数组字段创建 GIN 索引以提升查询性能
- 注意 NULL 处理：理解数组函数的 NULL 返回行为
- 结合实际场景：将数组功能与业务逻辑紧密结合，发挥最大价值
数组是 PostgreSQL 的强大特性之一，掌握这些函数和操作符将大大提升你的数据库开发效率和数据处理能力。