@gordon.gan/specflow 1.3.3-beta → 1.4.1

package/skills/database/postgresql/examples/02-cte-recursive.md

@@ -0,0 +1,110 @@
+# 递归 CTE 示例
+
+## 场景 1：组织架构树
+
+查询从根节点到所有子节点的完整部门树。
+
+```sql
+-- 建表
+CREATE TABLE departments (
+    id          SERIAL PRIMARY KEY,
+    name        TEXT NOT NULL,
+    parent_id   INTEGER REFERENCES departments(id)
+);
+
+-- 插入层级数据
+INSERT INTO departments (id, name, parent_id) VALUES
+    (1, '总公司', NULL),
+    (2, '技术部', 1),
+    (3, '市场部', 1),
+    (4, '后端组', 2),
+    (5, '前端组', 2),
+    (6, '数据组', 2),
+    (7, '广告组', 3),
+    (8, 'PR 组', 3);
+
+-- 递归 CTE: 展开整个树
+WITH RECURSIVE org_tree AS (
+    -- 基础: 根节点
+    SELECT id, name, parent_id, 1 AS level, ARRAY[id] AS path
+    FROM departments
+    WHERE parent_id IS NULL
+
+    UNION ALL
+
+    -- 递归: 子节点
+    SELECT d.id, d.name, d.parent_id, t.level + 1, t.path || d.id
+    FROM departments d
+    JOIN org_tree t ON d.parent_id = t.id
+)
+SELECT id, name, level, repeat('  ', level - 1) || name AS tree_display
+FROM org_tree ORDER BY path;
+```
+
+## 场景 2：商品分类全路径
+
+将树形分类扁平化并显示完整路径。
+
+```sql
+-- 建表
+CREATE TABLE categories (
+    id          SERIAL PRIMARY KEY,
+    name        TEXT NOT NULL,
+    parent_id   INTEGER REFERENCES categories(id)
+);
+
+INSERT INTO categories (id, name, parent_id) VALUES
+    (1, '电子产品', NULL),
+    (2, '手机', 1),
+    (3, '电脑', 1),
+    (4, '智能手机', 2),
+    (5, '功能机', 2),
+    (6, '笔记本', 3),
+    (7, '台式机', 3);
+
+-- 从指定节点开始，查询所有子分类及其全路径
+WITH RECURSIVE category_tree AS (
+    SELECT id, name, parent_id, name AS full_path
+    FROM categories WHERE id = 1  -- 从 "电子产品" 开始
+
+    UNION ALL
+
+    SELECT c.id, c.name, c.parent_id,
+           ct.full_path || ' > ' || c.name
+    FROM categories c
+    JOIN category_tree ct ON c.parent_id = ct.id
+)
+SELECT * FROM category_tree ORDER BY full_path;
+```
+
+## 场景 3：斐波那契数列
+
+```sql
+WITH RECURSIVE fib(a, b) AS (
+    SELECT 0::BIGINT, 1::BIGINT
+    UNION ALL
+    SELECT b, a + b FROM fib WHERE b < 1000
+)
+SELECT a FROM fib;
+```
+
+## 场景 4：销售统计占比
+
+使用非递归 CTE 计算每个分类的销售额占比。
+
+```sql
+WITH category_sales AS (
+    SELECT c.name AS category, SUM(oi.quantity * oi.price) AS total
+    FROM order_items oi
+    JOIN products p ON p.id = oi.product_id
+    JOIN categories c ON c.id = p.category_id
+    GROUP BY c.name
+),
+grand_total AS (
+    SELECT SUM(total) AS total FROM category_sales
+)
+SELECT cs.category, cs.total,
+       ROUND(cs.total / gt.total * 100, 2) AS pct
+FROM category_sales cs, grand_total gt
+ORDER BY cs.total DESC;
+```

package/skills/database/postgresql/examples/03-performance-tuning.md

@@ -0,0 +1,114 @@
+# 性能调优示例
+
+## 场景 1：定位慢查询
+
+使用 EXPLAIN ANALYZE 诊断查询性能问题。
+
+```sql
+-- 创建测试表
+CREATE TABLE orders (
+    id BIGSERIAL, user_id INTEGER NOT NULL, status TEXT,
+    total_amount NUMERIC(12,2), created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+-- 插入测试数据（假设已有数百万行）
+
+-- 诊断慢查询
+EXPLAIN (ANALYZE, BUFFERS)
+SELECT * FROM orders WHERE status = 'pending' AND created_at > '2024-01-01';
+-- 如果看到 Seq Scan → 需要加索引
+
+-- 创建复合索引
+CREATE INDEX idx_orders_status_created ON orders (status, created_at DESC);
+
+-- 再次验证
+EXPLAIN (ANALYZE, BUFFERS)
+SELECT * FROM orders WHERE status = 'pending' AND created_at > '2024-01-01';
+-- 现在应该看到 Index Scan
+```
+
+## 场景 2：JOIN 性能优化
+
+```sql
+-- 慢查询：大表 JOIN + GROUP BY
+EXPLAIN (ANALYZE, BUFFERS)
+SELECT u.name, COUNT(o.id) AS order_count
+FROM users u LEFT JOIN orders o ON o.user_id = u.id
+WHERE u.created_at > '2024-01-01'
+GROUP BY u.id, u.name;
+
+-- 检查输出中的 Sort Method
+-- 如果看到 "external merge Disk: 1536kB" → work_mem 不足
+
+-- 临时增加 work_mem（当前会话）
+SET work_mem = '256MB';
+
+-- 或者创建覆盖索引
+CREATE INDEX idx_orders_user_id_covering ON orders (user_id) INCLUDE (id);
+```
+
+## 场景 3：VACUUM 与膨胀监控
+
+```sql
+-- 查看表膨胀情况
+SELECT relname, n_live_tup, n_dead_tup,
+       ROUND(n_dead_tup::NUMERIC / NULLIF(n_live_tup, 0) * 100, 2) AS dead_pct,
+       last_autovacuum, last_autoanalyze
+FROM pg_stat_user_tables
+WHERE n_dead_tup > 0
+ORDER BY n_dead_tup DESC LIMIT 20;
+
+-- 为高频更新表调优 autovacuum
+ALTER TABLE orders SET (
+    autovacuum_vacuum_scale_factor = 0.05,
+    autovacuum_vacuum_threshold = 1000
+);
+
+-- 检查事务 ID 回卷风险
+SELECT datname, age(datfrozenxid) AS age,
+       ROUND(100 * age(datfrozenxid)::NUMERIC / 2000000000, 2) AS pct_wraparound
+FROM pg_database ORDER BY age DESC;
+```
+
+## 场景 4：pg_stat_statements 分析
+
+```sql
+CREATE EXTENSION IF NOT EXISTS pg_stat_statements;
+
+-- TOP 10 最耗时查询
+SELECT queryid, LEFT(query, 80) AS query_preview, calls,
+       ROUND(total_exec_time::NUMERIC, 2) AS total_ms,
+       ROUND(mean_exec_time::NUMERIC, 2) AS avg_ms,
+       ROUND(shared_blks_hit::NUMERIC / NULLIF(shared_blks_hit + shared_blks_read, 0) * 100, 2) AS hit_ratio
+FROM pg_stat_statements
+ORDER BY total_exec_time DESC LIMIT 10;
+
+-- TOP 10 I/O 密集查询
+SELECT queryid, LEFT(query, 80) AS query_preview,
+       shared_blks_read, temp_blks_read
+FROM pg_stat_statements
+WHERE shared_blks_read > 1000
+ORDER BY shared_blks_read DESC LIMIT 10;
+
+-- TOP 10 临时文件使用（work_mem 不足）
+SELECT queryid, LEFT(query, 80) AS query_preview,
+       temp_blk_read_time, temp_blk_write_time
+FROM pg_stat_statements
+WHERE temp_blk_read_time > 0
+ORDER BY temp_blk_read_time DESC LIMIT 10;
+```
+
+## 场景 5：配置调优参考
+
+```conf
+# 64GB 内存服务器参考配置
+shared_buffers = 12GB            # 物理内存 20-25%
+work_mem = 64MB                  # 每个排序操作
+maintenance_work_mem = 1GB       # VACUUM/CREATE INDEX
+effective_cache_size = 12GB      # 规划器缓存估计
+wal_buffers = 16MB
+max_connections = 200            # 超过则用 PgBouncer
+checkpoint_timeout = 15min
+max_wal_size = 16GB
+default_statistics_target = 100  # 大表可调至 500-1000
+```

package/skills/database/postgresql/examples/04-streaming-replication.md

@@ -0,0 +1,113 @@
+# 流复制搭建示例
+
+## 场景：搭建一主一从的高可用架构
+
+### 主库配置
+
+```conf
+# postgresql.conf 配置
+listen_addresses = 'localhost,192.168.1.100'
+wal_level = replica
+max_wal_senders = 10
+wal_keep_size = 1GB
+hot_standby = on
+```
+
+```bash
+# 重启主库
+systemctl restart postgresql
+```
+
+### 创建复制用户
+
+```sql
+-- 在主库执行
+CREATE USER replicator WITH REPLICATION LOGIN PASSWORD 'Str0ng!Pass';
+```
+
+```bash
+# 在 pg_hba.conf 添加
+echo 'host replication replicator 192.168.1.0/24 md5' >> /var/lib/pgsql/data/pg_hba.conf
+
+# 重新加载配置
+psql -c "SELECT pg_reload_conf();"
+```
+
+### 从库搭建
+
+```bash
+# 安装相同版本 PostgreSQL
+
+# 停从库
+systemctl stop postgresql
+
+# 清空从库数据目录
+rm -rf /var/lib/pgsql/data/*
+
+# 从主库拉取基础备份
+pg_basebackup -h 192.168.1.100 -U replicator \
+    -D /var/lib/pgsql/data -P -v --wal-method=stream
+
+# PG 12+: 创建 standby 信号文件
+touch /var/lib/pgsql/data/standby.signal
+
+# 配置主库连接信息
+cat > /var/lib/pgsql/data/postgresql.auto.conf << EOF
+primary_conninfo = 'host=192.168.1.100 port=5432 user=replicator password=Str0ng!Pass'
+EOF
+
+# 启动从库
+systemctl start postgresql
+```
+
+### 验证复制
+
+```sql
+-- 在主库检查复制状态
+SELECT pid, application_name, state, sync_state,
+       write_lag, flush_lag, replay_lag
+FROM pg_stat_replication;
+
+-- 在从库检查接收状态
+SELECT pid, status, receive_start_lsn, received_lsn,
+       latest_end_lsn, latest_end_time
+FROM pg_stat_wal_receiver;
+
+-- 测试: 在主库创建表并插入数据
+CREATE TABLE test_replication (id SERIAL PRIMARY KEY, data TEXT, ts TIMESTAMPTZ DEFAULT NOW());
+INSERT INTO test_replication (data) VALUES ('hello from primary');
+
+-- 在从库验证（从库为只读模式）
+SELECT * FROM test_replication;
+```
+
+### 故障转移
+
+```bash
+# 手动提升从库为主库
+# 在从库执行
+pg_ctl promote -D /var/lib/pgsql/data
+# 或
+systemctl stop postgresql
+# 删除 standby.signal 后启动
+rm /var/lib/pgsql/data/standby.signal
+systemctl start postgresql
+
+# 此时原从库变为可读写
+```
+
+### 常见问题排查
+
+```bash
+# 查看复制日志
+tail -f /var/lib/pgsql/data/log/postgresql-*.log
+
+# 检查网络连通性
+psql -h 192.168.1.100 -U replicator -d postgres -c "SELECT 1"
+
+# 检查 WAL 发送进程
+ps aux | grep wal_sender
+
+# 检查磁盘空间（WAL 堆积会导致磁盘满）
+df -h /var/lib/pgsql/data/
+```

package/skills/database/postgresql/references/01-functions-string.md

@@ -0,0 +1,174 @@
+# 字符串/正则函数详解
+
+## 字符串函数
+
+```sql
+-- FORMAT — 格式化字符串
+SELECT FORMAT('ORD-%s-%04d', TO_CHAR(NOW(), 'YYYYMMDD'), 123);
+-- 结果: ORD-20240529-0123
+
+-- SPLIT_PART — 分割字符串
+SELECT SPLIT_PART('北京市海淀区中关村', '区', 1);
+-- 结果: 北京市海淀
+
+-- STRING_AGG — 字符串聚合（将分类名称合并为逗号分隔字符串）
+SELECT STRING_AGG(DISTINCT c.name, ', ' ORDER BY c.name) AS categories
+FROM products p
+JOIN product_categories pc ON pc.product_id = p.id
+JOIN categories c ON c.id = pc.category_id
+WHERE p.id = 1001;
+
+-- CONCAT / CONCAT_WS
+SELECT CONCAT_WS(', ', province, city, district, detail) AS full_address FROM addresses;
+
+-- LEFT / RIGHT
+SELECT LEFT('Hello World', 5);   -- Hello
+SELECT RIGHT('Hello World', 5);  -- World
+
+-- REPEAT / REVERSE
+SELECT REPEAT('*', 5);           -- *****
+SELECT REVERSE('PostgreSQL');    -- LQSregtsoP
+
+-- POSITION / STRPOS
+SELECT POSITION('SQL' IN 'PostgreSQL');  -- 7
+SELECT STRPOS('PostgreSQL', 'SQL');       -- 7
+
+-- SUBSTRING (支持正则)
+SELECT SUBSTRING('abc123def' FROM '[0-9]+');  -- 123
+
+-- TRANSLATE
+SELECT TRANSLATE('hello', 'aeiou', '12345');  -- h2ll4
+```
+
+## 正则函数
+
+```sql
+-- REGEXP_MATCH — 正则匹配（提取邮箱）
+SELECT REGEXP_MATCH(
+    '联系邮箱: alice@example.com, 备用: bob@test.com',
+    '[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}',
+    'g'
+);
+-- 结果: {alice@example.com,bob@test.com}
+
+-- REGEXP_REPLACE — 正则替换（脱敏手机号）
+SELECT REGEXP_REPLACE('13812345678', '(\d{3})\d{4}(\d{4})', '\1****\2');
+-- 结果: 138****5678
+```
+
+## PL/pgSQL 函数
+
+```sql
+-- 标量函数
+CREATE OR REPLACE FUNCTION calculate_discount(
+    price NUMERIC, discount_pct NUMERIC, max_discount NUMERIC DEFAULT 100
+) RETURNS NUMERIC
+LANGUAGE plpgsql IMMUTABLE
+AS $$
+BEGIN
+    RETURN GREATEST(price * (1 - discount_pct / 100), price - max_discount);
+END;
+$$;
+
+-- 表函数 (RETURNS TABLE)
+CREATE OR REPLACE FUNCTION get_user_orders(
+    p_user_id INTEGER, p_status TEXT DEFAULT NULL, p_limit INTEGER DEFAULT 100
+) RETURNS TABLE (order_id BIGINT, total_amount NUMERIC(12,2), status TEXT, created_at TIMESTAMPTZ)
+LANGUAGE plpgsql STABLE
+AS $$
+BEGIN
+    RETURN QUERY
+    SELECT o.id, o.total_amount, o.status, o.created_at
+    FROM orders o
+    WHERE o.user_id = p_user_id AND (p_status IS NULL OR o.status = p_status)
+    ORDER BY o.created_at DESC LIMIT p_limit;
+END;
+$$;
+
+-- 函数 (FUNCTION) vs 过程 (PROCEDURE)
+-- FUNCTION: 必须返回值, SELECT 中调用
+-- PROCEDURE (PG 11+): 无返回值, CALL 调用, 支持事务控制
+
+-- 函数重载
+CREATE OR REPLACE FUNCTION format_price(price NUMERIC) RETURNS TEXT
+LANGUAGE SQL IMMUTABLE AS $$ SELECT '¥' || ROUND(price, 2)::TEXT; $$;
+
+CREATE OR REPLACE FUNCTION format_price(price NUMERIC, currency TEXT) RETURNS TEXT
+LANGUAGE SQL IMMUTABLE AS $$ SELECT currency || ROUND(price, 2)::TEXT; $$;
+
+-- PL/pgSQL 控制结构
+CREATE OR REPLACE FUNCTION process_order(p_order_id BIGINT) RETURNS TEXT
+LANGUAGE plpgsql
+AS $$
+DECLARE
+    v_order orders%ROWTYPE;
+    v_log TEXT := '';
+BEGIN
+    SELECT * INTO STRICT v_order FROM orders WHERE id = p_order_id;
+
+    IF v_order.status = 'pending' THEN
+        v_log := '待处理';
+    ELSIF v_order.status = 'paid' THEN
+        v_log := '已支付';
+    END IF;
+
+    RETURN v_log;
+EXCEPTION
+    WHEN NO_DATA_FOUND THEN RETURN '订单不存在';
+    WHEN OTHERS THEN RETURN '错误: ' || SQLERRM;
+END;
+$$;
+```
+
+## 触发器
+
+```sql
+-- 自动更新 updated_at
+CREATE OR REPLACE FUNCTION update_updated_at_column() RETURNS TRIGGER
+LANGUAGE plpgsql AS $$ BEGIN NEW.updated_at = NOW(); RETURN NEW; END; $$;
+
+CREATE TRIGGER trg_users_updated_at
+    BEFORE UPDATE ON users
+    FOR EACH ROW WHEN (OLD.* IS DISTINCT FROM NEW.*)
+    EXECUTE FUNCTION update_updated_at_column();
+
+-- 审计日志触发器
+CREATE OR REPLACE FUNCTION audit_order_changes() RETURNS TRIGGER
+LANGUAGE plpgsql
+AS $$
+BEGIN
+    IF TG_OP = 'INSERT' THEN
+        INSERT INTO order_audit_log (order_id, new_data, action) VALUES (NEW.id, row_to_json(NEW)::JSONB, 'INSERT');
+    ELSIF TG_OP = 'UPDATE' THEN
+        INSERT INTO order_audit_log (order_id, old_data, new_data, action) VALUES (NEW.id, row_to_json(OLD)::JSONB, row_to_json(NEW)::JSONB, 'UPDATE');
+    ELSIF TG_OP = 'DELETE' THEN
+        INSERT INTO order_audit_log (order_id, old_data, action) VALUES (OLD.id, row_to_json(OLD)::JSONB, 'DELETE');
+    END IF;
+    RETURN NEW;
+END;
+$$;
+
+-- 事件触发器 (DDL)
+CREATE OR REPLACE FUNCTION prevent_table_drop() RETURNS EVENT_TRIGGER
+LANGUAGE plpgsql AS $$ BEGIN RAISE EXCEPTION '禁止删除表'; END; $$;
+CREATE EVENT TRIGGER prevent_drop_trigger ON sql_drop EXECUTE FUNCTION prevent_table_drop();
+```
+
+## 数字函数
+
+```sql
+-- RANDOM — 随机抽样
+SELECT * FROM users ORDER BY RANDOM() LIMIT 5;
+
+-- GENERATE_SERIES — 生成序列
+SELECT GENERATE_SERIES('2024-01-01'::DATE, '2024-01-10'::DATE, '1 day');
+SELECT GENERATE_SERIES(1, 10, 2);  -- 1, 3, 5, 7, 9
+
+-- WIDTH_BUCKET — 等宽分桶
+SELECT WIDTH_BUCKET(age, 0, 100, 10) AS bucket, MIN(age), MAX(age), COUNT(*)
+FROM users GROUP BY bucket ORDER BY bucket;
+
+-- ROUND / TRUNC / CEIL / FLOOR / POWER / SQRT / ABS / DIV / MOD / GCD / LCM
+SELECT ROUND(123.456, 2), TRUNC(123.456, 2), CEIL(123.001), FLOOR(123.999);
+SELECT POWER(2,10), SQRT(144), ABS(-42), DIV(10,3), MOD(10,3), GCD(12,18), LCM(12,18);
+```

package/skills/database/postgresql/references/02-functions-datetime.md

@@ -0,0 +1,54 @@
+# 日期/时间函数详解
+
+```sql
+-- AGE — 计算时间差
+SELECT AGE('2024-05-29', '2023-01-15');
+-- 结果: 1 year 4 mons 14 days
+
+-- 计算年龄
+SELECT id, EXTRACT(YEAR FROM AGE(birth_date)) AS age FROM users;
+
+-- DATE_TRUNC — 时间截断（支持: microsecond, millisecond, second, minute, hour, day, week, month, quarter, year, decade, century, millennium）
+SELECT DATE_TRUNC('month', created_at) AS month, COUNT(*) AS order_count
+FROM orders GROUP BY month;
+
+-- EXTRACT — 提取日期部分
+SELECT
+    EXTRACT(YEAR FROM created_at) AS year,
+    EXTRACT(MONTH FROM created_at) AS month,
+    EXTRACT(DOW FROM created_at) AS day_of_week,  -- 0=Sunday
+    EXTRACT(HOUR FROM created_at) AS hour,
+    EXTRACT(QUARTER FROM created_at) AS quarter
+FROM orders;
+
+-- TO_CHAR — 日期格式化
+SELECT
+    TO_CHAR(created_at, 'YYYY-MM-DD HH24:MI:SS') AS formatted_time,
+    TO_CHAR(created_at, 'YYYY年MM月DD日') AS chinese_date,
+    TO_CHAR(created_at, 'Day, DD Month YYYY') AS english_date,
+    TO_CHAR(created_at, 'IW') AS iso_week_number
+FROM orders;
+
+-- JUSTIFY_DAYS / JUSTIFY_HOURS / JUSTIFY_INTERVAL
+SELECT JUSTIFY_DAYS(30::INTERVAL);   -- 30 days → 1 mon
+SELECT JUSTIFY_HOURS(100::INTERVAL); -- 100:00:00 → 4 days 04:00:00
+
+-- MAKE_DATE / MAKE_TIMESTAMPTZ / MAKE_INTERVAL (PG 10+)
+SELECT MAKE_DATE(2024, 6, 1);
+SELECT MAKE_TIMESTAMPTZ(2024, 6, 1, 10, 30, 0, 'Asia/Shanghai');
+SELECT MAKE_INTERVAL(days => 10, hours => 5);
+
+-- DATE 运算
+SELECT NOW(), NOW() + INTERVAL '1 day', NOW() - INTERVAL '3 hours';
+SELECT CURRENT_DATE, CURRENT_TIME;
+
+-- 时区转换
+SELECT
+    NOW() AT TIME ZONE 'Asia/Shanghai',
+    NOW() AT TIME ZONE 'UTC',
+    '2024-06-01 10:00:00+08'::TIMESTAMPTZ AT TIME ZONE 'America/New_York';
+
+-- 日期范围查询最佳实践
+-- ❌ 避免: WHERE created_at BETWEEN '2024-01-01' AND '2024-01-31'
+-- ✅ 推荐: WHERE created_at >= '2024-01-01' AND created_at < '2024-02-01'
+```

package/skills/database/postgresql/references/03-functions-aggregate-window.md

@@ -0,0 +1,142 @@
+# 聚合/窗口函数详解
+
+## 聚合函数
+
+```sql
+-- ARRAY_AGG — 聚合为数组
+SELECT o.id, ARRAY_AGG(p.name ORDER BY p.name) AS products
+FROM orders o JOIN order_items oi ON oi.order_id = o.id
+JOIN products p ON p.id = oi.product_id GROUP BY o.id;
+
+-- STRING_AGG — 聚合为字符串
+SELECT article_id, STRING_AGG(DISTINCT tag, ', ' ORDER BY tag) AS tags
+FROM article_tags GROUP BY article_id;
+
+-- JSON_AGG / JSONB_AGG — 聚合为 JSON
+SELECT o.id, JSONB_AGG(JSONB_BUILD_OBJECT('product_id', oi.product_id, 'qty', oi.quantity)) AS items
+FROM orders o JOIN order_items oi ON oi.order_id = o.id GROUP BY o.id;
+
+-- MODE — 众数
+SELECT MODE() WITHIN GROUP (ORDER BY category_id) FROM products;
+
+-- PERCENTILE_CONT / PERCENTILE_DISC — 百分位数
+SELECT
+    PERCENTILE_CONT(0.5) WITHIN GROUP (ORDER BY total_amount) AS median,
+    PERCENTILE_CONT(0.25) WITHIN GROUP (ORDER BY total_amount) AS q1,
+    PERCENTILE_CONT(0.9) WITHIN GROUP (ORDER BY total_amount) AS p90
+FROM orders;
+
+-- GROUPING SETS / CUBE / ROLLUP
+SELECT COALESCE(department, 'ALL') AS dept, COALESCE(role, 'ALL') AS role,
+       COUNT(*) AS cnt, AVG(salary)::NUMERIC(10,2) AS avg_sal
+FROM employees
+GROUP BY GROUPING SETS ((department, role), (department), (role), ());
+
+SELECT category, brand, COUNT(*) FROM products GROUP BY CUBE (category, brand);
+
+SELECT EXTRACT(YEAR FROM created_at) AS year, EXTRACT(MONTH FROM created_at) AS month,
+       COUNT(*) FROM orders GROUP BY ROLLUP (year, month) ORDER BY year, month;
+```
+
+## 窗口函数
+
+```sql
+-- ROW_NUMBER — 行号
+SELECT id, name, category_id, price,
+       ROW_NUMBER() OVER (PARTITION BY category_id ORDER BY price DESC) AS rn
+FROM products;
+
+-- RANK / DENSE_RANK — 排名
+SELECT salesperson, amount,
+       RANK() OVER (ORDER BY amount DESC) AS rank,
+       DENSE_RANK() OVER (ORDER BY amount DESC) AS dense_rank
+FROM monthly_sales;
+
+-- NTILE — 分桶
+SELECT id, total_spent, NTILE(4) OVER (ORDER BY total_spent DESC) AS quartile
+FROM customers;
+
+-- LAG / LEAD — 前后行访问
+SELECT dt, revenue,
+       LAG(revenue, 1) OVER (ORDER BY dt) AS prev_day,
+       LAG(revenue, 7) OVER (ORDER BY dt) AS prev_week,
+       ROUND((revenue - LAG(revenue, 1) OVER (ORDER BY dt))
+             / NULLIF(LAG(revenue, 1) OVER (ORDER BY dt), 0) * 100, 2) AS dod_pct,
+       LEAD(revenue, 1) OVER (ORDER BY dt) AS next_day
+FROM daily_revenue;
+
+-- FIRST_VALUE / LAST_VALUE
+SELECT category_id, name, price,
+       FIRST_VALUE(price) OVER (PARTITION BY category_id ORDER BY price) AS min_price,
+       LAST_VALUE(price) OVER (PARTITION BY category_id ORDER BY price
+           RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) AS max_price
+FROM products;
+
+-- NTH_VALUE
+SELECT DISTINCT category_id,
+       NTH_VALUE(name, 3) OVER (PARTITION BY category_id ORDER BY price DESC
+           RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) AS third_expensive
+FROM products;
+
+-- 窗口帧控制
+SELECT dt, revenue,
+       AVG(revenue) OVER (ORDER BY dt ROWS BETWEEN 6 PRECEDING AND CURRENT ROW) AS ma_7d,
+       AVG(revenue) OVER (ORDER BY dt ROWS BETWEEN 29 PRECEDING AND CURRENT ROW) AS ma_30d
+FROM daily_revenue;
+
+-- 累积求和
+SELECT dt, revenue, SUM(revenue) OVER (ORDER BY dt) AS cumulative_revenue
+FROM daily_revenue;
+
+-- 分组累计
+SELECT category_id, dt, revenue,
+       SUM(revenue) OVER (PARTITION BY category_id ORDER BY dt ROWS UNBOUNDED PRECEDING) AS cum_by_cat
+FROM daily_revenue_by_category;
+
+-- 窗口函数 + FILTER 条件聚合
+SELECT dt,
+       COUNT(*) AS total,
+       COUNT(*) FILTER (WHERE status = 'paid') AS paid,
+       COUNT(*) FILTER (WHERE status = 'cancelled') AS cancelled
+FROM orders GROUP BY dt;
+```
+
+## 数组函数
+
+```sql
+-- ARRAY — 构建数组
+SELECT ARRAY[1, 2, 3], ARRAY['a', 'b', 'c'];
+
+-- ANY / ALL — 元素检查
+SELECT * FROM articles WHERE '数据库' = ANY(tags);
+
+-- UNNEST — 展开数组
+SELECT UNNEST(tags) AS tag, COUNT(*) AS freq
+FROM articles GROUP BY tag ORDER BY freq DESC;
+
+-- ARRAY_APPEND / ARRAY_PREPEND / ARRAY_REMOVE / ARRAY_CAT
+SELECT ARRAY_APPEND(ARRAY[1,2], 3);      -- {1,2,3}
+SELECT ARRAY_PREPEND(0, ARRAY[1,2]);      -- {0,1,2}
+SELECT ARRAY_REMOVE(ARRAY[1,2,3], 2);     -- {1,3}
+SELECT ARRAY_CAT(ARRAY[1,2], ARRAY[3,4]); -- {1,2,3,4}
+
+-- 数组信息
+SELECT ARRAY_NDIMS(ARRAY[[1,2],[3,4]]), ARRAY_LENGTH(ARRAY[1,2,3], 1);
+
+-- ARRAY_POSITION / ARRAY_POSITIONS
+SELECT ARRAY_POSITION(ARRAY['a','b','c','b'], 'b');    -- 2
+SELECT ARRAY_POSITIONS(ARRAY['a','b','c','b'], 'b');    -- {2,4}
+
+-- STRING_TO_ARRAY / ARRAY_TO_STRING
+SELECT STRING_TO_ARRAY('a,b,c', ','), ARRAY_TO_STRING(ARRAY['a','b','c'], '|');
+
+-- 数组切片
+SELECT tags[1:3] FROM articles;
+
+-- @> / <@ — 包含, && — 重叠
+SELECT * FROM articles WHERE tags @> ARRAY['SQL', '高级'];
+SELECT * FROM articles WHERE tags && ARRAY['数据库', 'JSON'];
+
+-- 数组 GIN 索引
+CREATE INDEX idx_articles_tags_gin ON articles USING GIN (tags);
+```