这是本节的多页打印视图。
点击此处打印.
返回本页常规视图.
扩展详情
每个 PostgreSQL 扩展的详细信息，可用性情况，下载链接，使用说明
Pigsty 中扩展的完整清单，请参考 扩展列表，RPM 包列表，DEB 包列表。
元数据说明
扩展（Extension, name）是 PostgreSQL 中的一个逻辑功能模块，名称与 pg_available_extensions 系统视图中的名称一致，是 PostgreSQL 世界里的唯一标识。
使用 CREATE EXTENSION <name> 来创建一个扩展，使用 DROP EXTENSION <name> 来删除一个扩展。
扩展包（Package, pkg）是包含一个或多个扩展的二进制软件包（RPM 或 DEB）。一个扩展包可能包含多个扩展，
例如 postgis 扩展包中包含了 postgis、postgis_topology、postgis_raster 等多个扩展。
扩展包的名称不一定与扩展名一致，例如扩展包 pgvector 对应的核心扩展名为 vector。
当一个扩展包中包含多个扩展时，会有一个首要扩展（Lead Extension, lead）作为该包的代表。
首要扩展通常是包中最核心的扩展，其他扩展被视为 “兄弟扩展”。
分类维度
扩展可以按照以下维度进行分类：
| 维度 | 说明 |
|---|
| 分类 | 按功能划分为 16 个预定义类目，见下方分类表 |
| 协议 | 按开源许可证分类：MIT、PostgreSQL、Apache-2.0、GPL 等 |
| 语言 | 按实现语言分类：C、C++、Rust、SQL、Python 等 |
| 仓库 | 按归属仓库分类：PGDG、PIGSTY、CONTRIB、MIXED |
属性标记
每个扩展都有 7 个布尔属性标记，在扩展列表中以 7 位字符串 cbsLdtr 的形式展示，每一位代表一个属性：
| 位 | 字符 | 列名 | 字段 | 全称 | 说明 |
|---|
| 1 | c | Contrib | contrib | 内核自带 | 是否为 PostgreSQL 内核自带的 contrib 扩展 |
| 2 | b | Bin | has_bin | 二进制 | 扩展包是否包含额外的可执行二进制文件/命令行工具 |
| 3 | s | Solib | has_lib | 共享库 | 扩展是否包含共享库文件（.so），即 C/Rust 编译产物 |
| 4 | L | Load | need_ddl | 显式加载 | 是否需要通过 shared_preload_libraries 预加载并重启 |
| 5 | d | DDL | need_load | 需要创建 | 是否需要执行 CREATE EXTENSION DDL 语句完成安装 |
| 6 | t | Trust | trusted | 信任扩展 | 是否为受信任的扩展，普通用户（非超级用户）可直接创建 |
| 7 | r | Reloc | relocatable | 可重定位 | 扩展是否可以被安装到指定的 Schema 中 |
当该属性为真时，显示对应字母；为假时，显示短横线 -。
例如 --sLd-r 表示该扩展包含共享库，需要预加载，需要创建，不受信任（需要超级用户来创建）但可重定位。
可用性状态
Pigsty 为每一个扩展都提供了 版本可用性矩阵，这是一个表格，行为操作系统（例如 el9.x86_64），列为 PG 大版本（18, 17, …）。
每一个单元格代表这个 Linux 操作系统与 PG 大版本组合下的扩展状态，包括：
- 版本：这个 OS/PG 组合下，该扩展的最新可用版本号，如果缺失则显示为
MISS。 - 仓库：上面的最新可用版本是来自哪个 仓库？可能是 PGDG/PIGSTY
- 状态：扩展的状态如下表所示，状态会使用徽章的颜色进行区分与标记：
| 状态 | 说明 |
|---|
| AVAIL | 可用（PGDG 仓库），显示该平台上可用的具体版本号 |
| AVAIL | 可用（PIGSTY 仓库），显示该平台上可用的具体版本号 |
| AVAIL | 可用（CONTRIB 内核自带），显示该平台上可用的具体版本号 |
| MISS | 缺失，该平台上没有可用的二进制包 |
| HIDE | 隐藏，该扩展已知不支持此 PG 版本（如版本范围限制） |
| THROW | 异常，该包存在但安装时会抛出错误 |
| BREAK | 损坏，该包存在但运行时可能导致问题 |
| FORK | 分支，需要使用特定的 PostgreSQL 内核分支版本 |
数据库模式
Pigsty 扩展目录的模式定义于 github.com/pgsty/pgext，数据位于 extension.csv 中。
Extension 表结构定义
CREATE TABLE IF NOT EXISTS pgext.extension
(
id INTEGER PRIMARY KEY, -- Unique extension identifier
name TEXT NOT NULL UNIQUE, -- Extension name as it appears in pg_extension
pkg TEXT NOT NULL, -- Normalized package name (may differ from extension name)
lead_ext TEXT, -- Leading/primary extension in multi-extension packages
category TEXT, -- Category classification (TIME, GIS, RAG, FTS, etc.)
state TEXT, -- Extension state: available, deprecated, removed, not-ready
url TEXT, -- Extension homepage or source repository URL
license TEXT, -- Software license (PostgreSQL, MIT, Apache-2.0, etc.)
tags TEXT[], -- Additional classification tags
version TEXT, -- Latest available version of this extension
repo TEXT, -- Source repository type (github, gitlab, etc.)
lang TEXT, -- Primary programming language (C, SQL, PLpgSQL, Rust, etc.)
contrib BOOLEAN, -- Whether this is a PostgreSQL contrib extension
lead BOOLEAN, -- Whether this is the lead extension in its package
has_bin BOOLEAN, -- Whether extension includes binary executables
has_lib BOOLEAN, -- Whether extension includes shared libraries (.so/.dll)
need_ddl BOOLEAN, -- Whether requires CREATE EXTENSION DDL to install
need_load BOOLEAN, -- Whether requires LOAD or shared_preload_libraries
trusted BOOLEAN, -- Whether non-superuser can install (trusted extension)
relocatable BOOLEAN, -- Whether extension can be relocated to different schema
schemas TEXT[], -- Fixed schema names if not relocatable
pg_ver TEXT[], -- Supported PostgreSQL major versions
requires TEXT[], -- Extension dependencies (other extensions required)
require_by TEXT[], -- Extensions that depend on this extension
see_also TEXT[], -- Related or similar extensions
rpm_ver TEXT, -- Latest RPM package version
rpm_repo TEXT, -- RPM repository source (PGDG, PIGSTY, etc.)
rpm_pkg TEXT, -- RPM package name template ($v for PG version)
rpm_pg TEXT[], -- PostgreSQL versions available in RPM
rpm_deps TEXT[], -- RPM package dependencies
deb_ver TEXT, -- Latest DEB package version
deb_repo TEXT, -- DEB repository source (PGDG, PIGSTY, etc.)
deb_pkg TEXT, -- DEB package name template ($v for PG version)
deb_deps TEXT[], -- DEB package dependencies
deb_pg TEXT[], -- PostgreSQL versions available in DEB
source TEXT, -- Source tarball name if built by Pigsty
extra JSONB, -- Additional metadata in JSONB format
en_desc TEXT, -- English description of extension functionality
zh_desc TEXT, -- Chinese description of extension functionality
comment TEXT, -- Additional notes or special instructions
mtime DATE DEFAULT CURRENT_DATE -- Last modification date of this record
);
CREATE INDEX IF NOT EXISTS ext_name_pkg_idx ON pgext.extension (name, pkg);
COMMENT ON TABLE pgext.extension IS 'PostgreSQL Extension Central Catalog Table';
COMMENT ON COLUMN pgext.extension.id IS 'Unique integer identifier for each extension';
COMMENT ON COLUMN pgext.extension.name IS 'Extension name as it appears in PostgreSQL system catalog (pg_extension)';
COMMENT ON COLUMN pgext.extension.pkg IS 'Normalized package name used for package management (may differ from extension name)';
COMMENT ON COLUMN pgext.extension.lead_ext IS 'Primary/leading extension name in multi-extension packages';
COMMENT ON COLUMN pgext.extension.category IS 'Functional category: TIME, GIS, RAG, FTS, OLAP, FEAT, LANG, TYPE, UTIL, FUNC, ADMIN, STAT, SEC, FDW, SIM, ETL';
COMMENT ON COLUMN pgext.extension.state IS 'Extension lifecycle state: available, deprecated, removed, not-ready';
COMMENT ON COLUMN pgext.extension.url IS 'Extension homepage or source code repository URL (GitHub, GitLab, etc.)';
COMMENT ON COLUMN pgext.extension.license IS 'Software license (e.g., PostgreSQL, MIT, Apache-2.0, GPL, BSD)';
COMMENT ON COLUMN pgext.extension.tags IS 'Additional classification tags as string array for flexible categorization';
COMMENT ON COLUMN pgext.extension.version IS 'Latest available version of this extension';
COMMENT ON COLUMN pgext.extension.repo IS 'Source repository hosting platform (github, gitlab, bitbucket, etc.)';
COMMENT ON COLUMN pgext.extension.lang IS 'Primary implementation language (C, SQL, PLpgSQL, Rust, Go, Python, etc.)';
COMMENT ON COLUMN pgext.extension.contrib IS 'Whether this is an official PostgreSQL contrib extension';
COMMENT ON COLUMN pgext.extension.lead IS 'Whether this is the primary/lead extension in a multi-extension package';
COMMENT ON COLUMN pgext.extension.has_bin IS 'Whether the extension package includes binary executables/utilities';
COMMENT ON COLUMN pgext.extension.has_lib IS 'Whether the extension includes shared library files (.so on Linux, .dll on Windows)';
COMMENT ON COLUMN pgext.extension.need_ddl IS 'Whether extension requires CREATE EXTENSION DDL command to install';
COMMENT ON COLUMN pgext.extension.need_load IS 'Whether requires explicit LOAD or shared_preload_libraries configuration';
COMMENT ON COLUMN pgext.extension.trusted IS 'Whether non-superuser can install this extension (trusted extension feature)';
COMMENT ON COLUMN pgext.extension.relocatable IS 'Whether extension can be relocated to a different schema after installation';
COMMENT ON COLUMN pgext.extension.schemas IS 'Fixed schema names if extension is not relocatable (must be installed in specific schema)';
COMMENT ON COLUMN pgext.extension.pg_ver IS 'Array of supported PostgreSQL major versions (e.g., {14,15,16,17,18})';
COMMENT ON COLUMN pgext.extension.requires IS 'Array of extension dependencies (other extensions that must be installed first)';
COMMENT ON COLUMN pgext.extension.require_by IS 'Array of extensions that depend on this extension (reverse dependency list)';
COMMENT ON COLUMN pgext.extension.see_also IS 'Array of related or similar extensions (for discovery and comparison)';
COMMENT ON COLUMN pgext.extension.rpm_ver IS 'Latest available RPM package version';
COMMENT ON COLUMN pgext.extension.rpm_repo IS 'RPM repository source (PGDG, PIGSTY, EPEL, etc.)';
COMMENT ON COLUMN pgext.extension.rpm_pkg IS 'RPM package name template where $v is replaced with PostgreSQL major version';
COMMENT ON COLUMN pgext.extension.rpm_pg IS 'Array of PostgreSQL versions available as RPM packages';
COMMENT ON COLUMN pgext.extension.rpm_deps IS 'Array of RPM package dependencies (system libraries and other packages)';
COMMENT ON COLUMN pgext.extension.deb_ver IS 'Latest available DEB package version';
COMMENT ON COLUMN pgext.extension.deb_repo IS 'DEB repository source (PGDG, PIGSTY, etc.)';
COMMENT ON COLUMN pgext.extension.deb_pkg IS 'DEB package name template where $v is replaced with PostgreSQL major version';
COMMENT ON COLUMN pgext.extension.deb_deps IS 'Array of DEB package dependencies (system libraries and other packages)';
COMMENT ON COLUMN pgext.extension.deb_pg IS 'Array of PostgreSQL versions available as DEB packages';
COMMENT ON COLUMN pgext.extension.source IS 'Source code tarball filename if built and distributed by Pigsty';
COMMENT ON COLUMN pgext.extension.extra IS 'Additional extension metadata stored as JSONB for extensibility';
COMMENT ON COLUMN pgext.extension.en_desc IS 'English description of extension functionality and purpose';
COMMENT ON COLUMN pgext.extension.zh_desc IS 'Chinese description of extension functionality and purpose';
COMMENT ON COLUMN pgext.extension.comment IS 'Additional notes, special instructions, or warnings';
COMMENT ON COLUMN pgext.extension.mtime IS 'Last modification timestamp of this record';
1 - timescaledb
时序数据库扩展插件
概览
| ID | 扩展名 | Bin | Lib | Load | Create | Trust | Reloc | 模式 |
|---|
| 1000 | timescaledb | 否 | 是 | 是 | 是 | 是 | 否 | timescaledb_information |
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PIGSTY | 2.26.3 | 1817161514 | timescaledb | - |
| RPM | PIGSTY | 2.26.3 | 1817161514 | timescaledb-tsl_$v | - |
| DEB | PIGSTY | 2.26.3 | 1817161514 | postgresql-$v-timescaledb-tsl | - |
构建
您可以使用 pig build 命令构建 timescaledb 扩展的 RPM / DEB 包：
pig build pkg timescaledb # 构建 RPM / DEB 包
安装
您可以直接安装 timescaledb 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install timescaledb; # 当前活跃 PG 版本安装
pig ext install -y timescaledb -v 18 # PG 18
pig ext install -y timescaledb -v 17 # PG 17
pig ext install -y timescaledb -v 16 # PG 16
pig ext install -y timescaledb -v 15 # PG 15
dnf install -y timescaledb-tsl_18 # PG 18
dnf install -y timescaledb-tsl_17 # PG 17
dnf install -y timescaledb-tsl_16 # PG 16
dnf install -y timescaledb-tsl_15 # PG 15
apt install -y postgresql-18-timescaledb-tsl # PG 18
apt install -y postgresql-17-timescaledb-tsl # PG 17
apt install -y postgresql-16-timescaledb-tsl # PG 16
apt install -y postgresql-15-timescaledb-tsl # PG 15
预加载配置：
shared_preload_libraries = 'timescaledb';
创建扩展：
CREATE EXTENSION timescaledb;
用法
创建一张表并将其转换为超表（hypertable）
DROP TABLE IF EXISTS ts_test;
CREATE TABLE ts_test
(
ts TIMESTAMPTZ NOT NULL,
id BIGINT,
v INTEGER -- 载荷数据
);
SELECT create_hypertable('ts_test', by_range('ts'));
INSERT INTO ts_test
SELECT now() + (i || ' seconds')::INTERVAL, i, i % 100
FROM generate_series(1, 1000000) i;
连续聚合示例：
CREATE MATERIALIZED VIEW ts_hourly
WITH (timescaledb.continuous) AS
SELECT time_bucket('1 hour', ts) AS bucket,
count(*) AS cnt,
avg(v) AS avg_v
FROM ts_test
GROUP BY bucket;
-- 添加刷新策略以保持连续聚合的数据是最新的
SELECT add_continuous_aggregate_policy('ts_hourly',
start_offset => INTERVAL '3 hours',
end_offset => INTERVAL '1 hour',
schedule_interval => INTERVAL '1 hour');
任务调度示例：
SELECT add_job('SELECT 1','1h', initial_start => now()::timestamptz);
压缩示例：
ALTER TABLE ts_test SET (
timescaledb.compress,
timescaledb.compress_segmentby = 'id',
timescaledb.compress_orderby = 'ts'
);
-- 添加压缩策略，自动压缩超过 1 天的数据块
SELECT add_compression_policy('ts_test', INTERVAL '1 day');
2 - timescaledb_toolkit
超表分析查询，时间序列流式处理，以及其他SQL工具
概览
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PIGSTY | 1.22.0 | 1817161514 | timescaledb_toolkit | - |
| RPM | PIGSTY | 1.22.0 | 1817161514 | timescaledb-toolkit_$v | - |
| DEB | PIGSTY | 1.22.0 | 1817161514 | postgresql-$v-timescaledb-toolkit | - |
构建
您可以使用 pig build 命令构建 timescaledb_toolkit 扩展的 RPM / DEB 包：
pig build pkg timescaledb_toolkit # 构建 RPM / DEB 包
安装
您可以直接安装 timescaledb_toolkit 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install timescaledb_toolkit; # 当前活跃 PG 版本安装
pig ext install -y timescaledb_toolkit -v 18 # PG 18
pig ext install -y timescaledb_toolkit -v 17 # PG 17
pig ext install -y timescaledb_toolkit -v 16 # PG 16
pig ext install -y timescaledb_toolkit -v 15 # PG 15
dnf install -y timescaledb-toolkit_18 # PG 18
dnf install -y timescaledb-toolkit_17 # PG 17
dnf install -y timescaledb-toolkit_16 # PG 16
dnf install -y timescaledb-toolkit_15 # PG 15
apt install -y postgresql-18-timescaledb-toolkit # PG 18
apt install -y postgresql-17-timescaledb-toolkit # PG 17
apt install -y postgresql-16-timescaledb-toolkit # PG 16
apt install -y postgresql-15-timescaledb-toolkit # PG 15
创建扩展：
CREATE EXTENSION timescaledb_toolkit;
用法
TimescaleDB Toolkit 提供了一系列专用于时序数据分析的函数，采用两步聚合模式。大多数函数会先创建中间表示，再通过访问器函数进行查询，从而实现高效复用和多维分析。
近似分析
HyperLogLog - 基数估算
基于概率的去重计数，支持可配置精度，适用于高基数数据集。
-- 估算每日独立用户数
SELECT
date_trunc('day', timestamp) as day,
distinct_count(hyperloglog(64, user_id)) as unique_users
FROM events
GROUP BY day;
-- 跨分区合并计数
SELECT distinct_count(rollup(hll))
FROM (SELECT hyperloglog(32, session_id) as hll FROM events_2023
UNION ALL
SELECT hyperloglog(32, session_id) FROM events_2024) t;
T-Digest - 分位数近似
高精度百分位估算，针对尾部分位数（P95、P99）进行了优化。
-- 追踪响应时间百分位
SELECT
service_name,
approx_percentile(0.50, tdigest(100, response_time)) as p50,
approx_percentile(0.95, tdigest(100, response_time)) as p95,
approx_percentile(0.99, tdigest(100, response_time)) as p99
FROM api_metrics
GROUP BY service_name;
-- 结合连续聚合计算每小时百分位
CREATE MATERIALIZED VIEW hourly_percentiles AS
SELECT
time_bucket('1 hour', timestamp) as hour,
tdigest(200, response_time) as digest
FROM requests GROUP BY hour;
UddSketch - 有界误差分位数
带有最大相对误差保证的分位数估算。
-- 计算 CPU 利用率百分位，最大误差 1%
SELECT
host_id,
approx_percentile(0.95, uddsketch(100, 0.01, cpu_percent)) as p95_cpu,
error(uddsketch(100, 0.01, cpu_percent)) as actual_error
FROM system_metrics
GROUP BY host_id;
计数器分析
计数器聚合 - 单调递增指标
处理单调递增的计数器，自动检测重置。
-- 计算请求速率
SELECT
time_bucket('5 min', timestamp) as bucket,
rate(counter_agg(timestamp, request_count)) as requests_per_sec,
delta(counter_agg(timestamp, request_count)) as total_requests
FROM metrics
GROUP BY bucket;
-- 对不完整时间桶进行外推速率计算
SELECT
extrapolated_rate(
counter_agg(timestamp, bytes_sent,
bounds => time_bucket_range('1 hour', timestamp))
) as bytes_per_second
FROM network_stats;
仪表聚合 - 波动指标
用于分析上下波动的指标（如温度、内存使用量）。
-- 温度变化分析
SELECT
sensor_id,
delta(gauge_agg(timestamp, temperature)) as temp_delta,
rate(gauge_agg(timestamp, temperature)) as temp_rate_per_sec
FROM weather_data
GROUP BY sensor_id;
时间加权分析
时间加权平均
处理不规则采样数据，支持插值方法（LOCF 末次观测值保持、Linear 线性插值）。
-- 对不规则传感器读数计算加权平均
SELECT
device_id,
average(time_weight('LOCF', timestamp, sensor_value)) as weighted_avg,
average(time_weight('Linear', timestamp, sensor_value)) as linear_avg
FROM iot_readings
GROUP BY device_id;
-- 合并多个时间范围
SELECT average(rollup(tw))
FROM (SELECT time_weight('LOCF', ts, val) as tw FROM readings_2023
UNION ALL
SELECT time_weight('LOCF', ts, val) FROM readings_2024) t;
数据可视化
LTTB 降采样
在保持视觉相似性的前提下对时序数据进行降采样，适用于图表展示。
-- 将 10 万个数据点降采样为 1000 个用于可视化
SELECT time, value
FROM unnest((
SELECT lttb(timestamp, price, 1000)
FROM stock_prices
WHERE symbol = 'AAPL'
));
ASAP 平滑
通过降噪生成易于阅读的图表，同时保留趋势特征。
-- 将每日数据平滑为周粒度
SELECT time, value
FROM unnest((
SELECT asap_smooth(date, daily_sales, 52)
FROM sales_data
WHERE date >= '2023-01-01'
));
统计分析
统计聚合
提供全面的统计分析能力，支持一维和二维回归分析。
-- 多变量分析
SELECT
-- 基础统计量
average(stats_agg(response_time)) as avg_response,
stddev(stats_agg(response_time)) as response_stddev,
-- 回归分析
slope(stats_agg(response_time, request_size)) as size_impact,
corr(stats_agg(response_time, request_size)) as correlation,
determination_coeff(stats_agg(response_time, request_size)) as r_squared
FROM performance_data;
Timevector 数据类型
用于时序操作的高效中间表示。
-- 创建和操作 timevector
CREATE VIEW cpu_series AS
SELECT host_id, timevector(timestamp, cpu_percent) as ts
FROM system_metrics GROUP BY host_id;
-- 对 timevector 进行链式操作
SELECT host_id, unnest(lttb(ts, 100))
FROM cpu_series;
集成模式
连续聚合支持
大多数 Toolkit 函数可与 TimescaleDB 连续聚合无缝配合使用：
CREATE MATERIALIZED VIEW hourly_analytics AS
SELECT
time_bucket('1 hour', timestamp) as hour,
service_name,
tdigest(100, response_time) as response_digest,
counter_agg(timestamp, request_count) as request_counter,
hyperloglog(64, user_id) as unique_users
FROM api_events
GROUP BY hour, service_name;
-- 查询预计算的聚合结果
SELECT
hour,
approx_percentile(0.95, response_digest) as p95_response,
rate(request_counter) as req_per_sec,
distinct_count(unique_users) as unique_users
FROM hourly_analytics
WHERE hour >= NOW() - INTERVAL '24 hours';
两步分析模式
存储中间聚合结果，支持多维度分析复用：
-- 第一步：创建聚合
CREATE TABLE daily_summaries AS
SELECT
date_trunc('day', timestamp) as day,
tdigest(200, response_time) as response_digest,
stats_agg(response_time, request_size) as stats
FROM requests GROUP BY day;
-- 第二步：基于同一份数据进行多维分析
SELECT
day,
approx_percentile(0.50, response_digest) as median,
approx_percentile(0.99, response_digest) as p99,
average(stats) as avg_response,
slope(stats) as size_correlation
FROM daily_summaries;
所有位于 experimental 模式（toolkit_experimental）中的函数可能会在版本间发生变化。生产环境中如需 API 稳定性保证，请使用稳定版函数。
3 - timeseries
时序数据API封装
概览
| ID | 扩展名 | Bin | Lib | Load | Create | Trust | Reloc | 模式 |
|---|
| 1020 | timeseries | 否 | 否 | 否 | 是 | 否 | 否 | - |
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PIGSTY | 0.2.0 | 1817161514 | pg_timeseries | pg_cron, pg_partman |
| RPM | PIGSTY | 0.2.0 | 1817161514 | pg_timeseries_$v | pg_cron_$v, pg_partman_$v |
| DEB | PIGSTY | 0.2.0 | 1817161514 | postgresql-$v-pg-timeseries | postgresql-$v-cron, postgresql-$v-partman |
构建
您可以使用 pig build 命令构建 pg_timeseries 扩展的 RPM / DEB 包：
pig build pkg pg_timeseries # 构建 RPM / DEB 包
安装
您可以直接安装 pg_timeseries 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install pg_timeseries; # 当前活跃 PG 版本安装
pig ext install -y pg_timeseries -v 18 # PG 18
pig ext install -y pg_timeseries -v 17 # PG 17
pig ext install -y pg_timeseries -v 16 # PG 16
pig ext install -y pg_timeseries -v 15 # PG 15
pig ext install -y pg_timeseries -v 14 # PG 14
dnf install -y pg_timeseries_18 # PG 18
dnf install -y pg_timeseries_17 # PG 17
dnf install -y pg_timeseries_16 # PG 16
dnf install -y pg_timeseries_15 # PG 15
dnf install -y pg_timeseries_14 # PG 14
apt install -y postgresql-18-pg-timeseries # PG 18
apt install -y postgresql-17-pg-timeseries # PG 17
apt install -y postgresql-16-pg-timeseries # PG 16
apt install -y postgresql-15-pg-timeseries # PG 15
apt install -y postgresql-14-pg-timeseries # PG 14
创建扩展：
CREATE EXTENSION timeseries CASCADE; -- 依赖: pg_cron, pg_partman
用法
pg_timeseries: 时间序列便捷 API
本扩展为时间序列表的创建、维护和使用提供了一致的用户体验。
快速开始
假设你已经有一张分区表，只需调用 enable_ts_table 函数即可启用时间序列功能：
CREATE EXTENSION timeseries CASCADE;
SELECT enable_ts_table('sensor_readings');
这一调用会自动完成以下操作：
- 使用 PostgreSQL 原生分区功能将表重构为一系列分区
- 每个分区覆盖一段时间范围（默认一周）
- 自动为未来创建新分区（默认提前一个月）
- 每小时运行一次维护任务，创建缺失的分区和未来所需的分区
使用表
索引
时间序列表本质上就是标准的 PostgreSQL 分区表，所有 PostgreSQL 的现有功能都能正常使用。
传统 B-Tree 索引适用于时间序列数据，但在某些查询场景下（通常是返回大量结果的查询），BRIN 索引可能表现更优。如果每个分区不超过一百万条记录，建议先用 B-Tree。
分区大小
扩展提供了 ts_part_info 视图，可方便查看各分区的数据大小、索引大小和总大小。一般建议每个分区能容纳在可用内存的约四分之一以内。
数据保留
调用 set_ts_retention_policy 设置保留策略，超出保留窗口的分区每小时会被自动删除。使用 clear_ts_retention_policy 恢复默认行为（无限保留）。
压缩
调用 set_ts_compression_policy 可对超过指定时间间隔的分区使用列式存储进行压缩。压缩功能依赖 citus 和 citus_columnar 扩展：
CREATE EXTENSION citus;
CREATE EXTENSION citus_columnar;
分析辅助函数
first 和 last
按一个维度分组，但按另一个维度取首条/末条记录：
SELECT machine_id,
last(cpu_util, recorded_at)
FROM events
GROUP BY machine_id;
date_bin_table
自动将时间序列值对齐到指定步长，并为无数据的时间段补充 NULL 行：
SELECT * FROM date_bin_table(NULL::target_table, '1 hour', '[2024-02-01 00:00, 2024-02-02 15:00]');
输出结果与直接查表相比有三点不同：
- 按时间升序排列
- 时间列的值对齐到指定步长
- 无数据的时间段会补充 NULL 行
make_view_incremental
将普通视图转换为自动保持更新的增量物化视图，无需手动 REFRESH。该功能基于 pg_ivm 实现：
依赖
可选依赖
4 - periods
为 PERIODs 和 SYSTEM VERSIONING 提供标准 SQL 功能
概览
| ID | 扩展名 | Bin | Lib | Load | Create | Trust | Reloc | 模式 |
|---|
| 1030 | periods | 否 | 是 | 否 | 是 | 否 | 否 | - |
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PIGSTY | 1.2.3 | 1817161514 | periods | btree_gist |
| RPM | PGDG | 1.2.3 | 1817161514 | periods_$v | - |
| DEB | PGDG | 1.2.3 | 1817161514 | postgresql-$v-periods | - |
构建
您可以使用 pig build 命令构建 periods 扩展的 RPM 包：
pig build pkg periods # 构建 RPM 包
安装
您可以直接安装 periods 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install periods; # 当前活跃 PG 版本安装
pig ext install -y periods -v 18 # PG 18
pig ext install -y periods -v 17 # PG 17
pig ext install -y periods -v 16 # PG 16
pig ext install -y periods -v 15 # PG 15
pig ext install -y periods -v 14 # PG 14
dnf install -y periods_18 # PG 18
dnf install -y periods_17 # PG 17
dnf install -y periods_16 # PG 16
dnf install -y periods_15 # PG 15
dnf install -y periods_14 # PG 14
apt install -y postgresql-18-periods # PG 18
apt install -y postgresql-17-periods # PG 17
apt install -y postgresql-16-periods # PG 16
apt install -y postgresql-15-periods # PG 15
apt install -y postgresql-14-periods # PG 14
创建扩展：
CREATE EXTENSION periods CASCADE; -- 依赖: btree_gist
用法
periods: PostgreSQL 的时间段与系统版本控制
本扩展实现了 SQL:2016 标准（最初于 SQL:2011 引入）中关于时间段（Period）和 SYSTEM VERSIONING 系统版本控制的行为。
什么是时间段？
时间段是表上的一个定义，指定一个名称和两个列。时间段的值包含起始值，但不包含结束值。
-- 标准 SQL 语法
CREATE TABLE example (
id bigint,
start_date date,
end_date date,
PERIOD FOR validity (start_date, end_date)
);
由于扩展无法修改 PostgreSQL 的语法，我们通过函数、视图和触发器来尽可能模拟相同的行为：
CREATE TABLE example (
id bigint,
start_date date,
end_date date
);
SELECT periods.add_period('example', 'validity', 'start_date', 'end_date');
定义时间段后，会约束两列：起始值必须严格小于结束值，且两列均不能为空。
唯一约束
时间段可以作为 PRIMARY KEY 和 UNIQUE 约束的一部分：
CREATE TABLE example (
id bigint,
start_date date,
end_date date
);
SELECT periods.add_period('example', 'validity', 'start_date', 'end_date');
SELECT periods.add_unique_key('example', ARRAY['id'], 'validity');
扩展会创建一个覆盖所有指定列和时间段两列的唯一约束，并通过 GiST 排他约束实现 WITHOUT OVERLAPS 语义。
外键
有了带时间段的唯一键，就可以创建指向它们的外键：
SELECT periods.add_foreign_key('example2', 'ARRAY[ex_id]', 'validity', 'example_id_validity');
部分操作
SQL 标准允许对时间段的一部分进行更新或删除，扩展通过 INSTEAD OF 触发器的视图来实现：
UPDATE example__for_portion_of_validity
SET ...,
start_date = ...,
end_date = ...
WHERE ...;
使用此功能前，表必须有主键。
谓词函数
SQL 标准定义了多种时间段谓词，以内联函数形式实现：
-- "t" 和 "u" 是具有时间段 "p" 和 "q" 的表
-- 两个时间段的底层列为 "s" 和 "e"
WHERE periods.contains(t.s, t.e, 42) -- t.p CONTAINS 42
WHERE periods.contains(t.s, t.e, u.s, u.e) -- t.p CONTAINS u.q
WHERE periods.equals(t.s, t.e, u.s, u.e) -- t.p EQUALS u.q
WHERE periods.overlaps(t.s, t.e, u.s, u.e) -- t.p OVERLAPS u.q
WHERE periods.precedes(t.s, t.e, u.s, u.e) -- t.p PRECEDES u.q
WHERE periods.succeeds(t.s, t.e, u.s, u.e) -- t.p SUCCEEDS u.q
WHERE periods.immediately_precedes(t.s, t.e, u.s, u.e) -- t.p IMMEDIATELY PRECEDES u.q
WHERE periods.immediately_succeeds(t.s, t.e, u.s, u.e) -- t.p IMMEDIATELY SUCCEEDS u.q
系统版本控制表
SYSTEM_TIME
如果时间段名为 SYSTEM_TIME，则适用特殊规则。列类型必须是 date、timestamp without time zone 或 timestamp with time zone，且用户不可修改。扩展使用触发器将起始列设为 transaction_timestamp()，结束列始终为 'infinity'。
注意： 一般建议使用 timestamp with time zone，因为时区配置参数或夏令时变更可能导致历史记录失真。
CREATE TABLE example (
id bigint PRIMARY KEY,
value text
);
SELECT periods.add_system_time_period('example', 'row_start', 'row_end');
这些列无需预先存在——扩展会自动创建。
排除列
可以阻止某些列的更新触发 SYSTEM_TIME 值变化：
SELECT periods.add_system_time_period(
'example',
excluded_column_names => ARRAY['foo', 'bar']);
启用系统版本控制
SELECT periods.add_system_time_period('example', 'row_start', 'row_end');
SELECT periods.add_system_versioning('example');
系统会将所有变更记录到一张独立的历史表中。你也可以自行创建历史表（例如添加分区）并指定扩展使用它。
时态查询
SQL 标准扩展了 FROM 和 JOIN 子句以支持时间点或时间范围查询，扩展通过内联函数实现：
SELECT * FROM t__as_of('...'); -- FOR system_time AS OF '...'
SELECT * FROM t__from_to('...', '...'); -- FOR system_time FROM '...' TO '...'
SELECT * FROM t__between('...', '...'); -- FOR system_time BETWEEN '...' AND '...'
SELECT * FROM t__between_symmetric('...', '...'); -- FOR system_time BETWEEN SYMMETRIC '...' AND '...'
访问控制
历史表及辅助函数遵循基表的所有权和访问权限。历史数据为只读。如需清理旧数据，必须先暂停系统版本控制：
BEGIN;
SELECT periods.drop_system_versioning('t');
GRANT DELETE ON TABLE t TO CURRENT_USER;
DELETE FROM t_history WHERE system_time_end < now() - interval '1 year';
SELECT periods.add_system_versioning('t');
COMMIT;
5 - temporal_tables
时态表功能支持
概览
no pg17 on el8/9 pgdg repo
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PIGSTY | 1.2.2 | 1817161514 | temporal_tables | - |
| RPM | PIGSTY | 1.2.2 | 1817161514 | temporal_tables_$v | - |
| DEB | PIGSTY | 1.2.2 | 1817161514 | postgresql-$v-temporal-tables | - |
构建
您可以使用 pig build 命令构建 temporal_tables 扩展的 RPM / DEB 包：
pig build pkg temporal_tables # 构建 RPM / DEB 包
安装
您可以直接安装 temporal_tables 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install temporal_tables; # 当前活跃 PG 版本安装
pig ext install -y temporal_tables -v 18 # PG 18
pig ext install -y temporal_tables -v 17 # PG 17
pig ext install -y temporal_tables -v 16 # PG 16
pig ext install -y temporal_tables -v 15 # PG 15
pig ext install -y temporal_tables -v 14 # PG 14
dnf install -y temporal_tables_18 # PG 18
dnf install -y temporal_tables_17 # PG 17
dnf install -y temporal_tables_16 # PG 16
dnf install -y temporal_tables_15 # PG 15
dnf install -y temporal_tables_14 # PG 14
apt install -y postgresql-18-temporal-tables # PG 18
apt install -y postgresql-17-temporal-tables # PG 17
apt install -y postgresql-16-temporal-tables # PG 16
apt install -y postgresql-15-temporal-tables # PG 15
apt install -y postgresql-14-temporal-tables # PG 14
创建扩展：
CREATE EXTENSION temporal_tables;
用法
temporal_tables: PostgreSQL 系统时段时态表
时态表（temporal table）是一种记录行有效时间段的表。系统时段（system period）是由系统自动维护的列（或列对），包含该行在数据库层面有效的时间范围。当你向这样的表中插入行时，系统会自动生成时段的起止值。当你更新或删除系统时段时态表中的行时，旧版本会自动归档到另一张表——即历史表（history table）。
更多用法可参考这篇优秀教程。
创建系统时段时态表
该扩展使用一个通用触发器函数来维护系统时段时态表的行为：
versioning(<system_period_column_name>, <history_table_name>, <adjust>)
首先，创建一张表并添加系统时段列：
CREATE TABLE employees (
name text NOT NULL PRIMARY KEY,
department text,
salary numeric(20, 2)
);
ALTER TABLE employees ADD COLUMN sys_period tstzrange NOT NULL;
然后创建历史表：
CREATE TABLE employees_history (LIKE employees);
历史表必须包含与原表同名、同类型的系统时段列。如果两张表都包含某列，则数据类型必须相同。
最后，创建触发器将其与历史表关联：
CREATE TRIGGER versioning_trigger
BEFORE INSERT OR UPDATE OR DELETE ON employees
FOR EACH ROW EXECUTE PROCEDURE versioning('sys_period',
'employees_history',
true);
插入数据
向系统时段时态表插入数据与普通表类似：
INSERT INTO employees (name, department, salary)
VALUES ('Bernard Marx', 'Hatchery and Conditioning Centre', 10000);
INSERT INTO employees (name, department, salary)
VALUES ('Lenina Crowne', 'Hatchery and Conditioning Centre', 7000);
sys_period 列的起始值表示该行何时变为当前版本，由 CURRENT_TIMESTAMP 自动生成。
更新数据
当用户更新行时，触发器会将旧行的副本插入历史表。如果单个事务内对同一行进行了多次更新，只会生成一条历史记录：
UPDATE employees SET salary = 11200 WHERE name = 'Bernard Marx';
此时历史表包含之前的版本：
| name | department | salary | sys_period |
|---|
| Bernard Marx | Hatchery and Conditioning Centre | 10000 | [2006-08-08, 2007-02-27) |
更新冲突与时间调整
当多个事务更新同一行时，可能会发生更新冲突。当 adjust 参数设为 true 时，sys_period 的起始值会通过加上一个微小的时间增量（通常为 1 微秒）来避免冲突，否则会抛出 SQLSTATE 22000 错误。
删除数据
当用户删除数据时，触发器同样会将行添加到历史表：
DELETE FROM employees WHERE name = 'Helmholtz Watson';
高级用法
你可以为版本控制触发器设置自定义系统时间，这在从已记录时间戳的系统构建数据仓库时非常有用：
SELECT set_system_time('1985-08-08 06:42:00+08');
恢复默认行为：
SELECT set_system_time(NULL);
如果在随后被中止的事务中执行，所有更改都会撤销。如果已提交，更改将持续到会话结束。
示例与技巧
使用继承创建历史表
CREATE TABLE employees_history (
name text NOT NULL,
department text,
salary numeric(20, 2),
sys_period tstzrange NOT NULL
);
CREATE TABLE employees (PRIMARY KEY(name)) INHERITS (employees_history);
历史表清理
历史表会持续增长。以下是几种清理策略：
- 定期删除历史表中的旧数据。
- 使用分区，并将旧分区从历史表中分离。
- 仅保留每行的最近 N 个版本。
- 当时态表中的对应行被删除时，同步清理历史记录。
- 按业务规则清理符合条件的行。
你也可以将历史表设置到另一个表空间，将其迁移到更廉价的存储上。
数据审计
你可以添加触发器来记录修改或删除当前行的用户：
CREATE FUNCTION employees_modify()
RETURNS TRIGGER AS $$
BEGIN
NEW.user_modified = SESSION_USER;
RETURN NEW;
END;
$$ LANGUAGE plpgsql;
CREATE TRIGGER employees_modify
BEFORE INSERT OR UPDATE ON employees
FOR EACH ROW EXECUTE PROCEDURE employees_modify();
CREATE FUNCTION employees_delete()
RETURNS TRIGGER AS $$
BEGIN
NEW.user_deleted = SESSION_USER;
RETURN NEW;
END;
$$ LANGUAGE plpgsql;
CREATE TRIGGER employees_delete
BEFORE INSERT ON employees_history
FOR EACH ROW EXECUTE PROCEDURE employees_delete();
6 - emaj
让数据库的子集具有细粒度日志和时间旅行功能
概览
| ID | 扩展名 | Bin | Lib | Load | Create | Trust | Reloc | 模式 |
|---|
| 1050 | emaj | 否 | 是 | 否 | 是 | 否 | 否 | emaj |
max_prepared_transactions
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | MIXED | 4.7.1 | 1817161514 | emaj | dblink, btree_gist |
| RPM | PGDG | 4.7.1 | 1817161514 | e-maj_$v | - |
| DEB | PIGSTY | 4.7.1 | 1817161514 | postgresql-$v-emaj | - |
构建
您可以使用 pig build 命令构建 emaj 扩展的 DEB 包：
pig build pkg emaj # 构建 DEB 包
安装
您可以直接安装 emaj 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install emaj; # 当前活跃 PG 版本安装
pig ext install -y emaj -v 18 # PG 18
pig ext install -y emaj -v 17 # PG 17
pig ext install -y emaj -v 16 # PG 16
pig ext install -y emaj -v 15 # PG 15
pig ext install -y emaj -v 14 # PG 14
dnf install -y e-maj_18 # PG 18
dnf install -y e-maj_17 # PG 17
dnf install -y e-maj_16 # PG 16
dnf install -y e-maj_15 # PG 15
dnf install -y e-maj_14 # PG 14
apt install -y postgresql-18-emaj # PG 18
apt install -y postgresql-17-emaj # PG 17
apt install -y postgresql-16-emaj # PG 16
apt install -y postgresql-15-emaj # PG 15
apt install -y postgresql-14-emaj # PG 14
创建扩展：
CREATE EXTENSION emaj CASCADE; -- 依赖: dblink, btree_gist
用法
E-Maj: 记录并回滚表内容变更
文档 | Emaj_web 图形界面
E-Maj 记录表上执行的变更操作（Insert、Update、Delete、Truncate），涵盖一个或多个表集合，并可在需要时高效地撤销这些变更，将表集合恢复到预定义的稳定状态。
在开发环境中，它可以轻松回滚程序执行产生的所有更新，方便反复重放测试流程。
在生产环境中，它提供：
- 表变更历史记录，供检查与审计
- 表组的批间保存点
- 无需停机即可将表组"恢复"到稳定状态
- 批处理窗口内的多个保存点，每个都可用作恢复点
核心概念
表组（Tables Group）
表组是一组生命节奏相同的应用表——它们的内容可以作为整体恢复。一个组可以包含不同 schema 中的表和序列。每个组处于两种状态之一：LOGGING（记录中）或 IDLE（空闲），并可指定为：
- ROLLBACKABLE（标准）——支持记录和回滚
- AUDIT_ONLY——只记录变更，不支持回滚，适用于没有主键的表或 UNLOGGED 表
标记（Mark）
标记代表表组生命周期中的快照时刻，捕获所有组成员的稳定状态。标记名称在组内唯一。
回滚（Rollback）
回滚操作将表和序列恢复到建立特定标记时的状态：
- 非日志回滚（Unlogged rollback）——撤销的更新不留痕迹
- 日志回滚（Logged rollback）——撤销操作也会被记录，允许后续再次反转
注意：E-Maj 的回滚与 PostgreSQL 原生的事务回滚有本质区别。
主要函数
启动表组
SELECT emaj.emaj_start_group('my_group', 'mark_1');
激活变更记录。表组必须处于 IDLE 状态。会自动创建初始标记。
设置中间标记
SELECT emaj.emaj_set_mark_group('my_group', 'mark_2');
记录应用状态的时间点快照。表组必须处于 LOGGING 状态。
回滚表组
非日志回滚（恢复表，不留撤销痕迹）：
SELECT * FROM emaj.emaj_rollback_group('my_group', 'mark_1');
日志回滚（允许撤销本次回滚）：
SELECT * FROM emaj.emaj_logged_rollback_group('my_group', 'mark_1');
两者都支持 '_EMAJ_LAST_MARK_' 关键字来指定最近的标记。
停止表组
SELECT emaj.emaj_stop_group('my_group');
停用记录功能，将表组状态从 LOGGING 切换为 IDLE。
多组操作
支持同时对多个表组进行批量操作：
SELECT emaj.emaj_start_groups('{"group1","group2"}', 'multi_mark');
SELECT emaj.emaj_set_mark_groups('{"group1","group2"}', 'common_mark');
SELECT * FROM emaj.emaj_rollback_groups('{"group1","group2"}', 'common_mark');
SELECT emaj.emaj_stop_groups('{"group1","group2"}');
变更检查
E-Maj 提供函数用于统计和检查标记之间的数据变更内容，并可生成重放已记录变更的 SQL 脚本。这对审计和调试非常有用。
Emaj_web
Emaj_web 是一个基于 PHP 的 Web 图形管理工具，提供友好的 E-Maj 管理界面。可在 GitHub 获取，详见文档。
7 - table_version
PostgreSQL 版本控制表扩展
概览
| ID | 扩展名 | Bin | Lib | Load | Create | Trust | Reloc | 模式 |
|---|
| 1060 | table_version | 否 | 是 | 否 | 是 | 否 | 否 | table_version |
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | MIXED | 1.11.1 | 1817161514 | table_version | plpgsql |
| RPM | PIGSTY | 1.11.1 | 1817161514 | table_version_$v | - |
| DEB | PIGSTY | 1.11.1 | 1817161514 | postgresql-$v-table-version | - |
构建
您可以使用 pig build 命令构建 table_version 扩展的 DEB 包：
pig build pkg table_version # 构建 DEB 包
安装
您可以直接安装 table_version 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install table_version; # 当前活跃 PG 版本安装
pig ext install -y table_version -v 18 # PG 18
pig ext install -y table_version -v 17 # PG 17
pig ext install -y table_version -v 16 # PG 16
pig ext install -y table_version -v 15 # PG 15
pig ext install -y table_version -v 14 # PG 14
dnf install -y table_version_18 # PG 18
dnf install -y table_version_17 # PG 17
dnf install -y table_version_16 # PG 16
dnf install -y table_version_15 # PG 15
dnf install -y table_version_14 # PG 14
apt install -y postgresql-18-table-version # PG 18
apt install -y postgresql-17-table-version # PG 17
apt install -y postgresql-16-table-version # PG 16
apt install -y postgresql-15-table-version # PG 15
apt install -y postgresql-14-table-version # PG 14
创建扩展：
CREATE EXTENSION table_version CASCADE; -- 依赖: plpgsql
用法
table_version: PostgreSQL 表版本控制扩展
PostgreSQL 表版本控制扩展，记录行的修改及其历史。该扩展提供 API 用于获取表在特定版本的快照，以及任意两个版本之间的差异。它基于 PL/PgSQL 触发器系统来记录和访问行版本。
快速开始
CREATE EXTENSION table_version;
CREATE SCHEMA foo;
SET search_path TO foo, public;
CREATE TABLE foo.bar (
id INTEGER NOT NULL PRIMARY KEY,
baz TEXT
);
-- 启用版本控制
SELECT table_version.ver_enable_versioning('foo', 'bar');
-- 创建版本并插入数据
SELECT table_version.ver_create_revision('Insert data');
INSERT INTO foo.bar (id, baz) VALUES
(1, 'foo bar 1'),
(2, 'foo bar 2'),
(3, 'foo bar 3');
SELECT table_version.ver_complete_revision();
-- 查看两个版本之间的差异
SELECT * FROM table_version.ver_get_foo_bar_diff(1001, 1002);
工作原理
启用表版本控制后，原始表数据保持不变，系统会创建一张新的版本表，包含原表所有字段加上 _revision_created 和 _revision_expired 字段。原表上会设置行级触发器，记录每一次插入、更新和删除到版本数据表中。同时设置语句级触发器，禁止 TRUNCATE 操作。
表的前置条件
- 表必须有唯一的非复合 integer、bigint、text 或 varchar 列
- 表不能是临时表
自动版本
如果你不想显式调用 ver_create_revision 和 ver_complete_revision，自动版本模式会按事务对编辑进行分组：
SELECT table_version.ver_enable_versioning('foo', 'bar');
BEGIN;
INSERT INTO foo.bar (id, baz) VALUES (1, 'foo bar 1');
INSERT INTO foo.bar (id, baz) VALUES (2, 'foo bar 2');
COMMIT;
BEGIN;
UPDATE foo.bar SET baz = 'foo bar 1 edit' WHERE id = 1;
COMMIT;
SELECT * FROM table_version.foo_bar_revision;
版本消息会根据事务 ID 自动创建。
使用表差异复制数据
要在远程系统上维护一份表数据的副本：
-- 1. 确定哪些表已启用版本控制
SELECT * FROM table_version.ver_get_versioned_tables();
-- 2. 获取基准版本
SELECT table_version.ver_get_table_base_revision('foo', 'bar');
-- 3. 创建基准快照
CREATE TABLE foo_bar_copy AS
SELECT * FROM table_version.ver_get_foo_bar_revision(
table_version.ver_get_table_base_revision('foo', 'bar')
);
-- 4. 获取差异以进行增量更新
SELECT * FROM table_version.ver_get_foo_bar_diff(
my_last_revision,
table_version.ver_get_table_last_revision('foo', 'bar')
);
安全模型
- 任何人都可以创建版本
- 版本只能由其创建者完成
- 只有拥有表所有权权限的人才能启用/禁用版本控制
- 只有空版本可以被删除
- 只有版本创建者才能删除该版本
注意：禁用表的版本控制会导致该表的所有历史记录被删除。
主要函数
| 函数 | 说明 |
|---|
ver_enable_versioning(schema, table) | 启用表的版本控制 |
ver_disable_versioning(schema, table) | 禁用版本控制并删除历史 |
ver_create_revision(comment) | 创建新版本 |
ver_complete_revision() | 标记当前版本为已完成 |
ver_get_<schema>_<table>_diff(rev1, rev2) | 获取两个版本之间的差异 |
ver_get_<schema>_<table>_revision(rev) | 获取特定版本的快照 |
ver_get_versioned_tables() | 列出所有已版本控制的表 |
ver_get_last_revision() | 获取最后的版本号 |
8 - pg_cron
定时任务调度器
概览
| ID | 扩展名 | Bin | Lib | Load | Create | Trust | Reloc | 模式 |
|---|
| 1070 | pg_cron | 否 | 是 | 是 | 是 | 否 | 否 | pg_catalog |
require cron.database_name
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PGDG | 1.6.7 | 1817161514 | pg_cron | - |
| RPM | PGDG | 1.6.7 | 1817161514 | pg_cron_$v | - |
| DEB | PGDG | 1.6.7 | 1817161514 | postgresql-$v-cron | - |
安装
您可以直接安装 pg_cron 扩展包的预置二进制包，首先确保 PGDG 仓库已经添加并启用：
pig repo add pgdg -u # 添加 PGDG 仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install pg_cron; # 当前活跃 PG 版本安装
pig ext install -y pg_cron -v 18 # PG 18
pig ext install -y pg_cron -v 17 # PG 17
pig ext install -y pg_cron -v 16 # PG 16
pig ext install -y pg_cron -v 15 # PG 15
pig ext install -y pg_cron -v 14 # PG 14
dnf install -y pg_cron_18 # PG 18
dnf install -y pg_cron_17 # PG 17
dnf install -y pg_cron_16 # PG 16
dnf install -y pg_cron_15 # PG 15
dnf install -y pg_cron_14 # PG 14
apt install -y postgresql-18-cron # PG 18
apt install -y postgresql-17-cron # PG 17
apt install -y postgresql-16-cron # PG 16
apt install -y postgresql-15-cron # PG 15
apt install -y postgresql-14-cron # PG 14
预加载配置：
shared_preload_libraries = 'pg_cron';
创建扩展：
CREATE EXTENSION pg_cron;
用法
请注意，cron.database 必须在将 pg_cron 添加到 shared_preload_libraries 之前设置好。
-- 每周六凌晨 3:30（GMT）删除过期数据
SELECT cron.schedule('30 3 * * 6', $$DELETE FROM events WHERE event_time < now() - interval '1 week'$$);
schedule
----------
42
-- 每天上午 10:00（GMT）执行 VACUUM
SELECT cron.schedule('nightly-vacuum', '0 10 * * *', 'VACUUM');
schedule
----------
43
-- 改为每天凌晨 3:00（GMT）执行 VACUUM
SELECT cron.schedule('nightly-vacuum', '0 3 * * *', 'VACUUM');
schedule
----------
43
-- 取消定时任务
SELECT cron.unschedule('nightly-vacuum' );
unschedule
------------
t
SELECT cron.unschedule(42);
unschedule
------------
t
-- 每周日凌晨 4:00（GMT）在 pg_cron 所在数据库之外的其他数据库中执行 VACUUM
SELECT cron.schedule_in_database('weekly-vacuum', '0 4 * * 0', 'VACUUM', 'some_other_database');
schedule
----------
44
-- 每 5 秒调用一次存储过程
SELECT cron.schedule('process-updates', '5 seconds', 'CALL process_updates()');
-- 每月最后一天中午 12:00 执行工资处理
SELECT cron.schedule('process-payroll', '0 12 $ * *', 'CALL process_payroll()');
Crontab 格式说明：
┌───────────── 分钟 (0 - 59)
│ ┌────────────── 小时 (0 - 23)
│ │ ┌─────────────── 日期 (1 - 31) 或月末最后一天 ($)
│ │ │ ┌──────────────── 月份 (1 - 12)
│ │ │ │ ┌───────────────── 星期 (0 - 6)（0 到 6 表示周日到
│ │ │ │ │ 周六，也可使用英文名称；7 同样表示周日）
│ │ │ │ │
│ │ │ │ │
* * * * *
9 - pg_task
在特定时间点在后台执行SQL命令
概览
| ID | 扩展名 | Bin | Lib | Load | Create | Trust | Reloc | 模式 |
|---|
| 1080 | pg_task | 否 | 是 | 是 | 否 | 否 | 否 | - |
breaks on many systems
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PGDG | 1.0.0 | 1817161514 | pg_task | - |
| RPM | PGDG | 2.1.7 | 1817161514 | pg_task_$v | - |
| DEB | PIGSTY | 2.1.12 | 1817161514 | postgresql-$v-pg-task | - |
构建
您可以使用 pig build 命令构建 pg_task 扩展的 DEB 包：
pig build pkg pg_task # 构建 DEB 包
安装
您可以直接安装 pg_task 扩展包的预置二进制包，首先确保 PGDG 仓库已经添加并启用：
pig repo add pgdg -u # 添加 PGDG 仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install pg_task; # 当前活跃 PG 版本安装
pig ext install -y pg_task -v 18 # PG 18
pig ext install -y pg_task -v 17 # PG 17
pig ext install -y pg_task -v 16 # PG 16
pig ext install -y pg_task -v 15 # PG 15
pig ext install -y pg_task -v 14 # PG 14
dnf install -y pg_task_18 # PG 18
dnf install -y pg_task_17 # PG 17
dnf install -y pg_task_16 # PG 16
dnf install -y pg_task_15 # PG 15
dnf install -y pg_task_14 # PG 14
apt install -y postgresql-18-pg-task # PG 18
apt install -y postgresql-17-pg-task # PG 17
apt install -y postgresql-16-pg-task # PG 16
apt install -y postgresql-15-pg-task # PG 15
apt install -y postgresql-14-pg-task # PG 14
预加载配置：
shared_preload_libraries = 'pg_task';
用法
pg_task: PostgreSQL 任务调度器
pg_task 允许在后台异步地在任意指定时间执行任意 SQL 命令。支持 PostgreSQL、Greenplum 和 Greengage。
首先在 postgresql.conf 中添加：
shared_preload_libraries = 'pg_task'
然后通过向 task 表插入记录来调度任务：
-- 立即执行 SQL
INSERT INTO task (input) VALUES ('SELECT now()');
-- 5 分钟后执行 SQL
INSERT INTO task (plan, input) VALUES (now() + '5 min'::INTERVAL, 'SELECT now()');
-- 在指定时间执行 SQL
INSERT INTO task (plan, input) VALUES ('2029-07-01 12:51:00', 'SELECT now()');
-- 每 5 分钟重复执行 SQL
INSERT INTO task (repeat, input) VALUES ('5 min', 'SELECT now()');
-- 异常会被捕获并写入 error 列
INSERT INTO task (input) VALUES ('SELECT 1/0');
-- 限制同一组内的并发任务数
INSERT INTO task (group, max, input) VALUES ('group', 1, 'SELECT now()');
-- 在远程数据库上执行 SQL
INSERT INTO task (input, remote) VALUES ('SELECT now()', 'user=user host=host');
任务表列定义
| 列名 | 类型 | 默认值 | 说明 |
|---|
| id | bigserial | 自增 | 主键 |
| parent | bigint | pg_task.id | 父任务 ID |
| plan | timestamptz | statement_timestamp() | 计划执行时间 |
| start | timestamptz | | 实际开始时间 |
| stop | timestamptz | | 实际结束时间 |
| active | interval | 1 hour | 计划时间后任务保持活跃的时段 |
| live | interval | 0 sec | 后台工作进程最大存活时间 |
| repeat | interval | 0 sec | 自动重复间隔 |
| timeout | interval | 0 sec | 任务执行允许的最大时间 |
| count | int | 0 | 工作进程退出前的最大任务数 |
| max | int | 0 | 同一组内最大并发任务数 |
| pid | int | | 执行任务的进程 ID |
| state | enum | PLAN | PLAN、TAKE、WORK、DONE、STOP |
| delete | bool | true | 当 output 和 error 为空时自动删除 |
| drift | bool | false | 根据结束时间计算下次重复时间 |
| header | bool | true | 在输出中显示列标题 |
| group | text | ‘group’ | 任务分组名称 |
| input | text | | 要执行的 SQL 命令 |
| output | text | | 接收到的结果 |
| error | text | | 捕获的错误 |
| remote | text | | 远程数据库连接字符串 |
你可以在此表上添加任意所需的列和/或创建分区。
配置参数（GUC）
关键设置：
| 参数 | 类型 | 默认值 | 说明 |
|---|
| pg_task.data | text | postgres | 任务表所在数据库名 |
| pg_task.user | text | postgres | 任务表所用用户名 |
| pg_task.schema | text | public | 任务表所在模式名 |
| pg_task.table | text | task | 任务表名 |
| pg_task.sleep | int | 1000 | 每 N 毫秒检查一次任务 |
| pg_task.delete | bool | true | 自动删除已完成任务 |
| pg_task.drift | bool | false | 根据结束时间计算重复间隔 |
| pg_task.repeat | interval | 0 sec | 默认重复间隔 |
| pg_task.timeout | interval | 0 sec | 默认任务超时 |
| pg_task.max | int | 0 | 默认组内最大并发任务数 |
| pg_task.run | int | 2147483647 | 最大并发执行任务数 |
| pg_task.json | json | [{“data”:“postgres”}] | 多数据库配置 |
多数据库配置
通过 JSON 配置在多个数据库上运行任务：
pg_task.json = '[{"data":"database1"},{"data":"database2","user":"username2"},{"data":"database3","schema":"schema3"}]'
如果指定的数据库、用户、模式或表不存在，pg_task 会自动创建它们。
10 - pg_later
执行查询，并在稍后异步获取查询结果
概览
| ID | 扩展名 | Bin | Lib | Load | Create | Trust | Reloc | 模式 |
|---|
| 1090 | pg_later | 否 | 是 | 是 | 是 | 否 | 否 | pglater |
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PIGSTY | 0.4.0 | 1817161514 | pg_later | pgmq |
| RPM | PIGSTY | 0.4.0 | 1817161514 | pg_later_$v | pgmq_$v |
| DEB | PIGSTY | 0.4.0 | 1817161514 | postgresql-$v-pg-later | postgresql-$v-pgmq |
构建
您可以使用 pig build 命令构建 pg_later 扩展的 RPM / DEB 包：
pig build pkg pg_later # 构建 RPM / DEB 包
安装
您可以直接安装 pg_later 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install pg_later; # 当前活跃 PG 版本安装
pig ext install -y pg_later -v 18 # PG 18
pig ext install -y pg_later -v 17 # PG 17
pig ext install -y pg_later -v 16 # PG 16
pig ext install -y pg_later -v 15 # PG 15
pig ext install -y pg_later -v 14 # PG 14
dnf install -y pg_later_18 # PG 18
dnf install -y pg_later_17 # PG 17
dnf install -y pg_later_16 # PG 16
dnf install -y pg_later_15 # PG 15
dnf install -y pg_later_14 # PG 14
apt install -y postgresql-18-pg-later # PG 18
apt install -y postgresql-17-pg-later # PG 17
apt install -y postgresql-16-pg-later # PG 16
apt install -y postgresql-15-pg-later # PG 15
apt install -y postgresql-14-pg-later # PG 14
预加载配置：
shared_preload_libraries = 'pg_later';
创建扩展：
CREATE EXTENSION pg_later CASCADE; -- 依赖: pgmq
用法
pg_later: 立即执行 SQL，稍后获取结果
一个用于异步执行查询的 PostgreSQL 扩展。基于 pgmq 构建。
快速开始
初始化扩展后端：
CREATE EXTENSION pg_later CASCADE;
SELECT pglater.init();
立即执行一条 SQL 查询：
SELECT pglater.exec(
'SELECT * FROM pg_available_extensions ORDER BY name LIMIT 2'
) AS job_id;
稍后通过任务 ID 获取结果：
SELECT pglater.fetch_results(1);
{
"query": "select * from pg_available_extensions order by name limit 2",
"job_id": 1,
"result": [
{
"name": "adminpack",
"comment": "administrative functions for PostgreSQL",
"default_version": "2.1",
"installed_version": null
},
{
"name": "amcheck",
"comment": "functions for verifying relation integrity",
"default_version": "1.3",
"installed_version": null
}
],
"status": "success"
}
11 - pg_dispatch
基于 pg_cron 的异步 SQL 分发器
概览
| ID | 扩展名 | Bin | Lib | Load | Create | Trust | Reloc | 模式 |
|---|
| 1100 | pg_dispatch | 否 | 否 | 否 | 是 | 否 | 否 | - |
Pure SQL extension; runtime also needs pgcrypto from contrib in addition to pg_cron.
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PIGSTY | 0.1.5 | 1817161514 | pg_dispatch | pgcrypto, pg_cron |
| RPM | PIGSTY | 0.1.5 | 1817161514 | pg_dispatch_$v | - |
| DEB | PIGSTY | 0.1.5 | 1817161514 | postgresql-$v-pg-dispatch | postgresql-$v-cron |
构建
您可以使用 pig build 命令构建 pg_dispatch 扩展的 RPM / DEB 包：
pig build pkg pg_dispatch # 构建 RPM / DEB 包
安装
您可以直接安装 pg_dispatch 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install pg_dispatch; # 当前活跃 PG 版本安装
pig ext install -y pg_dispatch -v 18 # PG 18
pig ext install -y pg_dispatch -v 17 # PG 17
pig ext install -y pg_dispatch -v 16 # PG 16
pig ext install -y pg_dispatch -v 15 # PG 15
pig ext install -y pg_dispatch -v 14 # PG 14
dnf install -y pg_dispatch_18 # PG 18
dnf install -y pg_dispatch_17 # PG 17
dnf install -y pg_dispatch_16 # PG 16
dnf install -y pg_dispatch_15 # PG 15
dnf install -y pg_dispatch_14 # PG 14
apt install -y postgresql-18-pg-dispatch # PG 18
apt install -y postgresql-17-pg-dispatch # PG 17
apt install -y postgresql-16-pg-dispatch # PG 16
apt install -y postgresql-15-pg-dispatch # PG 15
apt install -y postgresql-14-pg-dispatch # PG 14
创建扩展：
CREATE EXTENSION pg_dispatch CASCADE; -- 依赖: pgcrypto, pg_cron
用法
语法：
CREATE EXTENSION "Snehil_Shah@pg_dispatch";
SELECT pgdispatch.fire('SELECT pg_sleep(40);');
SELECT pgdispatch.snooze('SELECT pg_sleep(20);', '20 seconds');
来源：README，database.dev 页面
pg_dispatch 是 PostgreSQL 的异步 SQL 调度器。它被设计为兼容 TLE 的 pg_later 替代方案，构建在 pg_cron 之上，因此可用于 Supabase 和 AWS RDS 等受限环境。
先决条件
上游 README 列出了以下要求：
- PostgreSQL 13 或更高版本
pg_cron 1.5.0 或更高版本pgcrypto
安装
文档中给出的 TLE 安装路径如下：
SELECT dbdev.install(Snehil_Shah@pg_dispatch);
CREATE EXTENSION "Snehil_Shah@pg_dispatch";
README 提醒，该扩展会安装到 pgdispatch 模式中，如果系统里已经存在同名模式，可能会发生命名空间冲突。
函数
pgdispatch.fire(command text)
异步派发一条 SQL 命令：
SELECT pgdispatch.fire('SELECT pg_sleep(40);');
pgdispatch.snooze(command text, delay interval)
延迟派发一条 SQL 命令：
SELECT pgdispatch.snooze('SELECT pg_sleep(20);', '20 seconds');
README 指出，这个延迟调度是异步完成的，不会阻塞主事务。
适用场景
该项目主要用于数据库内的异步副作用，尤其适合 PL/pgSQL 或触发器流程。示例场景是把昂贵的通知或分析任务从 AFTER INSERT 触发器中拆出去，让主 RPC 或应用请求更快返回。
12 - pg_background
在后台运行 SQL 查询
概览
Release tag 1.9.2 still ships extension SQL version 1.9.
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | MIXED | 1.9.2 | 1817161514 | pg_background | - |
| RPM | PGDG | 1.9.2 | 1817161514 | pg_background_$v | - |
| DEB | PIGSTY | 1.9.2 | 1817161514 | postgresql-$v-pg-background | - |
构建
您可以使用 pig build 命令构建 pg_background 扩展的 DEB 包：
pig build pkg pg_background # 构建 DEB 包
安装
您可以直接安装 pg_background 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install pg_background; # 当前活跃 PG 版本安装
pig ext install -y pg_background -v 18 # PG 18
pig ext install -y pg_background -v 17 # PG 17
pig ext install -y pg_background -v 16 # PG 16
pig ext install -y pg_background -v 15 # PG 15
pig ext install -y pg_background -v 14 # PG 14
dnf install -y pg_background_18 # PG 18
dnf install -y pg_background_17 # PG 17
dnf install -y pg_background_16 # PG 16
dnf install -y pg_background_15 # PG 15
dnf install -y pg_background_14 # PG 14
apt install -y postgresql-18-pg-background # PG 18
apt install -y postgresql-17-pg-background # PG 17
apt install -y postgresql-16-pg-background # PG 16
apt install -y postgresql-15-pg-background # PG 15
apt install -y postgresql-14-pg-background # PG 14
创建扩展：
CREATE EXTENSION pg_background;
用法
pg_background: 在后台工作进程中执行 SQL
在 PostgreSQL 的后台工作进程中执行任意 SQL 命令。与 dblink（会建立独立连接）不同，pg_background 的工作进程运行在数据库服务器内部，并且各自拥有独立事务。
适用场景：
- 后台维护（VACUUM、ANALYZE、REINDEX）
- 异步审计日志
- 长时间运行的 ETL 管道
- 独立通知投递
- 并行查询模式
快速开始（V2 API）
CREATE EXTENSION pg_background;
-- 启动后台任务
SELECT * FROM pg_background_launch_v2(
'SELECT count(*) FROM large_table'
) AS handle;
-- pid | cookie
-- -------+-------------------
-- 12345 | 1234567890123456
-- 获取结果（一次性消费）
SELECT * FROM pg_background_result_v2(12345, 1234567890123456) AS (count BIGINT);
-- 即发即忘（不需要结果）
SELECT * FROM pg_background_submit_v2(
'INSERT INTO audit_log (ts, event) VALUES (now(), ''system_check'')'
) AS handle;
V2 API 参考
| 函数 | 返回值 | 说明 |
|---|
pg_background_launch_v2(sql, queue_size) | pg_background_handle | 启动工作进程，返回由 cookie 保护的句柄 |
pg_background_submit_v2(sql, queue_size) | pg_background_handle | 即发即忘（不消费结果） |
pg_background_result_v2(pid, cookie) | SETOF record | 获取结果（一次性消费） |
pg_background_detach_v2(pid, cookie) | void | 停止跟踪工作进程（工作进程继续运行） |
pg_background_cancel_v2(pid, cookie) | void | 请求取消 |
pg_background_cancel_v2_grace(pid, cookie, grace_ms) | void | 带宽限期取消 |
pg_background_wait_v2(pid, cookie) | void | 阻塞等待工作进程完成 |
pg_background_wait_v2_timeout(pid, cookie, timeout_ms) | bool | 带超时等待 |
pg_background_list_v2() | SETOF record | 列出当前会话中已知的工作进程 |
pg_background_stats_v2() | pg_background_stats | 会话统计信息（v1.8+） |
pg_background_progress(pct, msg) | void | 从工作进程中上报进度（v1.8+） |
pg_background_get_progress_v2(pid, cookie) | pg_background_progress | 获取工作进程进度（v1.8+） |
取消与分离
| 操作 | 停止执行 | 移除跟踪 |
|---|
cancel_v2() | 是（尽力而为） | 否 |
detach_v2() | 否 | 是 |
- 使用
cancel_v2() 来停止任务（终止执行，防止提交） - 使用
detach_v2() 来停止跟踪（释放簿记资源，工作进程继续运行）
工作进程生命周期
-- 取消运行中的任务
SELECT pg_background_cancel_v2(pid, cookie);
-- 等待完成
SELECT pg_background_wait_v2(pid, cookie);
-- 带超时等待（完成则返回 true）
SELECT pg_background_wait_v2_timeout(pid, cookie, 5000);
-- 列出活跃工作进程
SELECT * FROM pg_background_list_v2() AS (
pid int4, cookie int8, launched_at timestamptz,
user_id oid, queue_size int4, state text,
sql_preview text, last_error text, consumed bool
);
工作进程状态：running、stopped、canceled、error
进度报告（v1.8+）
-- 在工作进程 SQL 内部调用
SELECT pg_background_progress(50, 'Halfway done');
-- 从启动方查看进度
SELECT * FROM pg_background_get_progress_v2(pid, cookie);
GUC 配置（v1.8+）
| 参数 | 默认值 | 说明 |
|---|
pg_background.max_workers | 16 | 每个会话允许的最大并发工作进程数 |
pg_background.default_queue_size | 65536 | 默认共享内存队列大小 |
pg_background.worker_timeout | 0 | 工作进程超时时间（0 = 不限） |
V1 API（遗留）
V1 API 保留用于向后兼容，但没有基于 cookie 的 PID 重用保护：
SELECT pg_background_launch('VACUUM VERBOSE my_table') AS pid \gset
SELECT * FROM pg_background_result(:pid) AS (result TEXT);
SELECT pg_background_detach(:pid);
生产环境建议使用 V2 API，因为它具备 cookie 级的 PID 重用保护。
安全模型
- 扩展由超级用户安装，默认不授予 PUBLIC 权限
- 会创建一个专用的
pg_background_worker NOLOGIN 角色 - 辅助函数管理权限：
grant_pg_background_privileges(role, include_v1) - 工作进程以启动用户身份执行，而不是超级用户
13 - pg_when
PostgreSQL 自然语言时间解析扩展
概览
| ID | 扩展名 | Bin | Lib | Load | Create | Trust | Reloc | 模式 |
|---|
| 1120 | pg_when | 否 | 是 | 否 | 是 | 否 | 否 | - |
manually upgraded PGRX from 0.15.0 to 0.17.0 by Vonng
版本
构建
您可以使用 pig build 命令构建 pg_when 扩展的 RPM / DEB 包：
pig build pkg pg_when # 构建 RPM / DEB 包
安装
您可以直接安装 pg_when 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install pg_when; # 当前活跃 PG 版本安装
pig ext install -y pg_when -v 18 # PG 18
pig ext install -y pg_when -v 17 # PG 17
pig ext install -y pg_when -v 16 # PG 16
pig ext install -y pg_when -v 15 # PG 15
pig ext install -y pg_when -v 14 # PG 14
dnf install -y pg_when_18 # PG 18
dnf install -y pg_when_17 # PG 17
dnf install -y pg_when_16 # PG 16
dnf install -y pg_when_15 # PG 15
dnf install -y pg_when_14 # PG 14
apt install -y postgresql-18-pg-when # PG 18
apt install -y postgresql-17-pg-when # PG 17
apt install -y postgresql-16-pg-when # PG 16
apt install -y postgresql-15-pg-when # PG 15
apt install -y postgresql-14-pg-when # PG 14
创建扩展：
CREATE EXTENSION pg_when;
用法
来源: README 和 项目仓库。
pg-when 是一个 PostgreSQL 扩展，用于根据自然语言短语生成时间值。
它通过同一份解析结果提供多种返回格式：when_is、seconds_at、millis_at、micros_at 和 nanos_at。
查询语法最多由三部分组成：
SELECT when_is('<date> at <time> in <timezone>');
SELECT when_is('<date>');
SELECT when_is('<time> in <timezone>');
SELECT when_is('<date> at <time>');
如果未指定时区，扩展默认使用 UTC。
支持的组件
<date> 可以是相对日期，也可以是精确日期。
README 中列出的相对日期示例包括：
todayyesterdaytomorrownext weeklast monththis friday5 days agoin 2 years
精确日期可以写成以下格式：
YYYY-MM-DD 或 YYYY/MM/DDDD-MM-YYYY 或 DD/MM/YYYYMonth D, YYYYD Month YYYY
<time> 也可以是相对时间或精确时间。
相对时间示例包括：
noonmidnightmorningeveningnext hourprevious minutethis hour
精确时间可以用 12 小时制或 24 小时制表示，例如 8:30 pm 或 15:45。
时区既支持 IANA 名称，也支持 UTC 偏移量，例如 America/New_York 或 UTC-08:00。
示例
SELECT when_is('5 days ago at this hour in Asia/Tokyo');
SELECT when_is('next friday at 8:00 pm in America/New_York');
SELECT when_is('in 2 months at midnight in UTC-8');
SELECT when_is('last monday at 22:30');
SELECT when_is('December 31, 2026 at evening');
部署
上游 README 展示了 PostgreSQL 13 到 18 的 Docker 镜像。
这与本仓库中的包元数据一致。
14 - postgis
PostGIS 几何和地理空间扩展
概览
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PGDG | 3.6.3 | 1817161514 | postgis | - |
| RPM | PGDG | 3.6.3 | 1817161514 | postgis36_$v | - |
| DEB | PGDG | 3.6.3 | 1817161514 | postgresql-$v-postgis-3 | - |
安装
您可以直接安装 postgis 扩展包的预置二进制包，首先确保 PGDG 仓库已经添加并启用：
pig repo add pgdg -u # 添加 PGDG 仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install postgis; # 当前活跃 PG 版本安装
pig ext install -y postgis -v 18 # PG 18
pig ext install -y postgis -v 17 # PG 17
pig ext install -y postgis -v 16 # PG 16
pig ext install -y postgis -v 15 # PG 15
pig ext install -y postgis -v 14 # PG 14
dnf install -y postgis36_18 # PG 18
dnf install -y postgis36_17 # PG 17
dnf install -y postgis36_16 # PG 16
dnf install -y postgis36_15 # PG 15
dnf install -y postgis36_14 # PG 14
apt install -y postgresql-18-postgis-3 # PG 18
apt install -y postgresql-17-postgis-3 # PG 17
apt install -y postgresql-16-postgis-3 # PG 16
apt install -y postgresql-15-postgis-3 # PG 15
apt install -y postgresql-14-postgis-3 # PG 14
创建扩展：
CREATE EXTENSION postgis;
用法
PostGIS：PostgreSQL 的空间与地理对象支持
PostGIS 为 PostgreSQL 添加了地理对象支持，将其变成一个空间数据库。它实现了 OGC 简单要素规范，并提供空间索引、空间函数和坐标变换功能。
文档
- PostGIS 参考手册 – 完整文档
- 几何类型 – Point、LineString、Polygon、MultiPoint 等
- 空间关系 – ST_Contains、ST_Intersects、ST_Within 等
- 度量函数 – ST_Distance、ST_Area、ST_Length 等
- 几何处理 – ST_Buffer、ST_Union、ST_Intersection 等
- 几何输入/输出 – WKT、WKB、GeoJSON、KML、GML、SVG
- 坐标变换 – ST_Transform、ST_SetSRID
- 地理类型函数 – 真实球面距离计算
- 空间索引 – GiST 与 SP-GiST 索引
安装
CREATE EXTENSION postgis;
验证安装：
SELECT PostGIS_Full_Version();
核心数据类型
PostGIS 提供两种主要的空间类型：
| 类型 | 描述 | 坐标系 |
|---|
geometry | 平面（平地球）空间类型 | 笛卡尔坐标，使用 SRID 指定投影 |
geography | 球面（圆地球）空间类型 | 始终使用 WGS 84 经纬度（SRID 4326） |
Geometry（几何类型）
geometry 类型在投影坐标系中工作。速度快且支持 PostGIS 的全部函数。最适合在单一投影坐标系内工作的场景（例如 UTM 分区、州平面坐标系）。
Geography（地理类型）
geography 类型在球体/椭球体上进行计算。距离和面积以米为单位返回。支持的函数较少，但在大面积范围内无需选择投影即可获得精确结果。
-- 地理类型列：距离以米为单位，始终使用 WGS 84
CREATE TABLE cities (
name text PRIMARY KEY,
location geography(Point, 4326)
);
INSERT INTO cities VALUES
('New York', ST_GeogFromText('POINT(-74.006 40.7128)')),
('London', ST_GeogFromText('POINT(-0.1278 51.5074)')),
('Tokyo', ST_GeogFromText('POINT(139.6917 35.6895)'));
-- 以米为单位的距离（大圆距离）
SELECT a.name, b.name, ST_Distance(a.location, b.location) / 1000 AS distance_km
FROM cities a, cities b WHERE a.name < b.name;
创建空间表
空间列具有几何类型、维度（2D、3D、4D）和空间参考系统标识符（SRID）。
CREATE TABLE buildings (
id serial PRIMARY KEY,
name text,
geom geometry(Polygon, 4326)
);
CREATE TABLE roads (
id serial PRIMARY KEY,
name text,
geom geometry(LineString, 4326)
);
CREATE TABLE sensors (
id serial PRIMARY KEY,
label text,
geom geometry(Point, 4326)
);
插入空间数据
从 WKT（Well-Known Text）格式导入：
INSERT INTO sensors (label, geom) VALUES
('S1', ST_GeomFromText('POINT(-73.985 40.748)', 4326)),
('S2', ST_GeomFromText('POINT(-73.979 40.754)', 4326));
使用构造函数：
INSERT INTO sensors (label, geom) VALUES
('S3', ST_SetSRID(ST_MakePoint(-73.990, 40.735), 4326));
从 GeoJSON 导入：
INSERT INTO buildings (name, geom) VALUES
('Plaza', ST_GeomFromGeoJSON('{"type":"Polygon","coordinates":[[[-73.98,40.74],[-73.97,40.74],[-73.97,40.75],[-73.98,40.75],[-73.98,40.74]]]}'));
空间索引
GiST 索引对空间查询性能至关重要。务必在空间列上创建索引：
CREATE INDEX idx_sensors_geom ON sensors USING GIST (geom);
CREATE INDEX idx_buildings_geom ON buildings USING GIST (geom);
CREATE INDEX idx_roads_geom ON roads USING GIST (geom);
空间索引支持边界框运算符（&&、@、~），并在 WHERE 子句中被 ST_DWithin、ST_Intersects 和 ST_Contains 等空间函数自动使用。
对于超大数据集，可以考虑使用 BRIN 索引：
CREATE INDEX idx_sensors_geom_brin ON sensors USING BRIN (geom);
核心空间函数
创建几何对象
-- 从坐标创建点
SELECT ST_MakePoint(-73.985, 40.748);
-- 创建带 SRID 的点
SELECT ST_SetSRID(ST_MakePoint(-73.985, 40.748), 4326);
-- 从 WKT 创建
SELECT ST_GeomFromText('LINESTRING(0 0, 1 1, 2 1)', 4326);
-- 从 GeoJSON 创建
SELECT ST_GeomFromGeoJSON('{"type":"Point","coordinates":[-73.985,40.748]}');
-- 从两个点创建线段
SELECT ST_MakeLine(
ST_MakePoint(0, 0),
ST_MakePoint(1, 1)
);
-- 从闭合线串创建多边形
SELECT ST_MakePolygon(
ST_GeomFromText('LINESTRING(0 0, 1 0, 1 1, 0 1, 0 0)')
);
度量
-- 两个几何对象之间的距离（以 SRID 单位计）
SELECT ST_Distance(
ST_GeomFromText('POINT(0 0)', 4326),
ST_GeomFromText('POINT(1 1)', 4326)
);
-- 使用地理类型计算以米为单位的距离
SELECT ST_Distance(
'SRID=4326;POINT(-73.985 40.748)'::geography,
'SRID=4326;POINT(-0.1278 51.5074)'::geography
);
-- 面积（以 SRID 单位计，或地理类型以平方米计）
SELECT ST_Area(geom) FROM buildings;
-- 线串长度
SELECT ST_Length(geom) FROM roads;
-- 多边形周长
SELECT ST_Perimeter(geom) FROM buildings;
空间关系
-- A 是否包含 B？
SELECT ST_Contains(a.geom, b.geom) FROM buildings a, sensors b;
-- A 与 B 是否相交？
SELECT ST_Intersects(a.geom, b.geom) FROM buildings a, roads b;
-- B 是否在 A 的距离 D 以内？（索引友好）
SELECT ST_DWithin(a.geom, b.geom, 0.01) FROM sensors a, sensors b;
-- A 和 B 是否在距离 D 以内？（地理类型，单位为米）
SELECT ST_DWithin(a.location, b.location, 10000) FROM cities a, cities b;
-- A 是否与 B 接触？（共享边界但不共享内部）
SELECT ST_Touches(a.geom, b.geom) FROM buildings a, roads b;
-- A 是否穿越 B？
SELECT ST_Crosses(a.geom, b.geom) FROM roads a, roads b;
-- A 是否与 B 重叠？（同维度，不完全相同）
SELECT ST_Overlaps(a.geom, b.geom) FROM buildings a, buildings b;
几何处理
-- 缓冲区（按距离扩展几何对象）
SELECT ST_Buffer(geom, 0.001) FROM sensors;
-- 两个几何对象的交集
SELECT ST_Intersection(a.geom, b.geom) FROM buildings a, buildings b
WHERE ST_Intersects(a.geom, b.geom) AND a.id < b.id;
-- 几何对象的联合
SELECT ST_Union(geom) FROM buildings WHERE name LIKE 'Block%';
-- 凸包
SELECT ST_ConvexHull(ST_Collect(geom)) FROM sensors;
-- 简化几何对象（Douglas-Peucker 算法）
SELECT ST_Simplify(geom, 0.0001) FROM roads;
-- 质心
SELECT ST_Centroid(geom) FROM buildings;
-- 沃罗诺伊图
SELECT ST_VoronoiPolygons(ST_Collect(geom)) FROM sensors;
坐标变换
-- 从 WGS 84 (4326) 转换到 Web 墨卡托 (3857)
SELECT ST_Transform(geom, 3857) FROM sensors;
-- 转换到 UTM 分区以进行米制计算
SELECT ST_Area(ST_Transform(geom, 32618)) AS area_sqm FROM buildings;
-- 设置几何对象的 SRID（不会重新投影）
SELECT ST_SetSRID(geom, 4326) FROM sensors;
-- 获取当前 SRID
SELECT ST_SRID(geom) FROM sensors;
输出格式
-- 转为 GeoJSON
SELECT ST_AsGeoJSON(geom) FROM sensors;
-- 转为 WKT
SELECT ST_AsText(geom) FROM sensors;
-- 转为 KML
SELECT ST_AsKML(geom) FROM sensors;
-- 转为 SVG 路径
SELECT ST_AsSVG(geom) FROM buildings;
-- 转为 EWKT（包含 SRID）
SELECT ST_AsEWKT(geom) FROM sensors;
实际示例
查找附近的点
查找给定位置 500 米内的所有传感器：
SELECT label, ST_Distance(
geom::geography,
ST_SetSRID(ST_MakePoint(-73.985, 40.748), 4326)::geography
) AS distance_m
FROM sensors
WHERE ST_DWithin(
geom::geography,
ST_SetSRID(ST_MakePoint(-73.985, 40.748), 4326)::geography,
500
)
ORDER BY distance_m;
空间连接
查找每个传感器所在的建筑物：
SELECT s.label, b.name
FROM sensors s
JOIN buildings b ON ST_Contains(b.geom, s.geom);
统计多边形内的点数
SELECT b.name, COUNT(s.id) AS sensor_count
FROM buildings b
LEFT JOIN sensors s ON ST_Contains(b.geom, s.geom)
GROUP BY b.name;
K 近邻查询
使用索引加速的 <-> 运算符查找距某点最近的 5 个传感器：
SELECT label, geom <-> ST_SetSRID(ST_MakePoint(-73.985, 40.748), 4326) AS dist
FROM sensors
ORDER BY geom <-> ST_SetSRID(ST_MakePoint(-73.985, 40.748), 4326)
LIMIT 5;
聚合为单个几何对象
-- 将所有传感器点收集为 MultiPoint
SELECT ST_Collect(geom) FROM sensors;
-- 计算最小外接圆
SELECT ST_MinimumBoundingCircle(ST_Collect(geom)) FROM sensors;
Geography 与 Geometry 对比
| 特性 | geometry | geography |
|---|
| 坐标系 | 任意投影坐标系 | 仅 WGS 84 |
| 距离单位 | SRID 单位（度、米、英尺） | 米 |
| 大面积精度 | 需要正确的投影 | 全球范围精确 |
| 函数支持 | 完整（约 300 个函数） | 子集（约 40 个函数） |
| 索引支持 | GiST、SP-GiST、BRIN | GiST |
| 性能 | 更快 | 略慢 |
常见模式是使用 geography 存储数据以确保正确性，需要使用地理类型不支持的函数时再转换为 geometry：
SELECT ST_Area(geom::geography) AS area_sqm FROM buildings;
15 - postgis_topology
PostGIS 拓扑空间类型和函数
概览
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PGDG | 3.6.3 | 1817161514 | postgis | postgis |
| RPM | PGDG | 3.6.3 | 1817161514 | postgis36_$v | - |
| DEB | PGDG | 3.6.3 | 1817161514 | postgresql-$v-postgis-3 | - |
| OS / PG | PG18 | PG17 | PG16 | PG15 | PG14 |
|---|
| el8.x86_64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| el8.aarch64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| el9.x86_64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| el9.aarch64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| el10.x86_64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| el10.aarch64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| d12.x86_64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| d12.aarch64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| d13.x86_64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| d13.aarch64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| u22.x86_64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| u22.aarch64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| u24.x86_64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| u24.aarch64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
安装
您可以直接安装 postgis 扩展包的预置二进制包，首先确保 PGDG 仓库已经添加并启用：
pig repo add pgdg -u # 添加 PGDG 仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install postgis; # 当前活跃 PG 版本安装
pig ext install -y postgis -v 18 # PG 18
pig ext install -y postgis -v 17 # PG 17
pig ext install -y postgis -v 16 # PG 16
pig ext install -y postgis -v 15 # PG 15
pig ext install -y postgis -v 14 # PG 14
dnf install -y postgis36_18 # PG 18
dnf install -y postgis36_17 # PG 17
dnf install -y postgis36_16 # PG 16
dnf install -y postgis36_15 # PG 15
dnf install -y postgis36_14 # PG 14
apt install -y postgresql-18-postgis-3 # PG 18
apt install -y postgresql-17-postgis-3 # PG 17
apt install -y postgresql-16-postgis-3 # PG 16
apt install -y postgresql-15-postgis-3 # PG 15
apt install -y postgresql-14-postgis-3 # PG 14
创建扩展：
CREATE EXTENSION postgis_topology CASCADE; -- 依赖: postgis
用法
PostGIS Topology：PostGIS 的拓扑数据模型支持
PostGIS Topology 为 PostgreSQL 实现了 SQL/MM 拓扑模型。它将空间数据表示为节点、边和面的图结构，确保共享边界只存储一次，并强制保证几何一致性。
安装
CREATE EXTENSION postgis_topology;
这将创建包含管理表和函数的 topology 模式。
创建拓扑
拓扑是一个具有指定 SRID 和捕捉容差的命名模式：
-- 创建名为 'city_topo' 的拓扑，SRID 4326，容差 0.00001 度
SELECT topology.CreateTopology('city_topo', 4326, 0.00001);
列出所有拓扑：
SELECT * FROM topology.topology;
构建拓扑基元
添加边
边是基本构建单元。节点会在边的端点处自动创建。
-- 添加孤立节点
SELECT topology.ST_AddIsoNode('city_topo', NULL, ST_Point(-73.98, 40.75));
-- 添加两点之间的边（如需要会自动创建节点）
SELECT topology.ST_AddEdgeModFace('city_topo',
ST_MakeLine(ST_Point(-73.99, 40.74), ST_Point(-73.98, 40.74)));
SELECT topology.ST_AddEdgeModFace('city_topo',
ST_MakeLine(ST_Point(-73.98, 40.74), ST_Point(-73.98, 40.75)));
SELECT topology.ST_AddEdgeModFace('city_topo',
ST_MakeLine(ST_Point(-73.98, 40.75), ST_Point(-73.99, 40.75)));
SELECT topology.ST_AddEdgeModFace('city_topo',
ST_MakeLine(ST_Point(-73.99, 40.75), ST_Point(-73.99, 40.74)));
查看基元
-- 列出节点
SELECT node_id, ST_AsText(geom) FROM city_topo.node;
-- 列出边
SELECT edge_id, ST_AsText(geom) FROM city_topo.edge_data;
-- 列出面（face_id 0 是全局面）
SELECT face_id, ST_AsText(mbr) FROM city_topo.face;
-- 获取面的几何形状
SELECT topology.ST_GetFaceGeometry('city_topo', 1);
拓扑几何（TopoGeometry）
拓扑几何是通过引用拓扑基元而非坐标来定义的空间对象。这确保了共享边界始终保持一致。
创建拓扑几何图层
-- 创建包含拓扑几何列的表
CREATE TABLE city_topo.blocks (
id serial PRIMARY KEY,
name text
);
-- 注册拓扑几何列（返回 layer_id）
SELECT topology.AddTopoGeometryColumn('city_topo', 'city_topo', 'blocks', 'topo', 'POLYGON');
赋值拓扑几何
-- 从常规几何创建拓扑几何（捕捉到已有拓扑）
INSERT INTO city_topo.blocks (name, topo) VALUES
('Block A', topology.toTopoGeom(
ST_GeomFromText('POLYGON((-73.99 40.74,-73.98 40.74,-73.98 40.75,-73.99 40.75,-73.99 40.74))', 4326),
'city_topo', 1));
-- 将拓扑几何转换回常规几何
SELECT name, topo::geometry FROM city_topo.blocks;
验证拓扑
-- 验证整个拓扑
SELECT * FROM topology.ValidateTopology('city_topo');
-- 检查拓扑错误
SELECT error FROM topology.ValidateTopology('city_topo')
WHERE error IS NOT NULL;
清理
-- 删除拓扑及其所有对象
SELECT topology.DropTopology('city_topo');
16 - postgis_raster
PostGIS 光栅类型和函数
概览
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PGDG | 3.6.3 | 1817161514 | postgis | postgis |
| RPM | PGDG | 3.6.3 | 1817161514 | postgis36_$v | - |
| DEB | PGDG | 3.6.3 | 1817161514 | postgresql-$v-postgis-3 | - |
| OS / PG | PG18 | PG17 | PG16 | PG15 | PG14 |
|---|
| el8.x86_64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| el8.aarch64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| el9.x86_64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| el9.aarch64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| el10.x86_64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| el10.aarch64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| d12.x86_64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| d12.aarch64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| d13.x86_64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| d13.aarch64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| u22.x86_64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| u22.aarch64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| u24.x86_64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| u24.aarch64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
安装
您可以直接安装 postgis 扩展包的预置二进制包，首先确保 PGDG 仓库已经添加并启用：
pig repo add pgdg -u # 添加 PGDG 仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install postgis; # 当前活跃 PG 版本安装
pig ext install -y postgis -v 18 # PG 18
pig ext install -y postgis -v 17 # PG 17
pig ext install -y postgis -v 16 # PG 16
pig ext install -y postgis -v 15 # PG 15
pig ext install -y postgis -v 14 # PG 14
dnf install -y postgis36_18 # PG 18
dnf install -y postgis36_17 # PG 17
dnf install -y postgis36_16 # PG 16
dnf install -y postgis36_15 # PG 15
dnf install -y postgis36_14 # PG 14
apt install -y postgresql-18-postgis-3 # PG 18
apt install -y postgresql-17-postgis-3 # PG 17
apt install -y postgresql-16-postgis-3 # PG 16
apt install -y postgresql-15-postgis-3 # PG 15
apt install -y postgresql-14-postgis-3 # PG 14
创建扩展：
CREATE EXTENSION postgis_raster CASCADE; -- 依赖: postgis
用法
PostGIS Raster：PostGIS 的栅格数据支持
PostGIS Raster 为 PostGIS 扩展了栅格（网格）数据支持，可直接在 PostgreSQL 中存储栅格数据。它支持在 SQL 中进行栅格分析、栅格/矢量交互和地图代数运算。
安装
CREATE EXTENSION postgis_raster;
加载栅格数据
raster2pgsql 命令行工具可将栅格文件（GeoTIFF 等）导入 PostgreSQL：
# 将 GeoTIFF 以 100x100 瓦片导入，创建空间索引，使用 COPY
raster2pgsql -s 4326 -t 100x100 -I -C -M elevation.tif public.dem | psql mydb
# 追加到已有表
raster2pgsql -s 4326 -t 100x100 -a more_data.tif public.dem | psql mydb
关键参数：
-s <srid> – 设置 SRID-t <width>x<height> – 将栅格切分为瓦片-I – 创建 GiST 空间索引-C – 应用栅格约束-M – 加载后执行 vacuum analyze
查询栅格数据
栅格元数据
-- 获取栅格尺寸和像素大小
SELECT rid,
ST_Width(rast) AS width,
ST_Height(rast) AS height,
ST_ScaleX(rast) AS pixel_size_x,
ST_ScaleY(rast) AS pixel_size_y,
ST_NumBands(rast) AS bands,
ST_SRID(rast) AS srid
FROM dem LIMIT 5;
像素值
-- 获取指定点的值
SELECT ST_Value(rast, ST_SetSRID(ST_MakePoint(-73.985, 40.748), 4326)) AS elevation
FROM dem
WHERE ST_Intersects(rast, ST_SetSRID(ST_MakePoint(-73.985, 40.748), 4326));
-- 获取列/行位置的值（波段 1）
SELECT ST_Value(rast, 1, 10, 20) FROM dem WHERE rid = 1;
波段统计
SELECT (ST_SummaryStats(rast)).*
FROM dem WHERE rid = 1;
-- 返回：count、sum、mean、stddev、min、max
栅格处理
按矢量几何裁剪栅格
-- 将栅格裁剪到多边形边界
SELECT ST_Clip(rast, geom) AS clipped_rast
FROM dem, boundaries
WHERE ST_Intersects(rast, geom);
地图代数
逐像素运算：
-- 单栅格地图代数：高程分类
SELECT ST_MapAlgebra(rast, 1, NULL,
'CASE WHEN [rast] > 100 THEN 1 WHEN [rast] > 50 THEN 2 ELSE 3 END') AS classified
FROM dem;
-- 双栅格地图代数：两个 DEM 的差值
SELECT ST_MapAlgebra(a.rast, 1, b.rast, 1, '[rast1] - [rast2]') AS diff
FROM dem_old a, dem_new b
WHERE ST_Intersects(a.rast, b.rast);
栅格/矢量交互
-- 将栅格像素转换为矢量点
SELECT (ST_PixelAsPoints(rast)).*
FROM dem WHERE rid = 1;
-- 将栅格转换为多边形（每个唯一值一个）
SELECT (ST_DumpAsPolygons(rast)).*
FROM dem WHERE rid = 1;
-- 栅格与矢量相交并获取值
SELECT p.name, ST_Value(d.rast, p.geom) AS elevation
FROM dem d, points p
WHERE ST_Intersects(d.rast, p.geom);
重采样与重投影
-- 重采样为不同的像素大小
SELECT ST_Rescale(rast, 0.001, -0.001) FROM dem;
-- 重投影到不同的 SRID
SELECT ST_Transform(rast, 3857) FROM dem;
导出栅格
-- 导出为 GeoTIFF（二进制）
SELECT ST_AsTIFF(rast) FROM dem WHERE rid = 1;
-- 导出为 PNG
SELECT ST_AsPNG(rast) FROM dem WHERE rid = 1;
-- 导出为 JPEG
SELECT ST_AsJPEG(rast) FROM dem WHERE rid = 1;
17 - postgis_sfcgal
PostGIS SFCGAL 函数
概览
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PGDG | 3.6.3 | 1817161514 | postgis | postgis |
| RPM | PGDG | 3.6.3 | 1817161514 | postgis36_$v | - |
| DEB | PGDG | 3.6.3 | 1817161514 | postgresql-$v-postgis-3 | - |
| OS / PG | PG18 | PG17 | PG16 | PG15 | PG14 |
|---|
| el8.x86_64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| el8.aarch64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| el9.x86_64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| el9.aarch64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| el10.x86_64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| el10.aarch64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| d12.x86_64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| d12.aarch64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| d13.x86_64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| d13.aarch64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| u22.x86_64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| u22.aarch64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| u24.x86_64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| u24.aarch64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
安装
您可以直接安装 postgis 扩展包的预置二进制包，首先确保 PGDG 仓库已经添加并启用：
pig repo add pgdg -u # 添加 PGDG 仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install postgis; # 当前活跃 PG 版本安装
pig ext install -y postgis -v 18 # PG 18
pig ext install -y postgis -v 17 # PG 17
pig ext install -y postgis -v 16 # PG 16
pig ext install -y postgis -v 15 # PG 15
pig ext install -y postgis -v 14 # PG 14
dnf install -y postgis36_18 # PG 18
dnf install -y postgis36_17 # PG 17
dnf install -y postgis36_16 # PG 16
dnf install -y postgis36_15 # PG 15
dnf install -y postgis36_14 # PG 14
apt install -y postgresql-18-postgis-3 # PG 18
apt install -y postgresql-17-postgis-3 # PG 17
apt install -y postgresql-16-postgis-3 # PG 16
apt install -y postgresql-15-postgis-3 # PG 15
apt install -y postgresql-14-postgis-3 # PG 14
创建扩展：
CREATE EXTENSION postgis_sfcgal CASCADE; -- 依赖: postgis
用法
PostGIS SFCGAL：基于 SFCGAL 的三维几何与高级操作
PostGIS SFCGAL 通过封装 SFCGAL 库，提供高级的二维和三维空间操作。它增加了对三维几何运算、体积计算、拉伸、三角剖分等核心 PostGIS GEOS 后端不支持的功能。
安装
CREATE EXTENSION postgis_sfcgal;
三维操作
三维交集与差集
-- 两个实体的三维交集
SELECT ST_3DIntersection(
ST_GeomFromText('POLYHEDRALSURFACE Z(((0 0 0,1 0 0,1 1 0,0 1 0,0 0 0)),((0 0 1,1 0 1,1 1 1,0 1 1,0 0 1)),((0 0 0,0 1 0,0 1 1,0 0 1,0 0 0)),((1 0 0,1 1 0,1 1 1,1 0 1,1 0 0)),((0 0 0,1 0 0,1 0 1,0 0 1,0 0 0)),((0 1 0,1 1 0,1 1 1,0 1 1,0 1 0)))'),
ST_GeomFromText('POLYHEDRALSURFACE Z(((0.5 0.5 0.5,1.5 0.5 0.5,1.5 1.5 0.5,0.5 1.5 0.5,0.5 0.5 0.5)),((0.5 0.5 1.5,1.5 0.5 1.5,1.5 1.5 1.5,0.5 1.5 1.5,0.5 0.5 1.5)),((0.5 0.5 0.5,0.5 1.5 0.5,0.5 1.5 1.5,0.5 0.5 1.5,0.5 0.5 0.5)),((1.5 0.5 0.5,1.5 1.5 0.5,1.5 1.5 1.5,1.5 0.5 1.5,1.5 0.5 0.5)),((0.5 0.5 0.5,1.5 0.5 0.5,1.5 0.5 1.5,0.5 0.5 1.5,0.5 0.5 0.5)),((0.5 1.5 0.5,1.5 1.5 0.5,1.5 1.5 1.5,0.5 1.5 1.5,0.5 1.5 0.5)))')
);
-- 三维差集
SELECT ST_3DDifference(solid_a, solid_b) FROM solids;
-- 三维并集
SELECT ST_3DUnion(solid_a, solid_b) FROM solids;
三维度量
-- 曲面的三维面积
SELECT ST_3DArea(geom) FROM surfaces;
-- 实体的体积
SELECT ST_Volume(geom) FROM solids;
拉伸
-- 将二维多边形拉伸为三维实体
SELECT ST_Extrude(
ST_GeomFromText('POLYGON((0 0, 1 0, 1 1, 0 1, 0 0))'),
0, 0, 10 -- dx, dy, dz
);
细分与三角剖分
-- 将多边形细分为三角形
SELECT ST_Tesselate(
ST_GeomFromText('POLYGON((0 0, 1 0, 1 1, 0 1, 0 0))')
);
-- 约束 Delaunay 三角剖分
SELECT ST_ConstrainedDelaunayTriangles(
ST_GeomFromText('POLYGON((0 0, 1 0, 1 1, 0 1, 0 0))')
);
其他函数
-- 多边形的直骨架
SELECT ST_StraightSkeleton(
ST_GeomFromText('POLYGON((0 0, 1 0, 1 1, 0 1, 0 0))')
);
-- 近似中轴线
SELECT ST_ApproximateMedialAxis(
ST_GeomFromText('POLYGON((0 0, 1 0, 1 1, 0 1, 0 0))')
);
-- 闵可夫斯基和
SELECT ST_MinkowskiSum(
ST_GeomFromText('LINESTRING(0 0, 4 0)'),
ST_GeomFromText('POLYGON((0 0, 1 0, 1 1, 0 1, 0 0))')
);
-- 检查曲面是否为平面
SELECT ST_IsPlanar(geom) FROM surfaces;
18 - postgis_tiger_geocoder
PostGIS tiger 地理编码器和反向地理编码器
概览
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PGDG | 3.6.3 | 1817161514 | postgis | postgis, fuzzystrmatch |
| RPM | PGDG | 3.6.3 | 1817161514 | postgis36_$v | - |
| DEB | PGDG | 3.6.3 | 1817161514 | postgresql-$v-postgis-3 | - |
| OS / PG | PG18 | PG17 | PG16 | PG15 | PG14 |
|---|
| el8.x86_64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| el8.aarch64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| el9.x86_64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| el9.aarch64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| el10.x86_64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| el10.aarch64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| d12.x86_64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| d12.aarch64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| d13.x86_64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| d13.aarch64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| u22.x86_64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| u22.aarch64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| u24.x86_64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| u24.aarch64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
安装
您可以直接安装 postgis 扩展包的预置二进制包，首先确保 PGDG 仓库已经添加并启用：
pig repo add pgdg -u # 添加 PGDG 仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install postgis; # 当前活跃 PG 版本安装
pig ext install -y postgis -v 18 # PG 18
pig ext install -y postgis -v 17 # PG 17
pig ext install -y postgis -v 16 # PG 16
pig ext install -y postgis -v 15 # PG 15
pig ext install -y postgis -v 14 # PG 14
dnf install -y postgis36_18 # PG 18
dnf install -y postgis36_17 # PG 17
dnf install -y postgis36_16 # PG 16
dnf install -y postgis36_15 # PG 15
dnf install -y postgis36_14 # PG 14
apt install -y postgresql-18-postgis-3 # PG 18
apt install -y postgresql-17-postgis-3 # PG 17
apt install -y postgresql-16-postgis-3 # PG 16
apt install -y postgresql-15-postgis-3 # PG 15
apt install -y postgresql-14-postgis-3 # PG 14
创建扩展：
CREATE EXTENSION postgis_tiger_geocoder CASCADE; -- 依赖: postgis, fuzzystrmatch
用法
PostGIS TIGER Geocoder：基于美国人口普查 TIGER/Line 数据的 PostGIS 地理编码
PostGIS TIGER Geocoder 利用美国人口普查 TIGER/Line 数据提供地理编码和反向地理编码功能。它可以将地址字符串解析为标准化格式、查找地理坐标，以及将坐标反向解析为地址。
安装
CREATE EXTENSION postgis_tiger_geocoder CASCADE;
这将创建包含地理编码器表和函数的 tiger 模式。
加载 TIGER 数据
在进行地理编码之前，必须先加载所需州的 TIGER/Line 数据。该扩展提供了辅助函数来生成加载脚本：
-- 生成下载和加载某个州数据的脚本
-- （例如，马萨诸塞州 = 'MA'）
SELECT loader_generate_script(ARRAY['MA'], 'sh');
这会生成一个使用 shp2pgsql 加载 TIGER 形状文件的 shell 脚本。运行生成的脚本可将地址范围、边、面等数据填充到 tiger_data 模式中。
加载完成后：
-- 安装缺失的索引以提升性能
SELECT install_missing_indexes();
-- 更新统计信息
ANALYZE tiger.addr;
ANALYZE tiger.edges;
ANALYZE tiger.faces;
地理编码
将美国地址字符串转换为地理坐标：
-- 基本地理编码
SELECT g.rating, ST_X(g.geomout) AS lon, ST_Y(g.geomout) AS lat,
pprint_addy(g.addy) AS address
FROM geocode('1600 Pennsylvania Ave NW, Washington, DC 20500') AS g;
rating 表示匹配质量（越低越好，0 = 精确匹配）。
-- 限制返回结果数量的地理编码
SELECT g.rating, ST_AsText(g.geomout), pprint_addy(g.addy)
FROM geocode('100 Main St, Boston, MA', 3) AS g;
-- 从表中批量地理编码
SELECT a.id, g.rating, g.geomout, pprint_addy(g.addy)
FROM addresses a, LATERAL geocode(a.address_string, 1) AS g;
反向地理编码
将坐标转换回街道地址：
SELECT pprint_addy(r.addy[1]) AS address
FROM reverse_geocode(ST_SetSRID(ST_MakePoint(-77.0365, 38.8977), 4326)) AS r;
地址标准化
无需地理编码即可解析和标准化地址字符串：
SELECT *
FROM normalize_address('1600 Pennsylvania Avenue NW, Washington, DC 20500');
返回的组件包括：address（门牌号）、predirAbbrev、streetName、streetTypeAbbrev、postdirAbbrev、internal、location（城市）、stateAbbrev、zip、parsed。
-- 格式化输出标准化地址
SELECT pprint_addy(normalize_address('100 main street boston ma 02101'));
配置
tiger.geocode_settings 表控制地理编码器的行为：
-- 查看当前设置
SELECT * FROM tiger.geocode_settings;
-- 调整设置（例如，增加调试级别）
UPDATE tiger.geocode_settings SET val = 'true' WHERE name = 'debug_geocode_address';
19 - address_standardizer
地址标准化函数。
概览
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PGDG | 3.6.3 | 1817161514 | postgis | - |
| RPM | PGDG | 3.6.3 | 1817161514 | postgis36_$v | - |
| DEB | PGDG | 3.6.3 | 1817161514 | postgresql-$v-postgis-3 | - |
| OS / PG | PG18 | PG17 | PG16 | PG15 | PG14 |
|---|
| el8.x86_64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| el8.aarch64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| el9.x86_64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| el9.aarch64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| el10.x86_64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| el10.aarch64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| d12.x86_64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| d12.aarch64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| d13.x86_64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| d13.aarch64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| u22.x86_64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| u22.aarch64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| u24.x86_64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| u24.aarch64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
安装
您可以直接安装 postgis 扩展包的预置二进制包，首先确保 PGDG 仓库已经添加并启用：
pig repo add pgdg -u # 添加 PGDG 仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install postgis; # 当前活跃 PG 版本安装
pig ext install -y postgis -v 18 # PG 18
pig ext install -y postgis -v 17 # PG 17
pig ext install -y postgis -v 16 # PG 16
pig ext install -y postgis -v 15 # PG 15
pig ext install -y postgis -v 14 # PG 14
dnf install -y postgis36_18 # PG 18
dnf install -y postgis36_17 # PG 17
dnf install -y postgis36_16 # PG 16
dnf install -y postgis36_15 # PG 15
dnf install -y postgis36_14 # PG 14
apt install -y postgresql-18-postgis-3 # PG 18
apt install -y postgresql-17-postgis-3 # PG 17
apt install -y postgresql-16-postgis-3 # PG 16
apt install -y postgresql-15-postgis-3 # PG 15
apt install -y postgresql-14-postgis-3 # PG 14
创建扩展：
CREATE EXTENSION address_standardizer;
用法
Address Standardizer：PostGIS 的地址解析与标准化
Address Standardizer 是一个 PostGIS 扩展，使用可配置的词典、语法和规则表将单行地址字符串解析为结构化形式。它是 TIGER 地理编码器中内置 normalize_address 函数的更灵活替代方案。
安装
CREATE EXTENSION address_standardizer;
标准化地址
核心函数接收一个地址字符串和三个表引用（lex、gaz、rules）：
SELECT *
FROM standardize_address(
'us_lex', -- 词典表
'us_gaz', -- 地名表
'us_rules', -- 规则表
'1600 Pennsylvania Ave NW, Washington, DC 20500'
);
返回结果包含以下结构化字段：
| 字段 | 描述 |
|---|
building | 建筑名称或标识 |
house_num | 门牌号 |
predir | 前缀方向（N、S、E、W） |
qual | 限定符 |
pretype | 前缀类型 |
name | 街道名称 |
suftype | 后缀类型（St、Ave、Blvd） |
sufdir | 后缀方向 |
ruralroute | 乡村路线 |
extra | 附加信息 |
city | 城市名 |
state | 州 |
country | 国家 |
postcode | 邮政编码 |
box | 邮政信箱 |
unit | 单元/公寓号 |
词典、地名和规则表
标准化器由三个用户可配置的表驱动：
词典（lex） – 将输入词元映射为标准化形式和词元类别：
CREATE TABLE us_lex (
id serial PRIMARY KEY,
seq integer,
word text,
stdword text,
token integer
);
地名表（gaz） – 将地名（城市、州）映射为标准形式：
CREATE TABLE us_gaz (
id serial PRIMARY KEY,
seq integer,
word text,
stdword text,
token integer
);
规则（rules） – 定义地址解析的语法规则：
CREATE TABLE us_rules (
id serial PRIMARY KEY,
rule text
);
对于美国地址，address_standardizer_data_us 扩展提供了这些表的预置数据。
20 - address_standardizer_data_us
地址标准化函数：美国数据集示例
概览
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PGDG | 3.6.3 | 1817161514 | postgis | - |
| RPM | PGDG | 3.6.3 | 1817161514 | postgis36_$v | - |
| DEB | PGDG | 3.6.3 | 1817161514 | postgresql-$v-postgis-3 | - |
| OS / PG | PG18 | PG17 | PG16 | PG15 | PG14 |
|---|
| el8.x86_64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| el8.aarch64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| el9.x86_64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| el9.aarch64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| el10.x86_64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| el10.aarch64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| d12.x86_64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| d12.aarch64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| d13.x86_64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| d13.aarch64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| u22.x86_64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| u22.aarch64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| u24.x86_64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
| u24.aarch64 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 | PGDG 3.6.3 |
安装
您可以直接安装 postgis 扩展包的预置二进制包，首先确保 PGDG 仓库已经添加并启用：
pig repo add pgdg -u # 添加 PGDG 仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install postgis; # 当前活跃 PG 版本安装
pig ext install -y postgis -v 18 # PG 18
pig ext install -y postgis -v 17 # PG 17
pig ext install -y postgis -v 16 # PG 16
pig ext install -y postgis -v 15 # PG 15
pig ext install -y postgis -v 14 # PG 14
dnf install -y postgis36_18 # PG 18
dnf install -y postgis36_17 # PG 17
dnf install -y postgis36_16 # PG 16
dnf install -y postgis36_15 # PG 15
dnf install -y postgis36_14 # PG 14
apt install -y postgresql-18-postgis-3 # PG 18
apt install -y postgresql-17-postgis-3 # PG 17
apt install -y postgresql-16-postgis-3 # PG 16
apt install -y postgresql-15-postgis-3 # PG 15
apt install -y postgresql-14-postgis-3 # PG 14
创建扩展：
CREATE EXTENSION address_standardizer_data_us;
用法
Address Standardizer Data US：address_standardizer 扩展的美国地址数据
此扩展为 address_standardizer 扩展提供预置的美国词典、地名和规则数据。它包含常见美国街道类型、方向缩写、州名以及解析美国地址所需的语法规则表。
安装
CREATE EXTENSION address_standardizer_data_us;
这将在 public 模式中创建预填充了美国地址数据的 us_lex、us_gaz 和 us_rules 表。
与 address_standardizer 配合使用
安装后即可立即标准化美国地址：
SELECT *
FROM standardize_address(
'us_lex', 'us_gaz', 'us_rules',
'123 Main Street NW, Apt 4B, Springfield, IL 62704'
);
提供的数据涵盖常见的美国地址模式，包括：
- 街道类型（Street、Avenue、Boulevard、Drive、Lane、Court 等）
- 方向前缀和后缀（North、South、N、S、NW、SE 等）
- 州名及其缩写
- 单元标识符（Apt、Suite、Unit 等）
- 公路标识符（US、State、County、Interstate 等）
21 - pgrouting
提供寻路能力
概览
| ID | 扩展名 | Bin | Lib | Load | Create | Trust | Reloc | 模式 |
|---|
| 1510 | pgrouting | 否 | 是 | 否 | 是 | 否 | 是 | - |
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PGDG | 4.0.1 | 1817161514 | pgrouting | plpgsql, postgis |
| RPM | PGDG | 4.0.1 | 1817161514 | pgrouting_$v | - |
| DEB | PGDG | 4.0.1 | 1817161514 | postgresql-$v-pgrouting | - |
安装
您可以直接安装 pgrouting 扩展包的预置二进制包，首先确保 PGDG 仓库已经添加并启用：
pig repo add pgdg -u # 添加 PGDG 仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install pgrouting; # 当前活跃 PG 版本安装
pig ext install -y pgrouting -v 18 # PG 18
pig ext install -y pgrouting -v 17 # PG 17
pig ext install -y pgrouting -v 16 # PG 16
pig ext install -y pgrouting -v 15 # PG 15
pig ext install -y pgrouting -v 14 # PG 14
dnf install -y pgrouting_18 # PG 18
dnf install -y pgrouting_17 # PG 17
dnf install -y pgrouting_16 # PG 16
dnf install -y pgrouting_15 # PG 15
dnf install -y pgrouting_14 # PG 14
apt install -y postgresql-18-pgrouting # PG 18
apt install -y postgresql-17-pgrouting # PG 17
apt install -y postgresql-16-pgrouting # PG 16
apt install -y postgresql-15-pgrouting # PG 15
apt install -y postgresql-14-pgrouting # PG 14
创建扩展：
CREATE EXTENSION pgrouting CASCADE; -- 依赖: plpgsql, postgis
用法
pgRouting - 基于 PostgreSQL 的路径规划
pgRouting 扩展 PostGIS/PostgreSQL 地理空间数据库，提供地理空间路径规划和其他网络分析功能。
该库包含以下特性：
- 全对最短路径（Floyd-Warshall、Johnson）
- A* 算法（含双向变体）
- Dijkstra 算法（代价、代价矩阵、行驶距离、K 条最短路径、经由路由、最近点）
- 双向 Dijkstra
- 旅行商问题（TSP）
- 网络流（最大流、Boykov-Kolmogorov、Edmonds-Karp、预流推进）
- 生成树（Kruskal、Prim 及其 BFS/DFS/行驶距离变体）
- 图组件（连通分量、强连通分量、双连通分量、关节点、桥）
- 转弯限制最短路径（TRSP）
- WithPoints 路由（边上任意位置）
- 图压缩与实用函数
快速开始
启用扩展（需要 PostGIS）：
CREATE EXTENSION pgrouting CASCADE;
图的表示
pgRouting 使用返回边数据的 SQL 查询来表示图。标准边查询格式：
SELECT id, source, target, cost, reverse_cost FROM edges;
| 列 | 类型 | 说明 |
|---|
id | ANY-INTEGER | 边标识符 |
source | ANY-INTEGER | 起始顶点标识符 |
target | ANY-INTEGER | 终止顶点标识符 |
cost | ANY-NUMERICAL | 权重（source 到 target）；负值表示排除该边 |
reverse_cost | ANY-NUMERICAL | 权重（target 到 source）；默认 -1（不存在） |
无几何体的简单示例
创建一个图并查找最短路径：
CREATE TABLE wiki (
id SERIAL,
source INTEGER,
target INTEGER,
cost INTEGER
);
INSERT INTO wiki (source, target, cost) VALUES
(1, 2, 7), (1, 3, 9), (1, 6, 14),
(2, 3, 10), (2, 4, 15),
(3, 6, 2), (3, 4, 11),
(4, 5, 6),
(5, 6, 9);
SELECT * FROM pgr_dijkstra(
'SELECT id, source, target, cost FROM wiki',
1, 5, false);
函数族
Dijkstra - 最短路径
核心路由函数。支持一对一、一对多、多对一、多对多及组合签名。
pgr_dijkstra(Edges SQL, start_vid, end_vid, [directed])
pgr_dijkstra(Edges SQL, start_vid, end_vids, [directed])
pgr_dijkstra(Edges SQL, start_vids, end_vid, [directed])
pgr_dijkstra(Edges SQL, start_vids, end_vids, [directed])
pgr_dijkstra(Edges SQL, Combinations SQL, [directed])
返回：(seq, path_seq, start_vid, end_vid, node, edge, cost, agg_cost)
一对一：
SELECT * FROM pgr_dijkstra(
'SELECT id, source, target, cost, reverse_cost FROM edges',
6, 10, true);
一对多：
SELECT * FROM pgr_dijkstra(
'SELECT id, source, target, cost, reverse_cost FROM edges',
6, ARRAY[10, 17]);
多对多（无向）：
SELECT * FROM pgr_dijkstra(
'SELECT id, source, target, cost, reverse_cost FROM edges',
ARRAY[6, 1], ARRAY[10, 17],
directed => false);
组合：
SELECT * FROM pgr_dijkstra(
'SELECT id, source, target, cost, reverse_cost FROM edges',
'SELECT source, target FROM combinations',
false);
Dijkstra 代价
仅返回聚合代价，不含路径详情：
pgr_dijkstraCost(Edges SQL, start_vid, end_vid, [directed])
返回：(start_vid, end_vid, agg_cost)
Dijkstra 代价矩阵
为一组顶点生成代价矩阵：
pgr_dijkstraCostMatrix(Edges SQL, vids, [directed])
Dijkstra 经由
按有序顶点序列规划路径：
pgr_dijkstraVia(Edges SQL, via_vertices, [directed, strict, U_turn_on_edge])
Dijkstra 最近点
查找距离一组目标最近的顶点：
pgr_dijkstraNear(Edges SQL, start_vid, end_vids, [directed])
A* - 最短路径
使用 A* 启发式算法。需要边查询中包含额外的坐标列（x1、y1、x2、y2）。
pgr_aStar(Edges SQL, start_vid, end_vid, [directed, heuristic, factor, epsilon])
| 选项 | 类型 | 默认值 | 说明 |
|---|
directed | BOOLEAN | true | 图方向 |
heuristic | INTEGER | 5 | 距离启发式（0-5） |
factor | FLOAT | 1 | 单位换算因子 |
epsilon | FLOAT | 1 | 近似因子 |
SELECT * FROM pgr_aStar(
'SELECT id, source, target, cost, reverse_cost, x1, y1, x2, y2 FROM edges',
6, 12,
directed => true, heuristic => 2);
另有：pgr_aStarCost、pgr_aStarCostMatrix
双向算法
双向变体从两端同时搜索：
pgr_bdDijkstra、pgr_bdDijkstraCost、pgr_bdDijkstraCostMatrixpgr_bdAstar、pgr_bdAstarCost、pgr_bdAstarCostMatrix
SELECT * FROM pgr_bdDijkstra(
'SELECT id, source, target, cost, reverse_cost FROM edges',
6, 10);
K 条最短路径（Yen 算法）
查找两个顶点之间的 K 条最短路径：
pgr_KSP(Edges SQL, start_vid, end_vid, K, [directed, heap_paths])
返回：(seq, path_id, path_seq, start_vid, end_vid, node, edge, cost, agg_cost)
SELECT * FROM pgr_KSP(
'SELECT id, source, target, cost, reverse_cost FROM edges',
6, 17, 2);
行驶距离
查找给定距离内可达的所有顶点：
pgr_drivingDistance(Edges SQL, start_vid, distance, [directed])
pgr_drivingDistance(Edges SQL, start_vids, distance, [directed, equicost])
返回：(seq, depth, start_vid, pred, node, edge, cost, agg_cost)
SELECT * FROM pgr_drivingDistance(
'SELECT id, source, target, cost, reverse_cost FROM edges',
11, 3.0);
旅行商问题
基于矩阵的 TSP：
pgr_TSP(Matrix SQL, [start_id, end_id])
返回：(seq, node, cost, agg_cost)
SELECT * FROM pgr_TSP(
$$SELECT * FROM pgr_dijkstraCostMatrix(
'SELECT id, source, target, cost, reverse_cost FROM edges',
ARRAY[1, 3, 5, 6, 7, 8, 9, 10, 11, 15, 16, 17],
directed => false)$$,
start_id => 1);
欧几里得 TSP（直接使用坐标）：
pgr_TSPeuclidean(Coordinates SQL, [start_id, end_id])
网络流
计算最大流及相关属性：
-- 最大流
pgr_maxFlow(Edges SQL, source, sink)
-- 特定算法
pgr_boykovKolmogorov(Edges SQL, source, sink)
pgr_edmondsKarp(Edges SQL, source, sink)
pgr_pushRelabel(Edges SQL, source, sink)
-- 边不相交路径
pgr_edgeDisjointPaths(Edges SQL, source, sink)
-- 最大基数匹配
pgr_maxCardinalityMatch(Edges SQL, [directed])
网络流的边 SQL 使用 capacity 和 reverse_capacity 替代 cost/reverse_cost。
生成树
Kruskal 算法：
pgr_kruskal(Edges SQL) -- 最小生成树
pgr_kruskalBFS(Edges SQL, root_vid, [max_depth])
pgr_kruskalDFS(Edges SQL, root_vid, [max_depth])
pgr_kruskalDD(Edges SQL, root_vid, distance)
Prim 算法：
pgr_prim(Edges SQL) -- 最小生成树
pgr_primBFS(Edges SQL, root_vid, [max_depth])
pgr_primDFS(Edges SQL, root_vid, [max_depth])
pgr_primDD(Edges SQL, root_vid, distance)
图组件
-- 连通分量（无向）
pgr_connectedComponents(Edges SQL)
-- 强连通分量（有向）
pgr_strongComponents(Edges SQL)
-- 双连通分量
pgr_biconnectedComponents(Edges SQL)
-- 关节点（割点）
pgr_articulationPoints(Edges SQL)
-- 桥（割边）
pgr_bridges(Edges SQL)
转弯限制最短路径（TRSP）
带禁止路径限制的路由：
pgr_trsp(Edges SQL, Restrictions SQL, start_vid, end_vid, [directed])
pgr_trspVia(Edges SQL, Restrictions SQL, via_vertices, [directed, strict, U_turn_on_edge])
pgr_trsp_withPoints(Edges SQL, Restrictions SQL, Points SQL, start_pid, end_pid, [options])
限制条件 SQL 格式：
| 列 | 类型 | 说明 |
|---|
path | ARRAY[ANY-INTEGER] | 禁止的边 ID 序列 |
cost | ANY-NUMERICAL | 禁止路径的代价 |
WithPoints - 任意位置路由
在边上任意点（不仅是顶点）之间路由：
pgr_withPoints(Edges SQL, Points SQL, start_pid, end_pid, [options])
pgr_withPointsCost(Edges SQL, Points SQL, start_pid, end_pid, [options])
pgr_withPointsCostMatrix(Edges SQL, Points SQL, pids, [options])
pgr_withPointsKSP(Edges SQL, Points SQL, start_pid, end_pid, K, [options])
pgr_withPointsDD(Edges SQL, Points SQL, start_pid, distance, [options])
点 SQL 格式：
| 列 | 类型 | 默认值 | 说明 |
|---|
pid | ANY-INTEGER | | 点标识符 |
edge_id | ANY-INTEGER | | 最近的边 |
fraction | ANY-NUMERICAL | | 在边上的位置（0-1） |
side | CHAR | b | r(右侧)、l(左侧)、b(两侧) |
图压缩
通过压缩顶点简化图：
pgr_contraction(Edges SQL, contraction_order, [options])
实用函数
-- 从边数据中提取顶点
pgr_extractVertices(Edges SQL)
-- 查找点附近的边
pgr_findCloseEdges(Edges SQL, point, tolerance, [options])
-- 分离交叉几何体
pgr_separateCrossing(Edges SQL)
-- 分离相切几何体
pgr_separateTouching(Edges SQL)
-- 版本信息
pgr_version()
pgr_full_version()
使用几何体
构建路由拓扑
从空间边中提取顶点并构建拓扑：
-- 从边几何体中提取顶点
SELECT * INTO vertices
FROM pgr_extractVertices('SELECT id, geom FROM edges ORDER BY id');
-- 设置起始顶点
UPDATE edges AS e
SET source = v.id, x1 = x, y1 = y
FROM vertices AS v
WHERE ST_StartPoint(e.geom) = v.geom;
-- 设置终止顶点
UPDATE edges AS e
SET target = v.id, x2 = x, y2 = y
FROM vertices AS v
WHERE ST_EndPoint(e.geom) = v.geom;
基于几何体长度设置代价
UPDATE edges SET
cost = sign(cost) * ST_Length(geom),
reverse_cost = sign(reverse_cost) * ST_Length(geom);
获取路径几何体
将路由结果与边几何体结合：
SELECT seq, node, edge, cost, agg_cost, geom
FROM pgr_dijkstra(
'SELECT id, source, target, cost, reverse_cost FROM edges',
6, 10
) AS r
LEFT JOIN edges AS e ON r.edge = e.id;
性能优化
将查询限制在感兴趣的区域内，减少处理的边数：
SELECT * FROM pgr_dijkstra($$
SELECT id, source, target, cost, reverse_cost
FROM edges
WHERE geom && (
SELECT ST_Buffer(ST_Union(geom), 1)
FROM edges WHERE source IN (7) OR target IN (8))$$,
7, 8);
全对最短路径
用于计算所有顶点对之间的距离：
-- Floyd-Warshall（不需要边 ID）
pgr_floydWarshall(Edges SQL, [directed])
-- Johnson（不需要边 ID）
pgr_johnson(Edges SQL, [directed])
返回：(start_vid, end_vid, agg_cost)
SELECT * FROM pgr_floydWarshall(
'SELECT id, source, target, cost, reverse_cost FROM edges');
22 - pointcloud
提供激光雷达点云数据类型支持
概览
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PGDG | 1.2.5 | 1817161514 | pointcloud | - |
| RPM | PGDG | 1.2.5 | 1817161514 | pointcloud_$v | - |
| DEB | PGDG | 1.2.5 | 1817161514 | postgresql-$v-pointcloud | - |
安装
您可以直接安装 pointcloud 扩展包的预置二进制包，首先确保 PGDG 仓库已经添加并启用：
pig repo add pgdg -u # 添加 PGDG 仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install pointcloud; # 当前活跃 PG 版本安装
pig ext install -y pointcloud -v 18 # PG 18
pig ext install -y pointcloud -v 17 # PG 17
pig ext install -y pointcloud -v 16 # PG 16
pig ext install -y pointcloud -v 15 # PG 15
pig ext install -y pointcloud -v 14 # PG 14
dnf install -y pointcloud_18 # PG 18
dnf install -y pointcloud_17 # PG 17
dnf install -y pointcloud_16 # PG 16
dnf install -y pointcloud_15 # PG 15
dnf install -y pointcloud_14 # PG 14
apt install -y postgresql-18-pointcloud # PG 18
apt install -y postgresql-17-pointcloud # PG 17
apt install -y postgresql-16-pointcloud # PG 16
apt install -y postgresql-15-pointcloud # PG 15
apt install -y postgresql-14-pointcloud # PG 14
创建扩展：
CREATE EXTENSION pointcloud;
用法
pgpointcloud/pointcloud: 用于存储点云（LIDAR）数据的 PostgreSQL 扩展
文档
PostgreSQL Pointcloud 在 PostgreSQL 中存储点云（LIDAR）数据。它引入了两种新的数据类型：PcPoint 表示单个点，PcPatch 表示点的集合。数据通过 schema 文档来组织，描述每个点的维度和编码方式。
CREATE EXTENSION pointcloud;
-- 用于 PostGIS 集成：
CREATE EXTENSION pointcloud_postgis;
核心概念
Schema
PostgreSQL Pointcloud 使用"schema 文档"来描述特定 LIDAR 点的内容。每个点包含多个维度，每个维度可以是任意数据类型，并可应用缩放和/或偏移量来转换实际值与数据库存储值。schema 文档格式与 PDAL 库使用的格式相同。
以下是一个简单的 4 维 schema 文档：
INSERT INTO pointcloud_formats (pcid, srid, schema) VALUES (1, 4326,
'<?xml version="1.0" encoding="UTF-8"?>
<pc:PointCloudSchema xmlns:pc="http://pointcloud.org/schemas/PC/1.1"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<pc:dimension>
<pc:position>1</pc:position>
<pc:size>4</pc:size>
<pc:description>X 坐标，以长整数表示。需要使用头部的
缩放和偏移信息来确定双精度值。</pc:description>
<pc:name>X</pc:name>
<pc:interpretation>int32_t</pc:interpretation>
<pc:scale>0.01</pc:scale>
</pc:dimension>
<pc:dimension>
<pc:position>2</pc:position>
<pc:size>4</pc:size>
<pc:description>Y 坐标，以长整数表示。需要使用头部的
缩放和偏移信息来确定双精度值。</pc:description>
<pc:name>Y</pc:name>
<pc:interpretation>int32_t</pc:interpretation>
<pc:scale>0.01</pc:scale>
</pc:dimension>
<pc:dimension>
<pc:position>3</pc:position>
<pc:size>4</pc:size>
<pc:description>Z 坐标，以长整数表示。需要使用头部的
缩放和偏移信息来确定双精度值。</pc:description>
<pc:name>Z</pc:name>
<pc:interpretation>int32_t</pc:interpretation>
<pc:scale>0.01</pc:scale>
</pc:dimension>
<pc:dimension>
<pc:position>4</pc:position>
<pc:size>2</pc:size>
<pc:description>强度值是脉冲回波幅度的整数表示。
该值是可选的且与系统相关。但如果可用，
应始终包含在内。</pc:description>
<pc:name>Intensity</pc:name>
<pc:interpretation>uint16_t</pc:interpretation>
<pc:scale>1</pc:scale>
</pc:dimension>
<pc:metadata>
<Metadata name="compression">dimensional</Metadata>
</pc:metadata>
</pc:PointCloudSchema>');
Schema 文档存储在 pointcloud_formats 表中，与 pcid（点云标识符）关联。每个对象只有一个 pcid，用于在 pointcloud_formats 中查找 schema。这类似于 PostGIS 中通过 srid 解析空间参考系统的方式。
点云对象
PcPoint：基本点云类型。每个点包含大量维度，但至少有 X 和 Y 坐标。可通过 PC_AsText(pcpoint) 渲染为 JSON 格式：
{
"pcid" : 1,
"pt" : [0.01, 0.02, 0.03, 4]
}
PcPatch：PcPoint 的集合。LIDAR 数据不是存储数十亿条独立的点记录，而是表示为较少数量的 PcPatch 记录。Patch 通过 PC_AsText(pcpatch) 渲染：
{
"pcid" : 1,
"pts" : [
[0.02, 0.03, 0.05, 6],
[0.02, 0.03, 0.05, 8]
]
}
表
-- 需要上面的 schema 条目，使 pcid==1 存在。
-- 点表
CREATE TABLE points (
id SERIAL PRIMARY KEY,
pt PCPOINT(1)
);
-- Patch 表
CREATE TABLE patches (
id SERIAL PRIMARY KEY,
pa PCPATCH(1)
);
两个系统提供的表：
pointcloud_formats：保存所有 pcid 条目和 schema 文档pointcloud_columns：显示所有包含点云对象的列的视图
SELECT * FROM pointcloud_columns;
schema | table | column | pcid | srid | type
--------+-------------+--------+------+------+---------
public | points | pt | 1 | 4326 | pcpoint
public | patches | pa | 1 | 4326 | pcpatch
压缩
压缩在 schema 文档的 <pc:metadata> 块中声明：
<pc:metadata>
<Metadata name="compression">dimensional</Metadata>
</pc:metadata>
支持三种压缩方法：
- None：使用 schema 文档中描述的类型和格式，以字节数组存储点和 patch。
- Dimensional：将 patch 存储为维度数据数组的集合，并应用"适当的"压缩。适合较小的 patch 尺寸。
- LAZ（LASZip）：需要 Pointcloud 构建时支持 laz-perf。
如果未声明压缩方式，默认使用 none。
维度压缩在内部使用三种方案：游程编码（低变异性）、公共位移除（窄位范围变异性）、以及基于 zlib 的原始 deflate 压缩。
函数：Schema
PC_SchemaGetNDims
PC_SchemaGetNDims(pcid integer) returns integer – 返回维度数量。
SELECT PC_SchemaGetNDims(1);
-- 18
PC_SchemaIsValid
PC_SchemaIsValid(xml text) returns boolean – 如果点云 schema 有效则返回 true。
SELECT PC_SchemaIsValid(schema) FROM pointcloud_formats LIMIT 1;
-- t
函数：PcPoint
PC_MakePoint
PC_MakePoint(pcid integer, vals float8[]) returns pcpoint – 从 pcid 和双精度数组构造新的 pcpoint。
SELECT PC_MakePoint(1, ARRAY[-127, 45, 124.0, 4.0]);
-- 010100000064CEFFFF94110000703000000400
插入测试值：
INSERT INTO points (pt)
SELECT PC_MakePoint(1, ARRAY[x,y,z,intensity])
FROM (
SELECT
-127+a/100.0 AS x,
45+a/100.0 AS y,
1.0*a AS z,
a/10 AS intensity
FROM generate_series(1,100) AS a
) AS values;
PC_AsText（点）
PC_AsText(p pcpoint) returns text – 返回点数据的 JSON 版本。
SELECT PC_AsText('010100000064CEFFFF94110000703000000400'::pcpoint);
-- {"pcid":1,"pt":[-127,45,124,4]}
PC_Get
PC_Get(pt pcpoint) returns float8[] – 返回所有维度值的数组。
SELECT PC_Get('010100000064CEFFFF94110000703000000400'::pcpoint);
-- {-127,45,124,4}
PC_Get(pt pcpoint, dimname text) returns numeric – 返回指定维度的值。
SELECT PC_Get('010100000064CEFFFF94110000703000000400'::pcpoint, 'Intensity');
-- 4
PC_MemSize（点）
PC_MemSize(pt pcpoint) returns int4 – 返回 pcpoint 的内存大小。
SELECT PC_MemSize(PC_MakePoint(1, ARRAY[-127, 45, 124.0, 4.0]));
-- 25
PC_PCId（点）
PC_PCId(p pcpoint) returns integer – 返回该点的 pcid schema 编号。
SELECT PC_PCId('010100000064CEFFFF94110000703000000400'::pcpoint);
-- 1
函数：PcPatch
PC_Patch
PC_Patch(pts pcpoint[]) returns pcpatch – 将 pcpoint 值聚合为 pcpatch 的聚合函数。
INSERT INTO patches (pa)
SELECT PC_Patch(pt) FROM points GROUP BY id/10;
PC_MakePatch
PC_MakePatch(pcid integer, vals float8[]) returns pcpatch – 从 pcid 和双精度数组构造新的 pcpatch（数组大小必须是维度数的倍数）。
SELECT PC_AsText(PC_MakePatch(1, ARRAY[-126.99,45.01,1,0, -126.98,45.02,2,0, -126.97,45.03,3,0]));
-- {"pcid":1,"pts":[
-- [-126.99,45.01,1,0],[-126.98,45.02,2,0],[-126.97,45.03,3,0]
-- ]}
PC_AsText（patch）
PC_AsText(p pcpatch) returns text – 返回 patch 数据的 JSON 版本。
SELECT PC_AsText(pa) FROM patches LIMIT 1;
-- {"pcid":1,"pts":[
-- [-126.99,45.01,1,0],[-126.98,45.02,2,0],[-126.97,45.03,3,0],
-- [-126.96,45.04,4,0],[-126.95,45.05,5,0],[-126.94,45.06,6,0],
-- [-126.93,45.07,7,0],[-126.92,45.08,8,0],[-126.91,45.09,9,0]
-- ]}
PC_Summary
PC_Summary(p pcpatch) returns text – 返回 patch 数据的 JSON 格式摘要。
SELECT PC_Summary(pa) FROM patches LIMIT 1;
-- {"pcid":1, "npts":9, "srid":4326, "compr":"dimensional",
-- "dims":[{"pos":0,"name":"X","size":4,"type":"int32_t","compr":"sigbits",
-- "stats":{"min":-126.99,"max":-126.91,"avg":-126.95}}, ...]}
PC_NumPoints
PC_NumPoints(p pcpatch) returns integer – 返回 patch 中的点数。
SELECT PC_NumPoints(pa) FROM patches LIMIT 1;
-- 9
PC_PCId（patch）
PC_PCId(p pcpatch) returns integer – 返回 patch 的 pcid schema 编号。
PC_MemSize（patch）
PC_MemSize(p pcpatch) returns int4 – 返回 pcpatch 的内存大小。
PC_Explode
PC_Explode(p pcpatch) returns SetOf[pcpoint] – 将 patch 转换为独立点记录的集合返回函数。
SELECT PC_AsText(PC_Explode(pa)), id
FROM patches WHERE id = 7;
pc_astext | id
--------------------------------------+----
{"pcid":1,"pt":[-126.5,45.5,50,5]} | 7
{"pcid":1,"pt":[-126.49,45.51,51,5]} | 7
{"pcid":1,"pt":[-126.48,45.52,52,5]} | 7
...
PC_PointN
PC_PointN(p pcpatch, n int4) returns pcpoint – 返回第 n 个点（从 1 开始）。负数 n 从末尾计数。
PC_Range
PC_Range(p pcpatch, start int4, n int4) returns pcpatch – 返回从第 start 个点开始包含 n 个点的 patch。
PC_Union
PC_Union(p pcpatch[]) returns pcpatch – 将多个 pcpatch 合并为单个 pcpatch 的聚合函数。
SELECT PC_NumPoints(PC_Union(pa)) FROM patches;
-- 100
PC_Intersects（patch-patch）
PC_Intersects(p1 pcpatch, p2 pcpatch) returns boolean – 如果 p1 的边界与 p2 的边界相交则返回 true。
PC_PatchAvg
PC_PatchAvg(p pcpatch, dimname text) returns numeric – 返回所有点中指定维度的平均值。
SELECT PC_PatchAvg(pa, 'intensity') FROM patches WHERE id = 7;
-- 5.0000000000000000
PC_PatchAvg(p pcpatch) returns pcpoint – 返回每个维度平均值的 PcPoint。
SELECT PC_AsText(PC_PatchAvg(pa)) FROM patches WHERE id = 7;
-- {"pcid":1,"pt":[-126.46,45.54,54.5,5]}
PC_PatchMin
PC_PatchMin(p pcpatch, dimname text) returns numeric – 返回指定维度的最小值。
PC_PatchMin(p pcpatch) returns pcpoint – 返回每个维度最小值的 PcPoint。
PC_PatchMax
PC_PatchMax(p pcpatch, dimname text) returns numeric – 返回指定维度的最大值。
PC_PatchMax(p pcpatch) returns pcpoint – 返回每个维度最大值的 PcPoint。
PC_FilterGreaterThan
PC_FilterGreaterThan(p pcpatch, dimname text, float8 value) returns pcpatch – 过滤值大于给定值的点。
SELECT PC_AsText(PC_FilterGreaterThan(pa, 'y', 45.57))
FROM patches WHERE id = 7;
-- {"pcid":1,"pts":[[-126.42,45.58,58,5],[-126.41,45.59,59,5]]}
PC_FilterLessThan
PC_FilterLessThan(p pcpatch, dimname text, float8 value) returns pcpatch – 过滤值小于给定值的点。
PC_FilterEquals
PC_FilterEquals(p pcpatch, dimname text, float8 value) returns pcpatch – 过滤值等于给定值的点。
PC_FilterBetween
PC_FilterBetween(p pcpatch, dimname text, float8 value1, float8 value2) returns pcpatch – 过滤值在 value1 和 value2 之间（不含）的点。
PC_Sort
PC_Sort(p pcpatch, dimnames text[]) returns pcpatch – 返回按给定维度字典排序的 patch 副本。
PC_IsSorted
PC_IsSorted(p pcpatch, dimnames text[], strict boolean default true) returns boolean – 检查 pcpatch 是否按字典顺序排序。strict 选项检查是否无重复。
PC_SetPCId
PC_SetPCId(p pcpatch, pcid int4, def float8 default 0.0) returns pcpatch – 设置 PcPatch 的 schema。对于新 schema 中有但旧 schema 中没有的维度，使用值 def（默认 0.0）。
PC_Transform(p pcpatch, pcid int4, def float8 default 0.0) returns pcpatch – 返回基于目标 schema 转换数据的新 patch。与 PC_SetPCId 不同，如果解释方式、缩放或偏移不同，可能会改变 patch 数据。
PC_Compress
PC_Compress(p pcpatch, global_compression_scheme text, compression_config text) returns pcpatch – 使用手动指定的方案压缩 patch。
允许的全局压缩方案：auto、laz、dimensional。对于 dimensional，配置是每个维度压缩方式的逗号分隔列表：auto、zlib、sigbits、rle。
PC_Uncompress
PC_Uncompress(p pcpatch) returns pcpatch – 返回未压缩版本（压缩类型 none）。必须作为查询中的最外层函数才能在线路上返回未压缩数据。
函数：WKB
PC_AsBinary（点）
PC_AsBinary(p pcpoint) returns bytea – 返回点的 OGC “well-known binary” 格式。
PC_EnvelopeAsBinary
PC_EnvelopeAsBinary(p pcpatch) returns bytea – 返回 patch 二维边界的 OGC WKB。
注意：PC_Envelope 是 PC_EnvelopeAsBinary 的已弃用别名。
PC_BoundingDiagonalAsBinary
PC_BoundingDiagonalAsBinary(p pcpatch) returns bytea – 返回 patch 边界对角线的 OGC WKB。
函数：PostGIS 集成
pointcloud_postgis 扩展添加了将 Pointcloud 与 PostGIS 配合使用的函数，可将 PcPoint 和 PcPatch 转换为 Geometry 并进行空间过滤。
CREATE EXTENSION postgis;
CREATE EXTENSION pointcloud;
CREATE EXTENSION pointcloud_postgis;
Geometry 转换
Geometry(pcpoint) returns geometry / pcpoint::geometry – 将 PcPoint 转换为 PostGIS geometry，映射 x/y/z/m。
SELECT ST_AsText(PC_MakePoint(1, ARRAY[-127, 45, 124.0, 4.0])::geometry);
-- POINT Z (-127 45 124)
PC_EnvelopeGeometry
PC_EnvelopeGeometry(pcpatch) returns geometry – 返回 2D 边界的 PostGIS 二维多边形。
SELECT ST_AsText(PC_EnvelopeGeometry(pa)) FROM patches LIMIT 1;
-- POLYGON((-126.99 45.01,-126.99 45.09,-126.91 45.09,-126.91 45.01,-126.99 45.01))
适合创建索引：
CREATE INDEX ON patches USING GIST(PC_EnvelopeGeometry(patch));
PC_BoundingDiagonalGeometry
PC_BoundingDiagonalGeometry(pcpatch) returns geometry – 返回边界对角线的 LineString（根据可用维度为 2D/Z/M/ZM）。
SELECT ST_AsText(PC_BoundingDiagonalGeometry(pa)) FROM patches;
-- LINESTRING Z (-126.99 45.01 1,-126.91 45.09 9)
适合创建 N 维索引：
CREATE INDEX ON patches USING GIST(PC_BoundingDiagonalGeometry(patch) gist_geometry_ops_nd);
PC_Intersection
PC_Intersection(pcpatch, geometry) returns pcpatch – 返回仅包含与几何体相交的点的 PcPatch。
SELECT PC_AsText(PC_Explode(PC_Intersection(
pa,
'SRID=4326;POLYGON((-126.451 45.552, -126.42 47.55, -126.40 45.552, -126.451 45.552))'::geometry
)))
FROM patches WHERE id = 7;
pc_astext
--------------------------------------
{"pcid":1,"pt":[-126.44,45.56,56,5]}
{"pcid":1,"pt":[-126.43,45.57,57,5]}
{"pcid":1,"pt":[-126.42,45.58,58,5]}
{"pcid":1,"pt":[-126.41,45.59,59,5]}
PC_Intersects（patch-geometry）
PC_Intersects(p pcpatch, g geometry) returns boolean / PC_Intersects(g geometry, p pcpatch) returns boolean – 如果 patch 边界与几何体相交则返回 true。
SELECT PC_Intersects('SRID=4326;POINT(-126.451 45.552)'::geometry, pa)
FROM patches WHERE id = 7;
-- t
函数：工具
PC_Version / PC_Lib_Version / PC_Script_Version
SELECT PC_Version(); -- 1.2.5
SELECT PC_Lib_Version(); -- 1.2.5 2346cc2
SELECT PC_Script_Version(); -- 1.2.5
SELECT PC_Full_Version();
-- POINTCLOUD="1.2.5 2346cc2" PGSQL="170" LIBXML2="2.14.3 LAZPERF enabled=false
PC_Lazperf_Enabled
PC_Lazperf_Enabled() returns boolean – 如果 LAZperf 压缩支持可用则返回 true。
使用 PDAL 加载数据
PDAL 用于将 LIDAR 文件加载到 PostgreSQL Pointcloud 中。PDAL 管线是声明 reader、filter 和 writer 的 JSON 文件。
加载 LAS 文件的示例管线：
{
"pipeline":[
{
"type":"readers.las",
"filename":"/home/lidar/st-helens-small.las",
"spatialreference":"EPSG:26910"
},
{
"type":"filters.chipper",
"capacity":400
},
{
"type":"writers.pgpointcloud",
"connection":"host='localhost' dbname='pc' user='lidar' password='lidar' port='5432'",
"table":"sthsm",
"compression":"dimensional",
"srid":"26910"
}
]
}
执行：
pdal pipeline --input pipelinefile.json
filters.chipper 将无序点分组为紧凑的 patch，以便高效存储。
PDAL Writer 选项
- connection：PostgreSQL 连接字符串
- table：写入 patch 的目标表
- schema：创建表的 schema（可选）
- column：patch 列名（默认：
pa） - compression：patch 压缩格式（默认：
dimensional） - overwrite：替换已有表（默认：
true） - srid：空间参考 ID（默认：
4326） - pcid：使用已有的 PCID（可选）
- pre_sql / post_sql：管线前/后执行的 SQL（可选）
PDAL Reader 选项
- connection：PostgreSQL 连接字符串
- table：读取 patch 的源表
- schema：读取的 schema（可选）
- column：读取的列名（默认：
pa） - where：约束查询的 SQL where 子句（可选）
- spatialreference：覆盖数据库 SRID（可选）
读取并导出的示例管线：
{
"pipeline":[
{
"type":"readers.pgpointcloud",
"connection":"host='localhost' dbname='pc' user='lidar' password='lidar' port='5432'",
"table":"sthsm",
"column":"pa",
"spatialreference":"EPSG:26910",
"where":"PC_Intersects(pa, ST_MakeEnvelope(560037.36, 5114846.45, 562667.31, 5118943.24, 26910))"
},
{
"type":"writers.text",
"filename":"/home/lidar/st-helens-small-out.txt"
}
]
}
23 - pointcloud_postgis
将激光雷达点云与PostGIS几何类型相集成
概览
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PGDG | 1.2.5 | 1817161514 | pointcloud | postgis, pointcloud |
| RPM | PGDG | 1.2.5 | 1817161514 | pointcloud_$v | - |
| DEB | PGDG | 1.2.5 | 1817161514 | postgresql-$v-pointcloud | - |
| OS / PG | PG18 | PG17 | PG16 | PG15 | PG14 |
|---|
| el8.x86_64 | PGDG 1.2.5 | PGDG 1.2.5 | PGDG 1.2.5 | PGDG 1.2.5 | PGDG 1.2.5 |
| el8.aarch64 | PGDG 1.2.5 | PGDG 1.2.5 | PGDG 1.2.5 | PGDG 1.2.5 | PGDG 1.2.5 |
| el9.x86_64 | PGDG 1.2.5 | PGDG 1.2.5 | PGDG 1.2.5 | PGDG 1.2.5 | PGDG 1.2.5 |
| el9.aarch64 | PGDG 1.2.5 | PGDG 1.2.5 | PGDG 1.2.5 | PGDG 1.2.5 | PGDG 1.2.5 |
| el10.x86_64 | PGDG 1.2.5 | PGDG 1.2.5 | PGDG 1.2.5 | PGDG 1.2.5 | PGDG 1.2.5 |
| el10.aarch64 | PGDG 1.2.5 | PGDG 1.2.5 | PGDG 1.2.5 | PGDG 1.2.5 | PGDG 1.2.5 |
| d12.x86_64 | PGDG 1.2.5 | PGDG 1.2.5 | PGDG 1.2.5 | PGDG 1.2.5 | PGDG 1.2.5 |
| d12.aarch64 | PGDG 1.2.5 | PGDG 1.2.5 | PGDG 1.2.5 | PGDG 1.2.5 | PGDG 1.2.5 |
| d13.x86_64 | PGDG 1.2.5 | PGDG 1.2.5 | PGDG 1.2.5 | PGDG 1.2.5 | PGDG 1.2.5 |
| d13.aarch64 | PGDG 1.2.5 | PGDG 1.2.5 | PGDG 1.2.5 | PGDG 1.2.5 | PGDG 1.2.5 |
| u22.x86_64 | PGDG 1.2.5 | PGDG 1.2.5 | PGDG 1.2.5 | PGDG 1.2.5 | PGDG 1.2.5 |
| u22.aarch64 | PGDG 1.2.5 | PGDG 1.2.5 | PGDG 1.2.5 | PGDG 1.2.5 | PGDG 1.2.5 |
| u24.x86_64 | PGDG 1.2.5 | PGDG 1.2.5 | PGDG 1.2.5 | PGDG 1.2.5 | PGDG 1.2.5 |
| u24.aarch64 | PGDG 1.2.5 | PGDG 1.2.5 | PGDG 1.2.5 | PGDG 1.2.5 | PGDG 1.2.5 |
安装
您可以直接安装 pointcloud 扩展包的预置二进制包，首先确保 PGDG 仓库已经添加并启用：
pig repo add pgdg -u # 添加 PGDG 仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install pointcloud; # 当前活跃 PG 版本安装
pig ext install -y pointcloud -v 18 # PG 18
pig ext install -y pointcloud -v 17 # PG 17
pig ext install -y pointcloud -v 16 # PG 16
pig ext install -y pointcloud -v 15 # PG 15
pig ext install -y pointcloud -v 14 # PG 14
dnf install -y pointcloud_18 # PG 18
dnf install -y pointcloud_17 # PG 17
dnf install -y pointcloud_16 # PG 16
dnf install -y pointcloud_15 # PG 15
dnf install -y pointcloud_14 # PG 14
apt install -y postgresql-18-pointcloud # PG 18
apt install -y postgresql-17-pointcloud # PG 17
apt install -y postgresql-16-pointcloud # PG 16
apt install -y postgresql-15-pointcloud # PG 15
apt install -y postgresql-14-pointcloud # PG 14
创建扩展：
CREATE EXTENSION pointcloud_postgis CASCADE; -- 依赖: postgis, pointcloud
用法
pointcloud_postgis: pgPointcloud 的 PostGIS 集成
pointcloud_postgis 是将 pgPointcloud 扩展与 PostGIS 集成的桥接扩展。它实现了点云几何类型与 PostGIS 几何类型之间的转换。
CREATE EXTENSION pointcloud_postgis;
该扩展需要同时安装 pointcloud 和 postgis。它添加了在 pcpoint/pcpatch 类型与 PostGIS geometry 类型之间转换的函数，使得可以使用 PostGIS 运算符和函数对点云数据进行空间查询。
24 - h3
H3六边形层级索引支持
概览
| ID | 扩展名 | Bin | Lib | Load | Create | Trust | Reloc | 模式 |
|---|
| 1530 | h3 | 否 | 是 | 否 | 是 | 否 | 是 | - |
| 1531 | h3_postgis | 否 | 是 | 否 | 是 | 否 | 是 | - |
pgdg missing el8.x86.pg17 and el8.x86.pg18
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PGDG | 4.2.3 | 1817161514 | pg_h3 | - |
| RPM | PGDG | 4.2.3 | 1817161514 | h3-pg_$v | - |
| DEB | PGDG | 4.2.3 | 1817161514 | postgresql-$v-h3 | - |
安装
您可以直接安装 pg_h3 扩展包的预置二进制包，首先确保 PGDG 仓库已经添加并启用：
pig repo add pgdg -u # 添加 PGDG 仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install pg_h3; # 当前活跃 PG 版本安装
pig ext install -y pg_h3 -v 18 # PG 18
pig ext install -y pg_h3 -v 17 # PG 17
pig ext install -y pg_h3 -v 16 # PG 16
pig ext install -y pg_h3 -v 15 # PG 15
pig ext install -y pg_h3 -v 14 # PG 14
dnf install -y h3-pg_18 # PG 18
dnf install -y h3-pg_17 # PG 17
dnf install -y h3-pg_16 # PG 16
dnf install -y h3-pg_15 # PG 15
dnf install -y h3-pg_14 # PG 14
apt install -y postgresql-18-h3 # PG 18
apt install -y postgresql-17-h3 # PG 17
apt install -y postgresql-16-h3 # PG 16
apt install -y postgresql-15-h3 # PG 15
apt install -y postgresql-14-h3 # PG 14
创建扩展：
用法
h3-pg: Uber 的 H3 六边形层次地理空间索引系统的 PostgreSQL 绑定
该扩展为 H3 核心库（Uber 的六边形层次地理空间索引系统）提供 PostgreSQL 绑定。完整 API 参考请参见 H3 文档。
通常，所有函数都从 H3 的 camelCase 重命名为 SQL 的 snake_case，并加上 h3_ 前缀。
CREATE EXTENSION h3;
SELECT h3_latlng_to_cell(POINT('37.3615593,-122.0553238'), 5);
h3_latlng_to_cell
-------------------
85e35e73fffffff
基础类型
h3index 类型是一个无符号 64 位整数，表示任何 H3 对象（六边形、五边形、有向边等），以 16 字符的十六进制字符串显示，如 '8928308280fffff'。
索引函数
这些函数用于查找包含指定坐标的 H3 索引，以及获取 H3 索引的中心和边界。
-- 在指定分辨率（0-15）索引一个位置
SELECT h3_latlng_to_cell(POINT('37.3615593,-122.0553238'), 5);
-- 查找索引的质心
SELECT h3_cell_to_latlng('85283473fffffff'::h3index);
-- 查找索引的边界多边形
SELECT h3_cell_to_boundary('85283473fffffff'::h3index);
使用 SET h3.extend_antimeridian TO true 可在跨越 180 度经线时扩展坐标。
索引检查函数
-- 获取索引的分辨率（0-15）
SELECT h3_get_resolution('85283473fffffff'::h3index);
-- 获取基础单元格编号
SELECT h3_get_base_cell_number('85283473fffffff'::h3index);
-- 验证 H3 索引
SELECT h3_is_valid_cell('85283473fffffff'::h3index);
-- 检查索引是否为五边形
SELECT h3_is_pentagon('85283473fffffff'::h3index);
-- 检查分辨率是否为 Class III 方向
SELECT h3_is_res_class_iii('85283473fffffff'::h3index);
-- 查找索引相交的所有二十面体面
SELECT h3_get_icosahedron_faces('85283473fffffff'::h3index);
网格遍历函数
网格遍历可以查找起始单元格附近的单元格，以及确定从一个单元格到另一个单元格的遍历路径。
-- 获取距起点 k 步以内的所有索引
SELECT h3_grid_disk('85283473fffffff'::h3index, 2);
-- 带距离的索引
SELECT * FROM h3_grid_disk_distances('85283473fffffff'::h3index, 2);
-- 距离为 k 的空心六边形环
SELECT h3_grid_ring_unsafe('85283473fffffff'::h3index, 1);
-- 两个单元格之间的索引路径（含端点）
SELECT h3_grid_path_cells('85283473fffffff'::h3index, '8528342bfffffff'::h3index);
-- 两个索引之间的网格距离
SELECT h3_grid_distance('85283473fffffff'::h3index, '8528342bfffffff'::h3index);
-- 局部 IJ 坐标
SELECT h3_cell_to_local_ij('85283473fffffff'::h3index, '8528342bfffffff'::h3index);
SELECT h3_local_ij_to_cell('85283473fffffff'::h3index, POINT(0,0));
层次网格函数
在 H3 网格系统中的不同分辨率之间移动，生成父级（更粗）或子级（更细）单元格。
-- 获取更粗分辨率的父单元格
SELECT h3_cell_to_parent('85283473fffffff'::h3index, 3);
-- 获取更细分辨率的所有子单元格
SELECT h3_cell_to_children('85283473fffffff'::h3index, 7);
-- 获取更细分辨率的中心子单元格
SELECT h3_cell_to_center_child('85283473fffffff'::h3index, 7);
-- 压缩单元格数组
SELECT h3_compact_cells(ARRAY['85283473fffffff'::h3index, '85283477fffffff'::h3index]);
-- 解压到目标分辨率
SELECT h3_uncompact_cells(ARRAY['85283473fffffff'::h3index], 7);
-- 获取子单元格在父单元格子列表中的位置
SELECT h3_cell_to_child_pos('872834700ffffff'::h3index, 5);
-- 获取指定位置的子单元格
SELECT h3_child_pos_to_cell(0, '85283473fffffff'::h3index, 7);
区域函数
在 H3 索引和多边形区域之间互转。
-- 用指定分辨率的六边形填充多边形
SELECT h3_polygon_to_cells(
'((37.7,-122.5),(37.8,-122.5),(37.8,-122.4),(37.7,-122.4))'::polygon,
NULL::polygon[],
5
);
-- 获取一组六边形的轮廓多边形
SELECT * FROM h3_cells_to_multi_polygon(
ARRAY['85283473fffffff'::h3index, '85283477fffffff'::h3index]
);
单向边函数
编码从一个单元格到相邻单元格的有向边。
-- 检查两个单元格是否相邻
SELECT h3_are_neighbor_cells('85283473fffffff'::h3index, '85283477fffffff'::h3index);
-- 获取相邻单元格之间的有向边
SELECT h3_cells_to_directed_edge('85283473fffffff'::h3index, '85283477fffffff'::h3index);
-- 验证边
SELECT h3_is_valid_directed_edge(edge) FROM ...;
-- 从边获取起点和终点
SELECT h3_get_directed_edge_origin(edge);
SELECT h3_get_directed_edge_destination(edge);
-- 以记录形式获取两端
SELECT * FROM h3_directed_edge_to_cells(edge);
-- 从一个单元格出发的所有边
SELECT h3_origin_to_directed_edges('85283473fffffff'::h3index);
-- 边界坐标
SELECT h3_directed_edge_to_boundary(edge);
顶点函数
-- 获取单元格的单个顶点
SELECT h3_cell_to_vertex('85283473fffffff'::h3index, 0);
-- 获取单元格的所有顶点
SELECT h3_cell_to_vertexes('85283473fffffff'::h3index);
-- 获取顶点的地理坐标
SELECT h3_vertex_to_latlng(vertex);
-- 验证顶点
SELECT h3_is_valid_vertex(vertex);
杂项函数
-- 两点之间的大圆距离（km、m 或 rads）
SELECT h3_great_circle_distance(POINT(37.7,-122.5), POINT(40.7,-74.0), 'km');
-- 指定分辨率的六边形平均面积
SELECT h3_get_hexagon_area_avg(5, 'km^2');
-- 特定单元格的精确面积
SELECT h3_cell_area('85283473fffffff'::h3index, 'km^2');
-- 指定分辨率的平均边长
SELECT h3_get_hexagon_edge_length_avg(5, 'km');
-- 精确边长
SELECT h3_edge_length(edge, 'km');
-- 指定分辨率的唯一单元格数
SELECT h3_get_num_cells(5);
-- 全部 122 个分辨率 0 的单元格
SELECT h3_get_res_0_cells();
-- 指定分辨率的所有五边形
SELECT h3_get_pentagons(5);
运算符
-- 网格距离运算符
SELECT '85283473fffffff'::h3index <-> '8528342bfffffff'::h3index;
-- B-tree 等于/不等于
SELECT a = b, a <> b FROM ...;
-- R-tree 空间运算符
SELECT a && b -- 相交
SELECT a @> b -- 包含
SELECT a <@ b -- 被包含
SP-GiST 索引（实验性）
CREATE INDEX spgist_idx ON h3_data USING spgist(hex h3index_ops_experimental);
类型转换
-- H3 索引与 bigint 互转
SELECT '85283473fffffff'::h3index::bigint;
SELECT 599686042433355775::bigint::h3index;
-- H3 索引转 point
SELECT '85283473fffffff'::h3index::point;
PostGIS 集成
传递给 h3-pg PostGIS 函数的 GEOMETRY 数据应使用 SRID 4326。使用其他 SRID（如 3857）可能导致错误或无效数据。
PostGIS 集成需要伴随扩展 h3_postgis：
CREATE EXTENSION h3_postgis CASCADE;
-- 对 PostGIS 几何体建立指定分辨率的索引
SELECT h3_latlng_to_cell(geom, 9) FROM points;
-- 将 H3 单元格转换为 PostGIS geometry/geography
SELECT h3_cell_to_geometry('85283473fffffff'::h3index);
SELECT h3_cell_to_geography('85283473fffffff'::h3index);
-- 单元格边界转 PostGIS 几何体（在反子午线处分割）
SELECT h3_cell_to_boundary_geometry('85283473fffffff'::h3index);
-- 用 H3 单元格填充 PostGIS 多边形
SELECT h3_polygon_to_cells(geom, 7) FROM polygons;
-- 将 H3 单元格转回 PostGIS 多多边形
SELECT h3_cells_to_multi_polygon_geometry(ARRAY['85283473fffffff'::h3index]);
-- PostGIS 索引运算符
SELECT geom @ 9 FROM points; -- geometry @ resolution
栅格处理
对于连续栅格数据（温度、高程等），汇总 H3 单元格内的像素值：
SELECT
(summary).h3 AS h3,
(h3_raster_summary_stats_agg((summary).stats)).*
FROM (
SELECT h3_raster_summary(rast, 8) AS summary
FROM rasters
) t
GROUP BY 1;
对于离散/分类栅格数据（土地覆盖、土地利用），按 H3 单元格聚合分类统计：
SELECT
h3,
jsonb_object_agg(
concat('class_', val::text),
h3_raster_class_summary_item_to_jsonb(item)
ORDER BY val
) AS summary
FROM (
SELECT h3, val, h3_raster_class_summary_item_agg(summary) AS item
FROM rasters, h3_raster_class_summary(rast, 8)
GROUP BY 1, 2
) t
GROUP BY 1;
栅格汇总方法：h3_raster_summary（自动选择）、h3_raster_summary_clip（按单元格几何体裁剪）、h3_raster_summary_centroids（按像素质心分组）、h3_raster_summary_subpixel（适用于亚像素 H3 单元格）。分类汇总也有相同的变体。
25 - h3_postgis
H3与PostGIS集成的扩展插件
概览
| ID | 扩展名 | Bin | Lib | Load | Create | Trust | Reloc | 模式 |
|---|
| 1530 | h3 | 否 | 是 | 否 | 是 | 否 | 是 | - |
| 1531 | h3_postgis | 否 | 是 | 否 | 是 | 否 | 是 | - |
pgdg missing el8.x86.pg17 and el8.x86.pg18
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PGDG | 4.2.3 | 1817161514 | pg_h3 | h3, postgis, postgis_raster |
| RPM | PGDG | 4.2.3 | 1817161514 | h3-pg_$v | - |
| DEB | PGDG | 4.2.3 | 1817161514 | postgresql-$v-h3 | - |
| OS / PG | PG18 | PG17 | PG16 | PG15 | PG14 |
|---|
| el8.x86_64 | PGDG MISS | PGDG MISS | PGDG 4.1.3 | PGDG 4.1.3 | PGDG 4.1.3 |
| el8.aarch64 | PGDG 4.2.3 | PGDG 4.1.3 | PGDG 4.1.3 | PGDG 4.1.3 | PGDG 4.1.3 |
| el9.x86_64 | PGDG 4.2.3 | PGDG 4.1.3 | PGDG 4.1.3 | PGDG 4.1.3 | PGDG 4.1.3 |
| el9.aarch64 | PGDG 4.2.3 | PGDG 4.1.3 | PGDG 4.1.3 | PGDG 4.1.3 | PGDG 4.1.3 |
| el10.x86_64 | PGDG 4.2.3 | PGDG 4.2.2 | PGDG 4.2.2 | PGDG 4.2.2 | PGDG 4.2.2 |
| el10.aarch64 | PGDG 4.2.3 | PGDG 4.2.2 | PGDG 4.2.2 | PGDG 4.2.2 | PGDG 4.2.2 |
| d12.x86_64 | PGDG 4.2.3 | PGDG 4.2.3 | PGDG 4.2.3 | PGDG 4.2.3 | PGDG 4.2.3 |
| d12.aarch64 | PGDG 4.2.3 | PGDG 4.2.3 | PGDG 4.2.3 | PGDG 4.2.3 | PGDG 4.2.3 |
| d13.x86_64 | PGDG 4.2.3 | PGDG 4.2.3 | PGDG 4.2.3 | PGDG 4.2.3 | PGDG 4.2.3 |
| d13.aarch64 | PGDG 4.2.3 | PGDG 4.2.3 | PGDG 4.2.3 | PGDG 4.2.3 | PGDG 4.2.3 |
| u22.x86_64 | PGDG 4.2.3 | PGDG 4.2.3 | PGDG 4.2.3 | PGDG 4.2.3 | PGDG 4.2.3 |
| u22.aarch64 | PGDG 4.2.3 | PGDG 4.2.3 | PGDG 4.2.3 | PGDG 4.2.3 | PGDG 4.2.3 |
| u24.x86_64 | PGDG 4.2.3 | PGDG 4.2.3 | PGDG 4.2.3 | PGDG 4.2.3 | PGDG 4.2.3 |
| u24.aarch64 | PGDG 4.2.3 | PGDG 4.2.3 | PGDG 4.2.3 | PGDG 4.2.3 | PGDG 4.2.3 |
安装
您可以直接安装 pg_h3 扩展包的预置二进制包，首先确保 PGDG 仓库已经添加并启用：
pig repo add pgdg -u # 添加 PGDG 仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install pg_h3; # 当前活跃 PG 版本安装
pig ext install -y pg_h3 -v 18 # PG 18
pig ext install -y pg_h3 -v 17 # PG 17
pig ext install -y pg_h3 -v 16 # PG 16
pig ext install -y pg_h3 -v 15 # PG 15
pig ext install -y pg_h3 -v 14 # PG 14
dnf install -y h3-pg_18 # PG 18
dnf install -y h3-pg_17 # PG 17
dnf install -y h3-pg_16 # PG 16
dnf install -y h3-pg_15 # PG 15
dnf install -y h3-pg_14 # PG 14
apt install -y postgresql-18-h3 # PG 18
apt install -y postgresql-17-h3 # PG 17
apt install -y postgresql-16-h3 # PG 16
apt install -y postgresql-15-h3 # PG 15
apt install -y postgresql-14-h3 # PG 14
创建扩展：
CREATE EXTENSION h3_postgis CASCADE; -- 依赖: h3, postgis, postgis_raster
用法
h3_postgis: H3 的 PostGIS 集成
h3_postgis 是将 H3 六边形层次空间索引与 PostGIS 集成的桥接扩展。它实现了 H3 索引与 PostGIS 几何类型之间的转换。
CREATE EXTENSION h3_postgis CASCADE;
该扩展需要同时安装 h3 和 postgis。它提供了在 H3 单元格索引与 PostGIS 几何体之间转换的函数，使得可以将 H3 的六边形网格系统与 PostGIS 的空间能力结合使用。
主要函数
-- 将 PostGIS 点转换为 H3 单元格索引
SELECT h3_latlng_to_cell(ST_MakePoint(-73.985, 40.748)::point, 9);
-- 获取 H3 单元格边界的 PostGIS 几何体
SELECT h3_cell_to_boundary_geometry('892a1008003ffff'::h3index);
-- 将 H3 单元格转换为 PostGIS 多边形用于可视化
SELECT h3_cell_to_geometry('892a1008003ffff'::h3index);
26 - q3c
Q3C天空索引插件
概览
| ID | 扩展名 | Bin | Lib | Load | Create | Trust | Reloc | 模式 |
|---|
| 1540 | q3c | 否 | 是 | 否 | 是 | 否 | 是 | - |
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PGDG | 2.0.2 | 1817161514 | q3c | - |
| RPM | PGDG | 2.0.2 | 1817161514 | q3c_$v | - |
| DEB | PGDG | 2.0.2 | 1817161514 | postgresql-$v-q3c | - |
构建
您可以使用 pig build 命令构建 q3c 扩展的 RPM 包：
pig build pkg q3c # 构建 RPM 包
安装
您可以直接安装 q3c 扩展包的预置二进制包，首先确保 PGDG 仓库已经添加并启用：
pig repo add pgdg -u # 添加 PGDG 仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install q3c; # 当前活跃 PG 版本安装
pig ext install -y q3c -v 18 # PG 18
pig ext install -y q3c -v 17 # PG 17
pig ext install -y q3c -v 16 # PG 16
pig ext install -y q3c -v 15 # PG 15
pig ext install -y q3c -v 14 # PG 14
dnf install -y q3c_18 # PG 18
dnf install -y q3c_17 # PG 17
dnf install -y q3c_16 # PG 16
dnf install -y q3c_15 # PG 15
dnf install -y q3c_14 # PG 14
apt install -y postgresql-18-q3c # PG 18
apt install -y postgresql-17-q3c # PG 17
apt install -y postgresql-16-q3c # PG 16
apt install -y postgresql-15-q3c # PG 15
apt install -y postgresql-14-q3c # PG 14
创建扩展：
用法
来源：segasai/q3c | ADASS 论文 | ASCL
Q3C（Quad Tree Cube）是一个用于天文星表快速天球索引的 PostgreSQL 扩展。它能够对球面坐标（赤经和赤纬）进行高效的空间查询，包括锥形搜索、椭圆搜索、多边形查询、位置交叉匹配和最近邻查找。
所有角度（ra、dec、距离）单位为度，自行单位为毫角秒/年，历元单位为年（如 2000.5、2010.5）。所有 Q3C 函数名以 q3c_ 为前缀。
表准备
要使用 Q3C，在包含 ra 和 dec 列（单位为度）的表上创建空间索引：
CREATE INDEX ON mytable (q3c_ang2ipix(ra, dec));
可选择按索引对表进行聚簇，以确保大数据集上更快的查询：
CLUSTER mytable_q3c_ang2ipix_idx ON mytable;
或在建索引前重新排列表：
CREATE TABLE mytable1 AS SELECT * FROM mytable ORDER BY q3c_ang2ipix(ra, dec);
建索引后，分析表：
函数
q3c_ang2ipix(ra, dec) – 返回给定 ra 和 dec 对应的 ipix 值（64 位整数像素标识符）
q3c_dist(ra1, dec1, ra2, dec2) – 返回两点之间的距离（度）
q3c_dist_pm(ra1, dec1, pmra1, pmdec1, cosdec_flag, epoch1, ra2, dec2, epoch2) – 返回考虑自行的两点距离（度）。cosdec_flag（0 或 1）指示自行是否包含 cos(dec) 项（1）或不包含（0）
q3c_join(ra1, dec1, ra2, dec2, radius) – 如果 (ra1, dec1) 在 (ra2, dec2) 的 radius 球面距离内则返回 true。需要在 q3c_ang2ipix(ra2, dec2) 上创建索引
q3c_join_pm(ra1, dec1, pmra1, pmdec1, cosdec_flag, epoch1, ra2, dec2, epoch2, max_delta_epoch, radius) – 类似 q3c_join 但考虑自行。max_delta_epoch 是两个表之间可能的最大历元差
q3c_ellipse_join(ra1, dec1, ra2, dec2, major, ratio, pa) – 类似 q3c_join，但 (ra1, dec1) 必须在以半长轴 major、轴比 ratio 和位置角 pa（从北向东）定义的椭圆内
q3c_radial_query(ra, dec, center_ra, center_dec, radius) – 如果 (ra, dec) 在 (center_ra, center_dec) 的 radius 度范围内则返回 true。锥形搜索的主要函数。需要在 q3c_ang2ipix(ra, dec) 上建索引
q3c_ellipse_query(ra, dec, center_ra, center_dec, maj_ax, axis_ratio, PA) – 如果 (ra, dec) 在以 (center_ra, center_dec) 为中心、由半长轴、轴比和位置角定义的椭圆内则返回 true
q3c_poly_query(ra, dec, poly) – 如果 (ra, dec) 在以 RA/DEC 值数组或 PostgreSQL polygon 类型指定的球面多边形内则返回 true。使用索引
q3c_ipix2ang(ipix) – 返回给定 ipix 对应的 (ra, dec) 两元素数组
q3c_pixarea(ipix, bits) – 返回给定 ipix 在 bits 指定的像素化级别对应的球面面积（1 最小，30 是立方体面）
q3c_ipixcenter(ra, dec, bits) – 返回覆盖指定 (ra, dec) 的特定像素深度的像素中心 ipix 值
q3c_in_poly(ra, dec, poly) – 返回点是否在多边形内。不使用 q3c 索引
q3c_version() – 返回安装的 Q3C 版本
示例
锥形搜索
查询 (ra, dec) = (11, 12) 附近 0.1 度内的所有天体：
SELECT * FROM mytable WHERE q3c_radial_query(ra, dec, 11, 12, 0.1);
表的列名必须在前，搜索位置在后，否则索引不会被使用。
使用 q3c_join 的替代锥形搜索（对小表可能更快）：
SELECT * FROM mytable WHERE q3c_join(11, 12, ra, dec, 0.1);
椭圆搜索
搜索以 (10, 20) 为中心、半长轴 1 度、轴比 0.5、位置角 10 度的椭圆内的天体：
SELECT * FROM mytable WHERE q3c_ellipse_query(ra, dec, 10, 20, 1, 0.5, 10);
多边形搜索
查询顶点为 (0,0)、(2,0)、(2,1)、(0,1) 的球面多边形内的天体：
SELECT * FROM mytable WHERE
q3c_poly_query(ra, dec, ARRAY[0, 0, 2, 0, 2, 1, 0, 1]);
使用 PostgreSQL polygon 类型：
SELECT * FROM mytable WHERE
q3c_poly_query(ra, dec, '((0, 0), (2, 0), (2, 1), (0, 1))'::polygon);
位置交叉匹配
在 0.001 度范围内交叉匹配 table1 和 table2。索引需存在于 table2 的 q3c_ang2ipix(ra, dec) 上：
SELECT * FROM table1 AS a, table2 AS b WHERE
q3c_join(a.ra, a.dec, b.ra, b.dec, 0.001);
索引表的 ra/dec 列必须是第 3 和第 4 个参数。这会返回匹配距离内的所有配对，而不仅是最近邻。
使用逐对象误差半径：
SELECT * FROM table1 AS a, table2 AS b WHERE
q3c_join(a.ra, a.dec, b.ra, b.dec, a.err);
椭圆交叉匹配
使用椭圆误差区域进行交叉匹配（如在星系椭圆体内匹配）：
SELECT * FROM table1 AS a, table2 AS b WHERE
q3c_ellipse_join(a.ra, a.dec, b.ra, b.dec, a.maj_ax, a.axis_ratio, a.PA);
含自行的交叉匹配
考虑自行修正的交叉匹配。假设 table1 有 pmra、pmdec（毫角秒/年）和 epoch 列，pmra 包含 cos(dec) 因子，最大历元差为 30 年：
SELECT * FROM table1 AS a, table2 AS b WHERE
q3c_join_pm(a.ra, a.dec, a.pmra, a.pmdec, 1,
a.epoch, b.ra, b.dec, b.epoch, 30, 0.001);
最近邻（未匹配返回 NULL）
为每行返回最近邻，1 角秒内无匹配则返回 NULL：
SELECT t.*, ss.* FROM mytable AS t
LEFT JOIN LATERAL (
SELECT s.*
FROM sdssdr9.phototag AS s
WHERE q3c_join(t.ra, t.dec, s.ra, s.dec, 1./3600)
ORDER BY q3c_dist(t.ra, t.dec, s.ra, s.dec) ASC
LIMIT 1
) AS ss ON true;
最近邻（仅匹配项）
仅返回有邻居的天体：
SELECT t.*, ss.* FROM mytable AS t,
LATERAL (
SELECT s.*
FROM sdssdr9.phototag AS s
WHERE q3c_join(t.ra, t.dec, s.ra, s.dec, 1./3600)
ORDER BY q3c_dist(t.ra, t.dec, s.ra, s.dec) ASC
LIMIT 1
) AS ss;
最近邻（CTE 变体）
使用带有对象 ID 列的 CTE（需要在 ID 列上建索引）：
WITH x AS MATERIALIZED (
SELECT *, (
SELECT objid FROM sdssdr9.phototag AS p
WHERE q3c_join(m.ra, m.dec, p.ra, p.dec, 1./3600)
ORDER BY q3c_dist(m.ra, m.dec, p.ra, p.dec) ASC
LIMIT 1
) AS match_objid
FROM mytable AS m
)
SELECT * FROM x, sdssdr9.phototag AS s WHERE x.match_objid = s.objid;
密度估计
使用像素化深度 25 估计天体密度：
SELECT (q3c_ipix2ang(i))[1] AS ra,
(q3c_ipix2ang(i))[2] AS dec,
c,
q3c_pixarea(i, 25) AS area
FROM (
SELECT q3c_ipixcenter(ra, dec, 25) AS i, count(*) AS c
FROM mytable
GROUP BY i
) AS x;
注意：Q3C 的像素面积不均匀（与 HEALPIX 不同）。
限制
- 不支持查询直径大于约 25 度的超大多边形
- 不支持超过 100 个顶点的多边形
性能提示
- 确保 Q3C 函数中的参数顺序正确（如
q3c_radial_query(ra, dec, 120, 3, 1) 而非 q3c_radial_query(120, 3, ra, dec, 1)） - 使用
EXPLAIN 验证查询计划使用了 Q3C 索引的位图扫描 - 如果规划器选择了不佳的计划，尝试：
SET enable_mergejoin TO off; SET enable_seqscan TO off; SET enable_hashjoin TO off; - 按 Q3C 索引聚簇表以获得最佳性能
- 当
q3c_join() 与额外的过滤条件结合使用时，使用 MATERIALIZED CTE 避免计划问题：
WITH x AS MATERIALIZED (SELECT * FROM t1 WHERE t1.mag < 1),
y AS (SELECT *, t2.mag AS t2mag FROM x, t2 WHERE q3c_join(x.ra, x.dec, t2.ra, t2.dec, 1./3600))
SELECT * FROM y WHERE t2mag > 33;
27 - ogr_fdw
GIS 数据外部数据源包装器
概览
| ID | 扩展名 | Bin | Lib | Load | Create | Trust | Reloc | 模式 |
|---|
| 1550 | ogr_fdw | 否 | 是 | 否 | 是 | 否 | 是 | - |
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PGDG | 1.1.7 | 1817161514 | ogr_fdw | - |
| RPM | PGDG | 1.1.7 | 1817161514 | ogr_fdw_$v | - |
| DEB | PGDG | 1.1.7 | 1817161514 | postgresql-$v-ogr-fdw | - |
安装
您可以直接安装 ogr_fdw 扩展包的预置二进制包，首先确保 PGDG 仓库已经添加并启用：
pig repo add pgdg -u # 添加 PGDG 仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install ogr_fdw; # 当前活跃 PG 版本安装
pig ext install -y ogr_fdw -v 18 # PG 18
pig ext install -y ogr_fdw -v 17 # PG 17
pig ext install -y ogr_fdw -v 16 # PG 16
pig ext install -y ogr_fdw -v 15 # PG 15
pig ext install -y ogr_fdw -v 14 # PG 14
dnf install -y ogr_fdw_18 # PG 18
dnf install -y ogr_fdw_17 # PG 17
dnf install -y ogr_fdw_16 # PG 16
dnf install -y ogr_fdw_15 # PG 15
dnf install -y ogr_fdw_14 # PG 14
apt install -y postgresql-18-ogr-fdw # PG 18
apt install -y postgresql-17-ogr-fdw # PG 17
apt install -y postgresql-16-ogr-fdw # PG 16
apt install -y postgresql-15-ogr-fdw # PG 15
apt install -y postgresql-14-ogr-fdw # PG 14
创建扩展：
CREATE EXTENSION ogr_fdw;
用法
ogr_fdw: PostgreSQL 的 OGR 外部数据包装器
OGR 是 GDAL 空间数据访问库的矢量部分。它允许通过简单的 C API 访问大量 GIS 数据格式。由于 OGR 暴露了简单的表结构，而 PostgreSQL 外部数据包装器允许访问表结构，两者的契合非常完美。
快速开始
CREATE EXTENSION postgis;
CREATE EXTENSION ogr_fdw;
使用 ogr_fdw_info 工具读取 OGR 数据源并输出服务器/表定义：
ogr_fdw_info -s /tmp/test -l pt_two
CREATE SERVER "myserver"
FOREIGN DATA WRAPPER ogr_fdw
OPTIONS (
datasource '/tmp/test',
format 'ESRI Shapefile' );
CREATE FOREIGN TABLE "pt_two" (
fid integer,
"geom" geometry(Point, 4326),
"name" varchar,
"age" integer,
"height" real,
"birthdate" date )
SERVER "myserver"
OPTIONS (layer 'pt_two');
SELECT * FROM pt_two;
支持过滤下推——包括简单谓词和边界框过滤（&&）：
SET client_min_messages = debug1;
SELECT name, age, height
FROM pt_two
WHERE height < 5.7
AND geom && ST_MakeEnvelope(0, 0, 1, 1);
DEBUG: OGR SQL: (height < 5.7)
DEBUG: OGR spatial filter (0 0, 1 1)
限制
- 需要 PostgreSQL 11 或更高版本
- 仅有限的非空间查询限制会下推到 OGR（仅
>、<、<=、>=、=） - 仅边界框过滤（
&&）会下推到空间过滤 - OGR 连接每次查询都会创建（无连接池）
- 每次都会检索所有列
示例
WFS（Web 要素服务）
CREATE SERVER geoserver
FOREIGN DATA WRAPPER ogr_fdw
OPTIONS (
datasource 'WFS:https://demo.geo-solutions.it/geoserver/wfs',
format 'WFS' );
CREATE FOREIGN TABLE topp_states (
fid bigint,
the_geom Geometry(MultiSurface,4326),
gml_id varchar,
state_name varchar,
state_fips varchar,
state_abbr varchar,
land_km double precision,
persons double precision )
SERVER "geoserver"
OPTIONS (layer 'topp:states');
文件地理数据库
CREATE SERVER fgdbtest
FOREIGN DATA WRAPPER ogr_fdw
OPTIONS (
datasource '/tmp/Querying.gdb',
format 'OpenFileGDB' );
CREATE FOREIGN TABLE cities (
fid integer,
geom geometry(Point, 4326),
city_name varchar,
state_name varchar,
elevation integer,
pop1990 integer )
SERVER fgdbtest
OPTIONS (layer 'Cities');
高级功能
可写表
如果 OGR 驱动支持，你可以插入/更新/删除记录。可写表需要在表定义中包含 fid 列。
ALTER SERVER myserver
OPTIONS (ADD updateable 'true');
列名映射
将远程列名映射到本地列名：
CREATE FOREIGN TABLE typetest_fdw_mapped (
fid bigint,
supertime time OPTIONS (column_name 'clock'),
thebestname varchar OPTIONS (column_name 'name') )
SERVER wraparound
OPTIONS (layer 'typetest');
自动表导入
使用 IMPORT FOREIGN SCHEMA 自动创建外部表定义：
CREATE SCHEMA fgdball;
-- 导入所有表
IMPORT FOREIGN SCHEMA ogr_all
FROM SERVER fgdbtest
INTO fgdball;
-- 导入指定表
IMPORT FOREIGN SCHEMA ogr_all
LIMIT TO(cities)
FROM SERVER fgdbtest
INTO fgdball;
GDAL 选项
通过配置和打开选项控制驱动行为：
CREATE SERVER myserver_latin1
FOREIGN DATA WRAPPER ogr_fdw
OPTIONS (
datasource '/tmp/test',
format 'ESRI Shapefile',
config_options 'SHAPE_ENCODING=LATIN1' );
多个配置选项可以作为空格分隔的列表传递。
28 - geoip
IP 地理位置扩展（围绕 MaxMind GeoLite 数据集的包装器）
概览
| ID | 扩展名 | Bin | Lib | Load | Create | Trust | Reloc | 模式 |
|---|
| 1560 | geoip | 否 | 是 | 否 | 是 | 否 | 否 | geoip |
no pg17 on el9, no legacy branch on el8
版本
构建
您可以使用 pig build 命令构建 geoip 扩展的 RPM / DEB 包：
pig build pkg geoip # 构建 RPM / DEB 包
安装
您可以直接安装 geoip 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install geoip; # 当前活跃 PG 版本安装
pig ext install -y geoip -v 18 # PG 18
pig ext install -y geoip -v 17 # PG 17
pig ext install -y geoip -v 16 # PG 16
pig ext install -y geoip -v 15 # PG 15
pig ext install -y geoip -v 14 # PG 14
dnf install -y geoip_18 # PG 18
dnf install -y geoip_17 # PG 17
dnf install -y geoip_16 # PG 16
dnf install -y geoip_15 # PG 15
dnf install -y geoip_14 # PG 14
apt install -y postgresql-18-geoip # PG 18
apt install -y postgresql-17-geoip # PG 17
apt install -y postgresql-16-geoip # PG 16
apt install -y postgresql-15-geoip # PG 15
apt install -y postgresql-14-geoip # PG 14
创建扩展：
CREATE EXTENSION geoip CASCADE; -- 依赖: ip4r
用法
geoip: 基于 IP 的 PostgreSQL 地理定位
该扩展提供基于 IP 的地理定位——你提供一个 IPv4 或 IPv6 地址，扩展会查找国家、城市、GPS 坐标、ASN 等信息。它需要 ip4r 扩展和来自 MaxMind 的 GeoLite2 数据。
CREATE EXTENSION ip4r;
CREATE EXTENSION geoip;
函数
| 函数 | 说明 |
|---|
geoip_country_code(ip4|ip6) | 返回国家代码（2 字符） |
geoip_country(ip4|ip6) | 返回所有国家信息（代码、名称、网络） |
geoip_city_location(ip4|ip6) | 仅返回位置 ID（INT） |
geoip_city(ip4|ip6) | 返回所有城市信息（GPS、邮编等） |
geoip_asn(ip4|ip6) | 返回 ASN 名称和 IP 范围 |
示例
SELECT geoip_country_code('78.45.133.255'::ip4);
-- CZ
SELECT * FROM geoip.geoip_city('78.45.133.255'::ip4);
-- geoname_id | country_iso_code | city_name | postal_code | ...
-- ------------+------------------+-----------+-------------+----
-- 3066399 | CZ | Sardice | 696 13 | ...
SELECT * FROM geoip.geoip_country('78.45.133.255'::ip4);
-- network | country_iso_code | country_name
-- ----------------+------------------+--------------
-- 78.45.128.0/17 | CZ | Czechia
SELECT * FROM geoip.geoip_asn('78.45.133.255'::ip4);
-- network | asn_number | asn_name
-- --------------+------------+---------------------
-- 78.44.0.0/15 | 6830 | Liberty Global B.V.
加载数据
该扩展需要来自 MaxMind 的 GeoLite2 CSV 数据。从 MaxMind GeoLite2 下载 City、Country 和 ASN 数据集的 CSV 格式，然后加载：
cat GeoLite2-Country-Locations-en.csv | \
psql $DBNAME -c 'COPY geoip.geoip_country_locations FROM stdin WITH (FORMAT CSV, HEADER)'
cat GeoLite2-Country-Blocks-IPv4.csv | \
psql $DBNAME -c 'COPY geoip.geoip_country_blocks FROM stdin WITH (FORMAT CSV, HEADER)'
cat GeoLite2-Country-Blocks-IPv6.csv | \
psql $DBNAME -c 'COPY geoip.geoip_country_blocks FROM stdin WITH (FORMAT CSV, HEADER)'
cat GeoLite2-City-Locations-en.csv | \
psql $DBNAME -c 'COPY geoip.geoip_city_locations FROM stdin WITH (FORMAT CSV, HEADER)'
cat GeoLite2-City-Blocks-IPv4.csv | \
psql $DBNAME -c 'COPY geoip.geoip_city_blocks FROM stdin WITH (FORMAT CSV, HEADER)'
cat GeoLite2-City-Blocks-IPv6.csv | \
psql $DBNAME -c 'COPY geoip.geoip_city_blocks FROM stdin WITH (FORMAT CSV, HEADER)'
cat GeoLite2-ASN-Blocks-IPv4.csv | \
psql $DBNAME -c 'COPY geoip.geoip_asn_blocks FROM stdin WITH (FORMAT CSV, HEADER)'
cat GeoLite2-ASN-Blocks-IPv6.csv | \
psql $DBNAME -c 'COPY geoip.geoip_asn_blocks FROM stdin WITH (FORMAT CSV, HEADER)'
“locations” 文件有多种语言版本——选择适合你的即可。
29 - pg_polyline
Google快速Polyline编码解码扩展
概览
| ID | 扩展名 | Bin | Lib | Load | Create | Trust | Reloc | 模式 |
|---|
| 1570 | pg_polyline | 否 | 是 | 否 | 是 | 否 | 否 | - |
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PIGSTY | 0.0.1 | 1817161514 | pg_polyline | - |
| RPM | PIGSTY | 0.0.1 | 1817161514 | pg_polyline_$v | - |
| DEB | PIGSTY | 0.0.1 | 1817161514 | postgresql-$v-pg-polyline | - |
构建
您可以使用 pig build 命令构建 pg_polyline 扩展的 RPM / DEB 包：
pig build pkg pg_polyline # 构建 RPM / DEB 包
安装
您可以直接安装 pg_polyline 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install pg_polyline; # 当前活跃 PG 版本安装
pig ext install -y pg_polyline -v 18 # PG 18
pig ext install -y pg_polyline -v 17 # PG 17
pig ext install -y pg_polyline -v 16 # PG 16
pig ext install -y pg_polyline -v 15 # PG 15
pig ext install -y pg_polyline -v 14 # PG 14
dnf install -y pg_polyline_18 # PG 18
dnf install -y pg_polyline_17 # PG 17
dnf install -y pg_polyline_16 # PG 16
dnf install -y pg_polyline_15 # PG 15
dnf install -y pg_polyline_14 # PG 14
apt install -y postgresql-18-pg-polyline # PG 18
apt install -y postgresql-17-pg-polyline # PG 17
apt install -y postgresql-16-pg-polyline # PG 16
apt install -y postgresql-15-pg-polyline # PG 15
apt install -y postgresql-14-pg-polyline # PG 14
创建扩展：
CREATE EXTENSION pg_polyline;
用法
pg_polyline: PostgreSQL 的 Google 编码折线编解码
快速的 Google 编码折线编码与解码 PostgreSQL 扩展。基于 pgrx 构建。
CREATE EXTENSION pg_polyline;
-- 将点数组编码为折线字符串
SELECT polyline_encode(
ARRAY[point(-120.2, 38.5), point(-120.95, 40.7), point(-126.453, 43.252)], 6
);
-- polyline_encode
-- ----------------------------------
-- _izlhA~rlgdF_{geC~ywl@_kwzCn`{nI
-- 将折线字符串解码回点数组
SELECT polyline_decode('_ibE_seK_seK_seK', 6);
-- polyline_decode
-- ---------------------------
-- {"(0.2,0.1)","(0.4,0.3)"}
第二个参数是精度（小数位数）。
30 - pg_eviltransform
基于PostGIS ST_Transform 的 BD09/GCJ02 坐标转换扩展
概览
| ID | 扩展名 | Bin | Lib | Load | Create | Trust | Reloc | 模式 |
|---|
| 1580 | pg_eviltransform | 否 | 是 | 否 | 是 | 否 | 是 | eviltransform_internal |
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PIGSTY | 0.0.2 | 1817161514 | pg_eviltransform | postgis |
| RPM | PIGSTY | 0.0.2 | 1817161514 | pg_eviltransform_$v | postgis36_$v |
| DEB | PIGSTY | 0.0.2 | 1817161514 | postgresql-$v-eviltransform | postgresql-$v-postgis |
构建
您可以使用 pig build 命令构建 pg_eviltransform 扩展的 RPM / DEB 包：
pig build pkg pg_eviltransform # 构建 RPM / DEB 包
安装
您可以直接安装 pg_eviltransform 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install pg_eviltransform; # 当前活跃 PG 版本安装
pig ext install -y pg_eviltransform -v 18 # PG 18
pig ext install -y pg_eviltransform -v 17 # PG 17
pig ext install -y pg_eviltransform -v 16 # PG 16
pig ext install -y pg_eviltransform -v 15 # PG 15
pig ext install -y pg_eviltransform -v 14 # PG 14
dnf install -y pg_eviltransform_18 # PG 18
dnf install -y pg_eviltransform_17 # PG 17
dnf install -y pg_eviltransform_16 # PG 16
dnf install -y pg_eviltransform_15 # PG 15
dnf install -y pg_eviltransform_14 # PG 14
apt install -y postgresql-18-eviltransform # PG 18
apt install -y postgresql-17-eviltransform # PG 17
apt install -y postgresql-16-eviltransform # PG 16
apt install -y postgresql-15-eviltransform # PG 15
apt install -y postgresql-14-eviltransform # PG 14
创建扩展：
CREATE EXTENSION pg_eviltransform CASCADE; -- 依赖: postgis
用法
pg_eviltransform: WGS84、GCJ02 和 BD09 之间的坐标转换
pg_eviltransform 为 PostGIS 的 ST_Transform 扩展了 BD09/GCJ02 中国坐标系支持。它暴露了 ST_EvilTransform 函数，与 ST_Transform 具有相同的重载接口。
自定义 SRID：
990001：GCJ02（火星坐标系）990002：BD09（百度坐标系）
函数
ST_EvilTransform(geometry, to_srid integer)
ST_EvilTransform(geometry, to_proj text)
ST_EvilTransform(geometry, from_proj text, to_srid integer)
ST_EvilTransform(geometry, from_proj text, to_proj text)
如果双方都不涉及自定义坐标系，则直接委托给 ST_Transform。如果涉及 BD09/GCJ02，会在需要时通过 WGS84（4326）进行中转。
示例
-- WGS84 转 GCJ02（使用文本字面量）
SELECT ST_EvilTransform(ST_SetSRID('POINT(120 30)'::geometry, 4326), 'GCJ02');
-- WGS84 转 BD09（使用文本字面量）
SELECT ST_EvilTransform(ST_SetSRID('POINT(120 30)'::geometry, 4326), 'BD09');
-- WGS84 转 GCJ02（使用数字 SRID）
SELECT ST_EvilTransform(ST_SetSRID('POINT(120 30)'::geometry, 4326), 990001);
-- BD09 转 Web Mercator
SELECT ST_EvilTransform(
ST_SetSRID('POINT(120.011070620552 30.0038830555128)'::geometry, 990002), 3857
);
-- from_proj / to_proj 重载
SELECT ST_EvilTransform('POINT(120 30)'::geometry, 'EPSG:4326', 'GCJ02');
性能
在 PG18 上处理 200,000 行数据时，ST_EvilTransform 比基于正则表达式的 SQL 方法快约 30-45 倍。
31 - pg_geohash
使用GeoHash处理空间坐标的函数包
概览
| ID | 扩展名 | Bin | Lib | Load | Create | Trust | Reloc | 模式 |
|---|
| 1590 | pg_geohash | 否 | 是 | 否 | 是 | 否 | 是 | - |
版本
构建
您可以使用 pig build 命令构建 pg_geohash 扩展的 RPM / DEB 包：
pig build pkg pg_geohash # 构建 RPM / DEB 包
安装
您可以直接安装 pg_geohash 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install pg_geohash; # 当前活跃 PG 版本安装
pig ext install -y pg_geohash -v 18 # PG 18
pig ext install -y pg_geohash -v 17 # PG 17
pig ext install -y pg_geohash -v 16 # PG 16
pig ext install -y pg_geohash -v 15 # PG 15
pig ext install -y pg_geohash -v 14 # PG 14
dnf install -y pg_geohash_18 # PG 18
dnf install -y pg_geohash_17 # PG 17
dnf install -y pg_geohash_16 # PG 16
dnf install -y pg_geohash_15 # PG 15
dnf install -y pg_geohash_14 # PG 14
apt install -y postgresql-18-pg-geohash # PG 18
apt install -y postgresql-17-pg-geohash # PG 17
apt install -y postgresql-16-pg-geohash # PG 16
apt install -y postgresql-15-pg-geohash # PG 15
apt install -y postgresql-14-pg-geohash # PG 14
创建扩展：
CREATE EXTENSION pg_geohash;
用法
pg_geohash: PostgreSQL 的 Geohash 函数
基于 C 实现的 PostgreSQL Geohash 函数（同时支持 HAWQ 和 Greenplum）。基于 libgeohash C 库。
Geohash 背景知识：维基百科：Geohash
函数
将经纬度编码为指定精度的 geohash 字符串：
SELECT LAT_LON_TO_GEOHASH_WITH_LEN(latitude, longitude, 5) AS geohash;
将经纬度编码为全精度的 geohash：
SELECT LAT_LON_TO_GEOHASH(latitude, longitude) AS geohash;
将 geohash 解码回经纬度：
SELECT GEOHASH_TO_LAT_LON('dp3w7') AS lat_lon;
示例
使用 5 字符精度（约 2.4km x 4.9km 网格）计算基于 geohash 的聚合：
SELECT LAT_LON_TO_GEOHASH_WITH_LEN(latitude, longitude, 5) AS geohash,
COUNT(*)
FROM crimes
GROUP BY 1
ORDER BY 2 DESC
LIMIT 10;
geohash | count
---------+-------
dp3w7 | 72404
dp3tt | 70713
dp3tw | 63642
dp3wm | 62332
dp3wk | 56467
从 geohash 恢复坐标：
SELECT location,
GEOHASH_TO_LAT_LON(LAT_LON_TO_GEOHASH(latitude, longitude))
FROM crimes
LIMIT 5;
32 - pghydro
PostgreSQL/PostGIS 排水网络分析核心扩展
概览
Lead row; package also ships pgh_raster, pgh_hgm, pgh_output, pgh_output_en_au, pgh_output_pt_br, and pgh_consistency.
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PIGSTY | 6.6 | 1817161514 | pghydro | plpgsql, postgis |
| RPM | PIGSTY | 6.6 | 1817161514 | pghydro_$v | postgis36_$v |
| DEB | PIGSTY | 6.6 | 1817161514 | postgresql-$v-pghydro | postgresql-$v-postgis-3 |
构建
您可以使用 pig build 命令构建 pghydro 扩展的 RPM / DEB 包：
pig build pkg pghydro # 构建 RPM / DEB 包
安装
您可以直接安装 pghydro 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install pghydro; # 当前活跃 PG 版本安装
pig ext install -y pghydro -v 18 # PG 18
pig ext install -y pghydro -v 17 # PG 17
pig ext install -y pghydro -v 16 # PG 16
pig ext install -y pghydro -v 15 # PG 15
pig ext install -y pghydro -v 14 # PG 14
dnf install -y pghydro_18 # PG 18
dnf install -y pghydro_17 # PG 17
dnf install -y pghydro_16 # PG 16
dnf install -y pghydro_15 # PG 15
dnf install -y pghydro_14 # PG 14
apt install -y postgresql-18-pghydro # PG 18
apt install -y postgresql-17-pghydro # PG 17
apt install -y postgresql-16-pghydro # PG 16
apt install -y postgresql-15-pghydro # PG 15
apt install -y postgresql-14-pghydro # PG 14
创建扩展：
CREATE EXTENSION pghydro CASCADE; -- 依赖: plpgsql, postgis
用法
来源: GitHub 仓库, README, releases
PgHydro 套件的主扩展。
PgHydro 在 PostGIS 和 PostgreSQL 之上提供排水网络分析与水资源决策支持。该项目覆盖河网建模、流向分析、Otto Pfafstetter 流域编码、上游与下游河段选择、距河口距离计算、上游汇水面积分析、河流等级以及流域层级等能力。
CREATE EXTENSION postgis;
CREATE EXTENSION postgis_raster;
CREATE EXTENSION pghydro;
CREATE EXTENSION pgh_raster;
CREATE EXTENSION pgh_hgm;
CREATE EXTENSION pgh_consistency;
CREATE EXTENSION pgh_output;
组件
pghydro 是核心的排水网络分析扩展。pgh_raster 使用从数字高程模型派生的水文产品。pgh_hgm 将 pghydro 与 pgh_raster 结合起来进行水文地貌分析。pgh_output 提供报表对象。pgh_consistency 增加 Pfafstetter 一致性检查。
环境要求
- PostgreSQL 9.1 或更高版本。
- PostGIS 3.x。
- PostGIS Raster。
说明
- README 表示 master 分支跟踪最新的小版本 6.6。
- CSV 中的主行对应核心
pghydro 包，但该仓库在同一发布树中还提供配套扩展。
33 - pgh_raster
PgHydro 栅格水文分析扩展
概览
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PIGSTY | 6.6 | 1817161514 | pghydro | plpgsql, postgis, postgis_raster, pghydro |
| RPM | PIGSTY | 6.6 | 1817161514 | pghydro_$v | postgis36_$v |
| DEB | PIGSTY | 6.6 | 1817161514 | postgresql-$v-pghydro | postgresql-$v-postgis-3 |
| OS / PG | PG18 | PG17 | PG16 | PG15 | PG14 |
|---|
| el8.x86_64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| el8.aarch64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| el9.x86_64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| el9.aarch64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| el10.x86_64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| el10.aarch64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| d12.x86_64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| d12.aarch64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| d13.x86_64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| d13.aarch64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| u22.x86_64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| u22.aarch64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| u24.x86_64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| u24.aarch64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
构建
您可以使用 pig build 命令构建 pghydro 扩展的 RPM / DEB 包：
pig build pkg pghydro # 构建 RPM / DEB 包
安装
您可以直接安装 pghydro 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install pghydro; # 当前活跃 PG 版本安装
pig ext install -y pghydro -v 18 # PG 18
pig ext install -y pghydro -v 17 # PG 17
pig ext install -y pghydro -v 16 # PG 16
pig ext install -y pghydro -v 15 # PG 15
pig ext install -y pghydro -v 14 # PG 14
dnf install -y pghydro_18 # PG 18
dnf install -y pghydro_17 # PG 17
dnf install -y pghydro_16 # PG 16
dnf install -y pghydro_15 # PG 15
dnf install -y pghydro_14 # PG 14
apt install -y postgresql-18-pghydro # PG 18
apt install -y postgresql-17-pghydro # PG 17
apt install -y postgresql-16-pghydro # PG 16
apt install -y postgresql-15-pghydro # PG 15
apt install -y postgresql-14-pghydro # PG 14
创建扩展：
CREATE EXTENSION pgh_raster CASCADE; -- 依赖: plpgsql, postgis, postgis_raster, pghydro
34 - pgh_hgm
PgHydro 水文地貌分析扩展
概览
Extension version is 2.2.6, shipped inside pghydro package version 6.6.
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PIGSTY | 2.2.6 | 1817161514 | pghydro | plpgsql, postgis, postgis_raster, pghydro, pgh_raster |
| RPM | PIGSTY | 6.6 | 1817161514 | pghydro_$v | postgis36_$v |
| DEB | PIGSTY | 6.6 | 1817161514 | postgresql-$v-pghydro | postgresql-$v-postgis-3 |
| OS / PG | PG18 | PG17 | PG16 | PG15 | PG14 |
|---|
| el8.x86_64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| el8.aarch64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| el9.x86_64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| el9.aarch64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| el10.x86_64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| el10.aarch64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| d12.x86_64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| d12.aarch64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| d13.x86_64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| d13.aarch64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| u22.x86_64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| u22.aarch64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| u24.x86_64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| u24.aarch64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
构建
您可以使用 pig build 命令构建 pghydro 扩展的 RPM / DEB 包：
pig build pkg pghydro # 构建 RPM / DEB 包
安装
您可以直接安装 pghydro 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install pghydro; # 当前活跃 PG 版本安装
pig ext install -y pghydro -v 18 # PG 18
pig ext install -y pghydro -v 17 # PG 17
pig ext install -y pghydro -v 16 # PG 16
pig ext install -y pghydro -v 15 # PG 15
pig ext install -y pghydro -v 14 # PG 14
dnf install -y pghydro_18 # PG 18
dnf install -y pghydro_17 # PG 17
dnf install -y pghydro_16 # PG 16
dnf install -y pghydro_15 # PG 15
dnf install -y pghydro_14 # PG 14
apt install -y postgresql-18-pghydro # PG 18
apt install -y postgresql-17-pghydro # PG 17
apt install -y postgresql-16-pghydro # PG 16
apt install -y postgresql-15-pghydro # PG 15
apt install -y postgresql-14-pghydro # PG 14
创建扩展：
CREATE EXTENSION pgh_hgm CASCADE; -- 依赖: plpgsql, postgis, postgis_raster, pghydro, pgh_raster
35 - pgh_output
PgHydro 输出与报表扩展
概览
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PIGSTY | 6.6 | 1817161514 | pghydro | plpgsql, postgis, pghydro |
| RPM | PIGSTY | 6.6 | 1817161514 | pghydro_$v | postgis36_$v |
| DEB | PIGSTY | 6.6 | 1817161514 | postgresql-$v-pghydro | postgresql-$v-postgis-3 |
| OS / PG | PG18 | PG17 | PG16 | PG15 | PG14 |
|---|
| el8.x86_64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| el8.aarch64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| el9.x86_64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| el9.aarch64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| el10.x86_64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| el10.aarch64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| d12.x86_64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| d12.aarch64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| d13.x86_64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| d13.aarch64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| u22.x86_64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| u22.aarch64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| u24.x86_64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| u24.aarch64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
构建
您可以使用 pig build 命令构建 pghydro 扩展的 RPM / DEB 包：
pig build pkg pghydro # 构建 RPM / DEB 包
安装
您可以直接安装 pghydro 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install pghydro; # 当前活跃 PG 版本安装
pig ext install -y pghydro -v 18 # PG 18
pig ext install -y pghydro -v 17 # PG 17
pig ext install -y pghydro -v 16 # PG 16
pig ext install -y pghydro -v 15 # PG 15
pig ext install -y pghydro -v 14 # PG 14
dnf install -y pghydro_18 # PG 18
dnf install -y pghydro_17 # PG 17
dnf install -y pghydro_16 # PG 16
dnf install -y pghydro_15 # PG 15
dnf install -y pghydro_14 # PG 14
apt install -y postgresql-18-pghydro # PG 18
apt install -y postgresql-17-pghydro # PG 17
apt install -y postgresql-16-pghydro # PG 16
apt install -y postgresql-15-pghydro # PG 15
apt install -y postgresql-14-pghydro # PG 14
创建扩展：
CREATE EXTENSION pgh_output CASCADE; -- 依赖: plpgsql, postgis, pghydro
36 - pgh_output_en_au
PgHydro 澳式英语输出扩展
概览
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PIGSTY | 6.6 | 1817161514 | pghydro | plpgsql, postgis, pghydro |
| RPM | PIGSTY | 6.6 | 1817161514 | pghydro_$v | postgis36_$v |
| DEB | PIGSTY | 6.6 | 1817161514 | postgresql-$v-pghydro | postgresql-$v-postgis-3 |
| OS / PG | PG18 | PG17 | PG16 | PG15 | PG14 |
|---|
| el8.x86_64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| el8.aarch64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| el9.x86_64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| el9.aarch64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| el10.x86_64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| el10.aarch64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| d12.x86_64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| d12.aarch64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| d13.x86_64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| d13.aarch64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| u22.x86_64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| u22.aarch64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| u24.x86_64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| u24.aarch64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
构建
您可以使用 pig build 命令构建 pghydro 扩展的 RPM / DEB 包：
pig build pkg pghydro # 构建 RPM / DEB 包
安装
您可以直接安装 pghydro 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install pghydro; # 当前活跃 PG 版本安装
pig ext install -y pghydro -v 18 # PG 18
pig ext install -y pghydro -v 17 # PG 17
pig ext install -y pghydro -v 16 # PG 16
pig ext install -y pghydro -v 15 # PG 15
pig ext install -y pghydro -v 14 # PG 14
dnf install -y pghydro_18 # PG 18
dnf install -y pghydro_17 # PG 17
dnf install -y pghydro_16 # PG 16
dnf install -y pghydro_15 # PG 15
dnf install -y pghydro_14 # PG 14
apt install -y postgresql-18-pghydro # PG 18
apt install -y postgresql-17-pghydro # PG 17
apt install -y postgresql-16-pghydro # PG 16
apt install -y postgresql-15-pghydro # PG 15
apt install -y postgresql-14-pghydro # PG 14
创建扩展：
CREATE EXTENSION pgh_output_en_au CASCADE; -- 依赖: plpgsql, postgis, pghydro
37 - pgh_output_pt_br
PgHydro 巴西葡语输出扩展
概览
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PIGSTY | 6.6 | 1817161514 | pghydro | plpgsql, postgis, pghydro |
| RPM | PIGSTY | 6.6 | 1817161514 | pghydro_$v | postgis36_$v |
| DEB | PIGSTY | 6.6 | 1817161514 | postgresql-$v-pghydro | postgresql-$v-postgis-3 |
| OS / PG | PG18 | PG17 | PG16 | PG15 | PG14 |
|---|
| el8.x86_64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| el8.aarch64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| el9.x86_64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| el9.aarch64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| el10.x86_64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| el10.aarch64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| d12.x86_64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| d12.aarch64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| d13.x86_64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| d13.aarch64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| u22.x86_64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| u22.aarch64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| u24.x86_64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| u24.aarch64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
构建
您可以使用 pig build 命令构建 pghydro 扩展的 RPM / DEB 包：
pig build pkg pghydro # 构建 RPM / DEB 包
安装
您可以直接安装 pghydro 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install pghydro; # 当前活跃 PG 版本安装
pig ext install -y pghydro -v 18 # PG 18
pig ext install -y pghydro -v 17 # PG 17
pig ext install -y pghydro -v 16 # PG 16
pig ext install -y pghydro -v 15 # PG 15
pig ext install -y pghydro -v 14 # PG 14
dnf install -y pghydro_18 # PG 18
dnf install -y pghydro_17 # PG 17
dnf install -y pghydro_16 # PG 16
dnf install -y pghydro_15 # PG 15
dnf install -y pghydro_14 # PG 14
apt install -y postgresql-18-pghydro # PG 18
apt install -y postgresql-17-pghydro # PG 17
apt install -y postgresql-16-pghydro # PG 16
apt install -y postgresql-15-pghydro # PG 15
apt install -y postgresql-14-pghydro # PG 14
创建扩展：
CREATE EXTENSION pgh_output_pt_br CASCADE; -- 依赖: plpgsql, postgis, pghydro
38 - pgh_consistency
PgHydro Pfafstetter 一致性检查扩展
概览
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PIGSTY | 6.6 | 1817161514 | pghydro | plpgsql, postgis, pghydro |
| RPM | PIGSTY | 6.6 | 1817161514 | pghydro_$v | postgis36_$v |
| DEB | PIGSTY | 6.6 | 1817161514 | postgresql-$v-pghydro | postgresql-$v-postgis-3 |
| OS / PG | PG18 | PG17 | PG16 | PG15 | PG14 |
|---|
| el8.x86_64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| el8.aarch64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| el9.x86_64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| el9.aarch64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| el10.x86_64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| el10.aarch64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| d12.x86_64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| d12.aarch64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| d13.x86_64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| d13.aarch64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| u22.x86_64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| u22.aarch64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| u24.x86_64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
| u24.aarch64 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 | PIGSTY 6.6 |
构建
您可以使用 pig build 命令构建 pghydro 扩展的 RPM / DEB 包：
pig build pkg pghydro # 构建 RPM / DEB 包
安装
您可以直接安装 pghydro 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install pghydro; # 当前活跃 PG 版本安装
pig ext install -y pghydro -v 18 # PG 18
pig ext install -y pghydro -v 17 # PG 17
pig ext install -y pghydro -v 16 # PG 16
pig ext install -y pghydro -v 15 # PG 15
pig ext install -y pghydro -v 14 # PG 14
dnf install -y pghydro_18 # PG 18
dnf install -y pghydro_17 # PG 17
dnf install -y pghydro_16 # PG 16
dnf install -y pghydro_15 # PG 15
dnf install -y pghydro_14 # PG 14
apt install -y postgresql-18-pghydro # PG 18
apt install -y postgresql-17-pghydro # PG 17
apt install -y postgresql-16-pghydro # PG 16
apt install -y postgresql-15-pghydro # PG 15
apt install -y postgresql-14-pghydro # PG 14
创建扩展：
CREATE EXTENSION pgh_consistency CASCADE; -- 依赖: plpgsql, postgis, pghydro
39 - mobilitydb
MobilityDB地理空间投影数据管理分析平台
概览
need another schema
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PGDG | 1.3.0 | 1817161514 | mobilitydb | postgis |
| DEB | PGDG | 1.3.0 | 1817161514 | postgresql-$v-mobilitydb | - |
安装
您可以直接安装 mobilitydb 扩展包的预置二进制包，首先确保 PGDG 仓库已经添加并启用：
pig repo add pgdg -u # 添加 PGDG 仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install mobilitydb; # 当前活跃 PG 版本安装
pig ext install -y mobilitydb -v 18 # PG 18
pig ext install -y mobilitydb -v 17 # PG 17
pig ext install -y mobilitydb -v 16 # PG 16
pig ext install -y mobilitydb -v 15 # PG 15
pig ext install -y mobilitydb -v 14 # PG 14
apt install -y postgresql-18-mobilitydb # PG 18
apt install -y postgresql-17-mobilitydb # PG 17
apt install -y postgresql-16-mobilitydb # PG 16
apt install -y postgresql-15-mobilitydb # PG 15
apt install -y postgresql-14-mobilitydb # PG 14
创建扩展：
CREATE EXTENSION mobilitydb CASCADE; -- 依赖: postgis
用法
mobilitydb: PostgreSQL 的时态与时空数据管理扩展
MobilityDB 通过时态和时空数据类型扩展了 PostgreSQL 和 PostGIS，实现了移动对象数据（如车辆轨迹、传感器读数和时变属性）的高效存储、索引和查询。
核心文档：
快速开始
MobilityDB 依赖 PostGIS。需要同时启用两个扩展：
CREATE EXTENSION PostGIS;
CREATE EXTENSION MobilityDB;
时态类型
MobilityDB 提供基础类型的时态变体：
| 时态类型 | 基础类型 | 描述 |
|---|
tbool | boolean | 时变布尔值 |
tint | integer | 时变整数 |
tfloat | float | 时变浮点数 |
ttext | text | 时变文本 |
tgeompoint | geometry(Point) | 时变几何点 |
tgeogpoint | geography(Point) | 时变地理点 |
时态子类型
每种时态类型根据值随时间变化的方式可用不同子类型表示：
| 子类型 | 描述 | 示例 |
|---|
| 瞬时值（Instant） | 单个时间戳上的单个值 | '25.5@2025-01-01 08:00' |
| 序列（Sequence） | 时间区间上的连续值 | '[25.5@08:00, 28.1@09:00, 30.0@10:00]' |
| 序列集（SequenceSet） | 不重叠序列的集合 | '{[25.5@08:00, 28.1@09:00], [30.0@11:00, 31.2@12:00]}' |
序列使用方括号表示包含 [ 或排除 ( 的边界，与 PostgreSQL 范围类型一致。
创建时态值
瞬时值：
SELECT tfloat '25.5@2025-06-01 08:00:00+00';
SELECT tgeompoint 'SRID=4326;Point(2.3522 48.8566)@2025-06-01 08:00:00+00';
序列值（连续插值）：
SELECT tfloat '[20.0@2025-06-01 08:00, 25.5@2025-06-01 09:00, 22.0@2025-06-01 10:00]';
离散序列（阶梯插值）：
SELECT tint 'Interp=Step;[10@2025-06-01 08:00, 20@2025-06-01 09:00, 15@2025-06-01 10:00]';
序列集值：
SELECT tfloat '{[20.0@08:00, 25.5@09:00], [22.0@11:00, 28.0@12:00]}';
通过组件构造：
SELECT tgeompoint_inst(ST_Point(2.3522, 48.8566, 4326), '2025-06-01 08:00+00');
SELECT tgeompoint_seq(ARRAY[
tgeompoint_inst(ST_Point(2.3522, 48.8566, 4326), '2025-06-01 08:00+00'),
tgeompoint_inst(ST_Point(2.2945, 48.8584, 4326), '2025-06-01 08:30+00'),
tgeompoint_inst(ST_Point(2.3364, 48.8606, 4326), '2025-06-01 09:00+00')
]);
时态操作
获取特定时间的值：
SELECT valueAtTimestamp(temp, '2025-06-01 08:30:00+00')
FROM (SELECT tfloat '[20.0@08:00, 30.0@09:00]' AS temp) t;
-- 返回 25.0（线性插值）
限制到特定时间段：
SELECT atTime(trip, tstzspan '[2025-06-01 08:00, 2025-06-01 09:00]')
FROM trips;
获取时态值的时间跨度：
SELECT duration(trip), startTimestamp(trip), endTimestamp(trip)
FROM trips;
时态比较：
-- 温度超过 30 度的时间段
SELECT atValue(temperature, true)
FROM (SELECT tfloat '[20@08:00, 35@09:00, 25@10:00]' #> 30.0 AS temperature) t;
时空操作
轨迹：将空间路径提取为几何体：
SELECT ST_AsText(trajectory(trip))
FROM trips
WHERE vehicle_id = 42;
速度计算：
-- 速度以每秒为单位（地理点为 m/s）
SELECT speed(trip)
FROM trips
WHERE vehicle_id = 42;
轨迹长度：
SELECT length(trip)
FROM trips
WHERE vehicle_id = 42;
时空边界框（stbox）：
-- 获取时空边界框
SELECT stbox(trip)
FROM trips;
-- 构造用于查询的 stbox
SELECT stbox(
ST_MakeEnvelope(2.2, 48.8, 2.4, 48.9, 4326),
tstzspan '[2025-06-01, 2025-06-02]'
);
空间限制：获取特定区域内的值：
-- 行程中位于某多边形内的部分
SELECT atGeometry(trip, ST_Buffer(ST_Point(2.35, 48.86, 4326), 0.01))
FROM trips;
两个时态点之间的距离：
SELECT distance(t1.trip, t2.trip)
FROM trips t1, trips t2
WHERE t1.vehicle_id = 1 AND t2.vehicle_id = 2;
最近接近距离和时间：
SELECT nearestApproachDistance(t1.trip, t2.trip),
nearestApproachInstant(t1.trip, t2.trip)
FROM trips t1, trips t2
WHERE t1.vehicle_id = 1 AND t2.vehicle_id = 2;
索引
MobilityDB 支持 GiST 和 SP-GiST 索引，用于高效的时态和时空查询。
SP-GiST 索引用于时态类型（时间维度）：
CREATE INDEX ON measurements USING spgist(temperature);
GiST 索引用于时空类型（空间 + 时间）：
CREATE INDEX ON trips USING gist(trip);
这些索引可以加速边界框查询、时态重叠检查和时空相交操作：
-- 使用 GiST 索引进行时空过滤
SELECT vehicle_id
FROM trips
WHERE trip && stbox(
ST_MakeEnvelope(2.2, 48.8, 2.4, 48.9, 4326),
tstzspan '[2025-06-01, 2025-06-02]'
);
示例：车辆追踪
存储和查询车辆 GPS 轨迹的完整示例：
CREATE TABLE vehicles (
vehicle_id INT PRIMARY KEY,
plate TEXT,
type TEXT
);
CREATE TABLE trips (
trip_id BIGSERIAL PRIMARY KEY,
vehicle_id INT REFERENCES vehicles(vehicle_id),
trip tgeompoint,
trip_date DATE
);
CREATE INDEX ON trips USING gist(trip);
-- 将行程插入为一系列 GPS 点
INSERT INTO trips (vehicle_id, trip, trip_date) VALUES (
1,
tgeompoint_seq(ARRAY[
tgeompoint_inst(ST_Point(2.3522, 48.8566, 4326), '2025-06-01 08:00+00'),
tgeompoint_inst(ST_Point(2.2945, 48.8584, 4326), '2025-06-01 08:15+00'),
tgeompoint_inst(ST_Point(2.3364, 48.8606, 4326), '2025-06-01 08:30+00'),
tgeompoint_inst(ST_Point(2.3488, 48.8534, 4326), '2025-06-01 08:45+00')
]),
'2025-06-01'
);
-- 车辆 1 在 08:20 的位置？
SELECT valueAtTimestamp(trip, '2025-06-01 08:20+00')
FROM trips WHERE vehicle_id = 1 AND trip_date = '2025-06-01';
-- 平均速度是多少？
SELECT twAvg(speed(trip))
FROM trips WHERE vehicle_id = 1 AND trip_date = '2025-06-01';
-- 总行驶距离
SELECT length(trip)
FROM trips WHERE vehicle_id = 1 AND trip_date = '2025-06-01';
-- 获取完整轨迹作为 LineString
SELECT ST_AsGeoJSON(trajectory(trip))
FROM trips WHERE vehicle_id = 1 AND trip_date = '2025-06-01';
示例：时空相交查询
查找在指定时间窗口内经过特定区域的所有行程：
-- 定义感兴趣区域：以埃菲尔铁塔为中心的圆形区域
WITH area AS (
SELECT ST_Buffer(ST_Point(2.2945, 48.8584, 4326)::geography, 500)::geometry AS geom
)
SELECT t.vehicle_id,
t.trip_date,
atGeometry(t.trip, a.geom) AS trip_in_area,
length(atGeometry(t.trip, a.geom)) AS distance_in_area
FROM trips t, area a
WHERE t.trip && stbox(
a.geom,
tstzspan '[2025-06-01 07:00+00, 2025-06-01 10:00+00]'
)
AND eIntersects(t.trip, a.geom)
ORDER BY t.trip_date;
聚合函数
MobilityDB 提供时态聚合函数：
-- 时态浮点数的时间加权平均
SELECT twAvg(temperature) FROM sensor_data WHERE sensor_id = 1;
-- 将多个时态点合并为一个
SELECT tUnion(trip) FROM trips WHERE vehicle_id = 1 AND trip_date = '2025-06-01';
-- 在每个时间戳上计算一组时态点的质心
SELECT tCentroid(trip) FROM trips WHERE trip_date = '2025-06-01';
40 - mobilitydb_datagen
MobilityDB随机数据生成函数
概览
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PGDG | 1.3.0 | 1817161514 | mobilitydb | mobilitydb |
| DEB | PGDG | 1.3.0 | 1817161514 | postgresql-$v-mobilitydb | - |
| OS / PG | PG18 | PG17 | PG16 | PG15 | PG14 |
|---|
| el8.x86_64 | PGDG MISS | PGDG MISS | PGDG MISS | PGDG MISS | PGDG MISS |
| el8.aarch64 | PGDG MISS | PGDG MISS | PGDG MISS | PGDG MISS | PGDG MISS |
| el9.x86_64 | PGDG MISS | PGDG MISS | PGDG MISS | PGDG MISS | PGDG MISS |
| el9.aarch64 | PGDG MISS | PGDG MISS | PGDG MISS | PGDG MISS | PGDG MISS |
| el10.x86_64 | PGDG MISS | PGDG MISS | PGDG MISS | PGDG MISS | PGDG MISS |
| el10.aarch64 | PGDG MISS | PGDG MISS | PGDG MISS | PGDG MISS | PGDG MISS |
| d12.x86_64 | PGDG 1.3.0 | PGDG 1.3.0 | PGDG 1.3.0 | PGDG 1.3.0 | PGDG 1.3.0 |
| d12.aarch64 | PGDG 1.3.0 | PGDG 1.3.0 | PGDG 1.3.0 | PGDG 1.3.0 | PGDG 1.3.0 |
| d13.x86_64 | PGDG 1.3.0 | PGDG 1.3.0 | PGDG 1.3.0 | PGDG 1.3.0 | PGDG 1.3.0 |
| d13.aarch64 | PGDG 1.3.0 | PGDG 1.3.0 | PGDG 1.3.0 | PGDG 1.3.0 | PGDG 1.3.0 |
| u22.x86_64 | PGDG MISS | PGDG 1.2.0 | PGDG 1.2.0 | PGDG 1.2.0 | PGDG 1.2.0 |
| u22.aarch64 | PGDG MISS | PGDG 1.2.0 | PGDG 1.2.0 | PGDG 1.2.0 | PGDG 1.2.0 |
| u24.x86_64 | PGDG 1.3.0 | PGDG 1.3.0 | PGDG 1.3.0 | PGDG 1.3.0 | PGDG 1.3.0 |
| u24.aarch64 | PGDG 1.3.0 | PGDG 1.3.0 | PGDG 1.3.0 | PGDG 1.3.0 | PGDG 1.3.0 |
安装
您可以直接安装 mobilitydb 扩展包的预置二进制包，首先确保 PGDG 仓库已经添加并启用：
pig repo add pgdg -u # 添加 PGDG 仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install mobilitydb; # 当前活跃 PG 版本安装
pig ext install -y mobilitydb -v 18 # PG 18
pig ext install -y mobilitydb -v 17 # PG 17
pig ext install -y mobilitydb -v 16 # PG 16
pig ext install -y mobilitydb -v 15 # PG 15
pig ext install -y mobilitydb -v 14 # PG 14
apt install -y postgresql-18-mobilitydb # PG 18
apt install -y postgresql-17-mobilitydb # PG 17
apt install -y postgresql-16-mobilitydb # PG 16
apt install -y postgresql-15-mobilitydb # PG 15
apt install -y postgresql-14-mobilitydb # PG 14
创建扩展：
CREATE EXTENSION mobilitydb_datagen CASCADE; -- 依赖: mobilitydb
用法
mobilitydb_datagen: MobilityDB 的合成移动数据生成器
MobilityDB DataGen 提供用于生成合成移动数据的函数，用于测试和基准测试 MobilityDB 工作负载。它可以创建随机的时态值，包括行程、轨迹和时变测量数据。
生成随机时态值
-- 在时间跨度内生成随机时态浮点数
SELECT random_tfloat(
'2025-06-01 00:00+00', '2025-06-02 00:00+00', -- 时间跨度
0.0, 100.0, -- 值范围
10 -- 瞬时值数量
);
-- 生成随机时态几何点（轨迹）
SELECT random_tgeompoint(
'2025-06-01 08:00+00', '2025-06-01 18:00+00', -- 时间跨度
ST_MakeEnvelope(2.2, 48.8, 2.4, 48.9, 4326), -- 空间范围
20 -- 瞬时值数量
);
生成测试数据集
批量创建测试数据用于行程查询基准测试：
INSERT INTO trips (vehicle_id, trip, trip_date)
SELECT
i,
random_tgeompoint(
'2025-06-01 08:00+00', '2025-06-01 18:00+00',
ST_MakeEnvelope(2.2, 48.8, 2.5, 48.9, 4326),
50
),
'2025-06-01'
FROM generate_series(1, 1000) AS i;
41 - tzf
快速根据GPS经纬度坐标查找时区
概览
| ID | 扩展名 | Bin | Lib | Load | Create | Trust | Reloc | 模式 |
|---|
| 1680 | tzf | 否 | 是 | 否 | 是 | 否 | 否 | - |
版本
构建
您可以使用 pig build 命令构建 pg_tzf 扩展的 RPM / DEB 包：
pig build pkg pg_tzf # 构建 RPM / DEB 包
安装
您可以直接安装 pg_tzf 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install pg_tzf; # 当前活跃 PG 版本安装
pig ext install -y pg_tzf -v 18 # PG 18
pig ext install -y pg_tzf -v 17 # PG 17
pig ext install -y pg_tzf -v 16 # PG 16
pig ext install -y pg_tzf -v 15 # PG 15
pig ext install -y pg_tzf -v 14 # PG 14
dnf install -y pg_tzf_18 # PG 18
dnf install -y pg_tzf_17 # PG 17
dnf install -y pg_tzf_16 # PG 16
dnf install -y pg_tzf_15 # PG 15
dnf install -y pg_tzf_14 # PG 14
apt install -y postgresql-18-tzf # PG 18
apt install -y postgresql-17-tzf # PG 17
apt install -y postgresql-16-tzf # PG 16
apt install -y postgresql-15-tzf # PG 15
apt install -y postgresql-14-tzf # PG 14
创建扩展：
用法
tzf: PostgreSQL 快速时区查找
根据坐标查找时区名称。基于 tzf-rs 构建，使用来自 timezone-boundary-builder 的时区边界数据。
函数
根据坐标（经度、纬度）查找时区：
SELECT tzf_tzname(116.3883, 39.9289) AS timezone;
-- Asia/Shanghai
批量查找坐标的时区：
SELECT unnest(
tzf_tzname_batch(
ARRAY[-74.0060, -118.2437, 139.6917],
ARRAY[40.7128, 34.0522, 35.6895]
)
) AS timezones;
-- America/New_York
-- America/Los_Angeles
-- Asia/Tokyo
根据点查找时区：
SELECT tzf_tzname_point(point(-74.0060, 40.7128)) AS timezone;
-- America/New_York
批量查找点的时区：
SELECT unnest(
tzf_tzname_batch_points(
ARRAY[
point(-74.0060, 40.7128),
point(-118.2437, 34.0522),
point(139.6917, 35.6895)
]
)
) AS timezones;
-- America/New_York
-- America/Los_Angeles
-- Asia/Tokyo
性能
| 函数 | TPS | 备注 |
|---|
tzf_tzname | ~17,700 | 单坐标查找 |
tzf_tzname_point | ~17,600 | 单点查找 |
tzf_tzname_batch | ~51 | 1000 个一批 ≈ ~51,000 TPS |
tzf_tzname_batch_points | ~32 | 1000 个一批 ≈ ~32,000 TPS |
42 - earthdistance
计算地球表面上的大圆距离
概览
版本
| PG18 | PG17 | PG16 | PG15 | PG14 |
|---|
| 1.2 | 1.2 | 1.2 | 1.2 | 1.2 |
安装
提示：这是 PostgreSQL 内核自带的 contrib 扩展
CREATE EXTENSION earthdistance;
用法
earthdistance: 地球表面大圆距离计算
earthdistance 模块提供两种计算地球表面大圆距离的方法。假设地球为完美球体（需要更高精度请使用 PostGIS）。
CREATE EXTENSION earthdistance CASCADE; -- 需要 cube
基于 Cube 的地球距离
数据以 cube 存储，使用 3 个坐标表示距地球中心的 x、y、z 距离。提供了基于 cube 类型的 earth 域。
函数
| 函数 | 说明 |
|---|
earth() → float8 | 返回假定的地球半径 |
sec_to_gc(float8) → float8 | 将直线（割线）距离转换为大圆距离 |
gc_to_sec(float8) → float8 | 将大圆距离转换为直线（割线）距离 |
ll_to_earth(float8, float8) → earth | 根据经纬度（度）返回位置 |
latitude(earth) → float8 | 返回纬度（度） |
longitude(earth) → float8 | 返回经度（度） |
earth_distance(earth, earth) → float8 | 返回两点之间的大圆距离 |
earth_box(earth, float8) → cube | 返回用于 cube @> 运算符索引搜索的框 |
示例
-- 纽约到伦敦的距离（米）
SELECT earth_distance(
ll_to_earth(40.7128, -74.0060),
ll_to_earth(51.5074, -0.1278)
);
-- 查找某位置 1000 米范围内的所有点（可使用索引）
SELECT *
FROM places
WHERE earth_box(ll_to_earth(40.7128, -74.0060), 1000) @> ll_to_earth(lat, lon);
基于 Point 的地球距离
将地球位置表示为 point 类型值，其中第一个分量是经度，第二个是纬度（度）。
运算符
| 运算符 | 说明 |
|---|
point <@> point → float8 | 两点之间的法定英里距离 |
示例
-- 法定英里距离
SELECT point(-74.0060, 40.7128) <@> point(-0.1278, 51.5074);
注意：单位固定为法定英里。基于 point 的方法在极点和 ±180° 经线附近有边界条件问题；基于 cube 的表示方式避免了这些不连续性。
43 - vector
向量数据类型和 ivfflat / hnsw 访问方法
概览
| ID | 扩展名 | Bin | Lib | Load | Create | Trust | Reloc | 模式 |
|---|
| 1800 | vector | 否 | 是 | 否 | 是 | 否 | 是 | - |
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PGDG | 0.8.2 | 1817161514 | pgvector | - |
| RPM | PGDG | 0.8.2 | 1817161514 | pgvector_$v | - |
| DEB | PGDG | 0.8.2 | 1817161514 | postgresql-$v-pgvector | - |
构建
您可以使用 pig build 命令构建 pgvector 扩展的 RPM 包：
pig build pkg pgvector # 构建 RPM 包
安装
您可以直接安装 pgvector 扩展包的预置二进制包，首先确保 PGDG 仓库已经添加并启用：
pig repo add pgdg -u # 添加 PGDG 仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install pgvector; # 当前活跃 PG 版本安装
pig ext install -y pgvector -v 18 # PG 18
pig ext install -y pgvector -v 17 # PG 17
pig ext install -y pgvector -v 16 # PG 16
pig ext install -y pgvector -v 15 # PG 15
pig ext install -y pgvector -v 14 # PG 14
dnf install -y pgvector_18 # PG 18
dnf install -y pgvector_17 # PG 17
dnf install -y pgvector_16 # PG 16
dnf install -y pgvector_15 # PG 15
dnf install -y pgvector_14 # PG 14
apt install -y postgresql-18-pgvector # PG 18
apt install -y postgresql-17-pgvector # PG 17
apt install -y postgresql-16-pgvector # PG 16
apt install -y postgresql-15-pgvector # PG 15
apt install -y postgresql-14-pgvector # PG 14
创建扩展：
用法
适用于 PostgreSQL 的开源向量相似性搜索扩展。将向量与其他数据存储在一起，支持：
- 精确与近似最近邻搜索
- 单精度、半精度、二进制和稀疏向量
- L2 距离、内积、余弦距离、L1 距离、汉明距离和 Jaccard 距离
- 任何具有 PostgreSQL 客户端的编程语言
此外还具备 ACID 合规性、时间点恢复（PITR）、JOIN 以及 PostgreSQL 的所有其他优秀特性
快速上手
启用扩展（在每个需要使用该扩展的数据库中执行一次）
创建一个 3 维向量列
CREATE TABLE items (id bigserial PRIMARY KEY, embedding vector(3));
插入向量
INSERT INTO items (embedding) VALUES ('[1,2,3]'), ('[4,5,6]');
按 L2 距离获取最近邻
SELECT * FROM items ORDER BY embedding <-> '[3,1,2]' LIMIT 5;
还支持内积（<#>）、余弦距离（<=>）和 L1 距离（<+>）
注意：<#> 返回的是负内积，因为 PostgreSQL 的索引扫描仅支持 ASC 排序的操作符
存储
创建一个带有向量列的新表
CREATE TABLE items (id bigserial PRIMARY KEY, embedding vector(3));
或者向已有表添加向量列
ALTER TABLE items ADD COLUMN embedding vector(3);
还支持半精度、二进制和稀疏向量
插入向量
INSERT INTO items (embedding) VALUES ('[1,2,3]'), ('[4,5,6]');
或使用 COPY 批量导入向量（示例）
COPY items (embedding) FROM STDIN WITH (FORMAT BINARY);
更新插入（Upsert）向量
INSERT INTO items (id, embedding) VALUES (1, '[1,2,3]'), (2, '[4,5,6]')
ON CONFLICT (id) DO UPDATE SET embedding = EXCLUDED.embedding;
更新向量
UPDATE items SET embedding = '[1,2,3]' WHERE id = 1;
删除向量
DELETE FROM items WHERE id = 1;
查询
获取某个向量的最近邻
SELECT * FROM items ORDER BY embedding <-> '[3,1,2]' LIMIT 5;
支持的距离函数：
<-> - L2 距离<#> - （负）内积<=> - 余弦距离<+> - L1 距离<~> - 汉明距离（二进制向量）<%> - Jaccard 距离（二进制向量）
获取某行的最近邻
SELECT * FROM items WHERE id != 1 ORDER BY embedding <-> (SELECT embedding FROM items WHERE id = 1) LIMIT 5;
获取指定距离范围内的行
SELECT * FROM items WHERE embedding <-> '[3,1,2]' < 5;
注意：配合 ORDER BY 和 LIMIT 使用才能利用索引
距离计算
获取距离值
SELECT embedding <-> '[3,1,2]' AS distance FROM items;
对于内积，需要乘以 -1（因为 <#> 返回的是负内积）
SELECT (embedding <#> '[3,1,2]') * -1 AS inner_product FROM items;
对于余弦相似度，使用 1 减去余弦距离
SELECT 1 - (embedding <=> '[3,1,2]') AS cosine_similarity FROM items;
聚合
计算向量平均值
SELECT AVG(embedding) FROM items;
按分组计算向量平均值
SELECT category_id, AVG(embedding) FROM items GROUP BY category_id;
索引
默认情况下，pgvector 执行精确最近邻搜索，提供完美的召回率。
可以添加索引来使用近似最近邻搜索，以牺牲部分召回率换取速度提升。与普通索引不同，添加近似索引后查询结果可能会有所变化。
支持的索引类型：
HNSW
HNSW 索引会创建一个多层图结构。相比 IVFFlat，它具有更好的查询性能（在速度与召回率的权衡上），但构建时间更长且占用更多内存。此外，由于没有像 IVFFlat 那样的训练步骤，HNSW 索引可以在表中没有数据时就创建。
为所需的每种距离函数添加索引。
L2 距离
CREATE INDEX ON items USING hnsw (embedding vector_l2_ops);
注意：halfvec 类型使用 halfvec_l2_ops，sparsevec 类型使用 sparsevec_l2_ops（其他距离函数同理）
内积
CREATE INDEX ON items USING hnsw (embedding vector_ip_ops);
余弦距离
CREATE INDEX ON items USING hnsw (embedding vector_cosine_ops);
L1 距离
CREATE INDEX ON items USING hnsw (embedding vector_l1_ops);
汉明距离
CREATE INDEX ON items USING hnsw (embedding bit_hamming_ops);
Jaccard 距离
CREATE INDEX ON items USING hnsw (embedding bit_jaccard_ops);
支持的类型：
vector - 最多 2,000 维halfvec - 最多 4,000 维bit - 最多 64,000 维sparsevec - 最多 1,000 个非零元素
索引选项
指定 HNSW 参数
m - 每层的最大连接数（默认 16）ef_construction - 构建图时动态候选列表的大小（默认 64）
CREATE INDEX ON items USING hnsw (embedding vector_l2_ops) WITH (m = 16, ef_construction = 64);
ef_construction 值越大，召回率越高，但索引构建时间和插入耗时也会相应增加。
查询选项
指定搜索时动态候选列表的大小（默认 40）
SET hnsw.ef_search = 100;
该值越大，召回率越高，但查询速度会相应下降。
在事务中使用 SET LOCAL 可以仅对单次查询生效
BEGIN;
SET LOCAL hnsw.ef_search = 100;
SELECT ...
COMMIT;
索引构建时间
当图结构能完全放入 maintenance_work_mem 时，索引构建速度会显著提升
SET maintenance_work_mem = '8GB';
当图结构无法再放入内存时，会显示如下提示
NOTICE: hnsw graph no longer fits into maintenance_work_mem after 100000 tuples
DETAIL: Building will take significantly more time.
HINT: Increase maintenance_work_mem to speed up builds.
注意：不要将 maintenance_work_mem 设置得过高以至于耗尽服务器内存
与其他索引类型一样，在加载完初始数据之后再创建索引会更快
还可以通过增加并行工作进程数来加速索引创建（默认 2 个）
SET max_parallel_maintenance_workers = 7; -- 加上 leader 进程
如果工作进程数较多，可能需要同时增大 max_parallel_workers（默认 8）
索引选项对构建时间也有显著影响（除非召回率偏低，否则使用默认值即可）
索引构建进度
查看索引构建进度
SELECT phase, round(100.0 * blocks_done / nullif(blocks_total, 0), 1) AS "%" FROM pg_stat_progress_create_index;
HNSW 的构建阶段：
initializingloading tuples
IVFFlat
IVFFlat 索引将向量划分到多个列表中，然后搜索与查询向量最接近的那些列表的子集。相比 HNSW，它构建速度更快且占用内存更少，但查询性能较低（在速度与召回率的权衡上）。
实现良好召回率的三个关键：
- 在表中已有一定数据之后再创建索引
- 选择合适的列表数量——对于不超过 100 万行的数据，可从
rows / 1000 开始；超过 100 万行的数据则使用 sqrt(rows) - 查询时指定合适的探针数（值越高召回率越好，值越低速度越快）——可从
sqrt(lists) 开始
为所需的每种距离函数添加索引。
L2 距离
CREATE INDEX ON items USING ivfflat (embedding vector_l2_ops) WITH (lists = 100);
注意：halfvec 类型使用 halfvec_l2_ops（其他距离函数同理）
内积
CREATE INDEX ON items USING ivfflat (embedding vector_ip_ops) WITH (lists = 100);
余弦距离
CREATE INDEX ON items USING ivfflat (embedding vector_cosine_ops) WITH (lists = 100);
汉明距离
CREATE INDEX ON items USING ivfflat (embedding bit_hamming_ops) WITH (lists = 100);
支持的类型：
vector - 最多 2,000 维halfvec - 最多 4,000 维bit - 最多 64,000 维
查询选项
指定探针数（默认 1）
该值越大，召回率越高，但速度会相应下降。可以将其设置为列表总数以实现精确最近邻搜索（此时查询规划器将不会使用索引）
在事务中使用 SET LOCAL 可以仅对单次查询生效
BEGIN;
SET LOCAL ivfflat.probes = 10;
SELECT ...
COMMIT;
索引构建时间
对于大表，可以通过增加并行工作进程数来加速索引创建（默认 2 个）
SET max_parallel_maintenance_workers = 7; -- 加上 leader 进程
如果工作进程数较多，可能还需要同时增大 max_parallel_workers（默认 8）
索引构建进度
查看索引构建进度
SELECT phase, round(100.0 * tuples_done / nullif(tuples_total, 0), 1) AS "%" FROM pg_stat_progress_create_index;
IVFFlat 的构建阶段：
initializingperforming k-meansassigning tuplesloading tuples
注意：% 仅在 loading tuples 阶段显示
过滤
有多种方式可以对带有 WHERE 子句的最近邻查询建立索引。
SELECT * FROM items WHERE category_id = 123 ORDER BY embedding <-> '[3,1,2]' LIMIT 5;
首先可以在过滤列上创建索引。在很多场景下，这可以提供快速的精确最近邻搜索。PostgreSQL 为此提供了多种索引类型：B-tree（默认）、hash、GiST、SP-GiST、GIN 和 BRIN。
CREATE INDEX ON items (category_id);
对于多列过滤，可以考虑使用多列索引。
CREATE INDEX ON items (location_id, category_id);
精确索引适用于匹配行数占比较低的条件。否则，近似索引可能效果更好。
CREATE INDEX ON items USING hnsw (embedding vector_l2_ops);
使用近似索引时，过滤是在索引扫描之后应用的。如果某个条件匹配 10% 的行，在 HNSW 默认 hnsw.ef_search 为 40 的情况下，平均只有 4 行会匹配。要获取更多行，请增大 hnsw.ef_search。
SET hnsw.ef_search = 200;
从 0.8.0 版本开始，可以启用迭代索引扫描，在需要时自动扫描索引的更多部分。
SET hnsw.iterative_scan = strict_order;
如果只按少数几个不同的值过滤，可以考虑使用部分索引。
CREATE INDEX ON items USING hnsw (embedding vector_l2_ops) WHERE (category_id = 123);
如果按大量不同的值过滤，可以考虑使用分区表。
CREATE TABLE items (embedding vector(3), category_id int) PARTITION BY LIST(category_id);
迭代索引扫描
使用近似索引时，带有过滤条件的查询可能返回较少的结果，因为过滤是在索引扫描之后应用的。从 0.8.0 版本开始，可以启用迭代索引扫描，它会自动扫描索引的更多部分，直到找到足够的结果（或达到 hnsw.max_scan_tuples 或 ivfflat.max_probes 的限制）。
迭代扫描可以使用严格排序或宽松排序。
严格排序确保结果按距离精确排序
SET hnsw.iterative_scan = strict_order;
宽松排序允许结果在距离排序上略有偏差，但能提供更好的召回率
SET hnsw.iterative_scan = relaxed_order;
# or
SET ivfflat.iterative_scan = relaxed_order;
使用宽松排序时，可以通过物化 CTE 来获得严格排序
WITH relaxed_results AS MATERIALIZED (
SELECT id, embedding <-> '[1,2,3]' AS distance FROM items WHERE category_id = 123 ORDER BY distance LIMIT 5
) SELECT * FROM relaxed_results ORDER BY distance + 0;
注意：PostgreSQL 17+ 需要 + 0
对于按距离过滤的查询，请使用物化 CTE 并将距离过滤条件放在 CTE 外部以获得最佳性能（这是由于 PostgreSQL 执行器的当前行为所致）
WITH nearest_results AS MATERIALIZED (
SELECT id, embedding <-> '[1,2,3]' AS distance FROM items ORDER BY distance LIMIT 5
) SELECT * FROM nearest_results WHERE distance < 5 ORDER BY distance;
注意：其他过滤条件请放在 CTE 内部
迭代扫描选项
由于扫描近似索引的大部分内容开销很大，因此提供了控制扫描何时终止的选项。
HNSW
指定最大访问元组数（默认 20,000）
SET hnsw.max_scan_tuples = 20000;
注意：该值为近似值，不影响初始扫描
指定最大可用内存量，以 work_mem 的倍数表示（默认 1）
SET hnsw.scan_mem_multiplier = 2;
注意：如果增大 hnsw.max_scan_tuples 未能改善召回率，可尝试增大此值
IVFFlat
指定最大探针数
SET ivfflat.max_probes = 100;
注意：如果该值低于 ivfflat.probes，则使用 ivfflat.probes 的值
向量类型
半精度向量
使用 halfvec 类型存储半精度向量
CREATE TABLE items (id bigserial PRIMARY KEY, embedding halfvec(3));
半精度索引
以半精度对向量建立索引，可以获得更小的索引体积
CREATE INDEX ON items USING hnsw ((embedding::halfvec(3)) halfvec_l2_ops);
获取最近邻
SELECT * FROM items ORDER BY embedding::halfvec(3) <-> '[1,2,3]' LIMIT 5;
二进制向量
使用 bit 类型存储二进制向量（示例）
CREATE TABLE items (id bigserial PRIMARY KEY, embedding bit(3));
INSERT INTO items (embedding) VALUES ('000'), ('111');
按汉明距离获取最近邻
SELECT * FROM items ORDER BY embedding <~> '101' LIMIT 5;
还支持 Jaccard 距离（<%>）
二进制量化
使用表达式索引进行二进制量化
CREATE INDEX ON items USING hnsw ((binary_quantize(embedding)::bit(3)) bit_hamming_ops);
按汉明距离获取最近邻
SELECT * FROM items ORDER BY binary_quantize(embedding)::bit(3) <~> binary_quantize('[1,-2,3]') LIMIT 5;
使用原始向量重新排序以提高召回率
SELECT * FROM (
SELECT * FROM items ORDER BY binary_quantize(embedding)::bit(3) <~> binary_quantize('[1,-2,3]') LIMIT 20
) ORDER BY embedding <=> '[1,-2,3]' LIMIT 5;
稀疏向量
使用 sparsevec 类型存储稀疏向量
CREATE TABLE items (id bigserial PRIMARY KEY, embedding sparsevec(5));
插入向量
INSERT INTO items (embedding) VALUES ('{1:1,3:2,5:3}/5'), ('{1:4,3:5,5:6}/5');
格式为 {索引1:值1,索引2:值2}/维度数，索引从 1 开始，与 SQL 数组一致
按 L2 距离获取最近邻
SELECT * FROM items ORDER BY embedding <-> '{1:3,3:1,5:2}/5' LIMIT 5;
混合搜索
结合 PostgreSQL 的全文搜索实现混合搜索。
SELECT id, content FROM items, plainto_tsquery('hello search') query
WHERE textsearch @@ query ORDER BY ts_rank_cd(textsearch, query) DESC LIMIT 5;
可以使用倒数排名融合（RRF）或交叉编码器来合并结果。
子向量索引
使用表达式索引对子向量建立索引
CREATE INDEX ON items USING hnsw ((subvector(embedding, 1, 3)::vector(3)) vector_cosine_ops);
按余弦距离获取最近邻
SELECT * FROM items ORDER BY subvector(embedding, 1, 3)::vector(3) <=> subvector('[1,2,3,4,5]'::vector, 1, 3) LIMIT 5;
使用完整向量重新排序以提高召回率
SELECT * FROM (
SELECT * FROM items ORDER BY subvector(embedding, 1, 3)::vector(3) <=> subvector('[1,2,3,4,5]'::vector, 1, 3) LIMIT 20
) ORDER BY embedding <=> '[1,2,3,4,5]' LIMIT 5;
性能
调优
使用 PgTune 等工具来设置 PostgreSQL 服务器参数的初始值。例如，shared_buffers 通常应设置为服务器内存的 25%。可以通过以下命令查找配置文件路径：
查看各项参数设置：
修改后需要重启 PostgreSQL 才能生效。
数据加载
使用 COPY 批量加载数据（示例）。
COPY items (embedding) FROM STDIN WITH (FORMAT BINARY);
为获得最佳性能，建议在加载完初始数据之后再创建索引。
索引
关于索引构建时间，参见 HNSW 和 IVFFlat。
在生产环境中，请使用并发方式创建索引以避免阻塞写操作。
CREATE INDEX CONCURRENTLY ...
查询
使用 EXPLAIN (ANALYZE, BUFFERS) 调试查询性能。
EXPLAIN (ANALYZE, BUFFERS) SELECT * FROM items ORDER BY embedding <-> '[3,1,2]' LIMIT 5;
精确搜索
对于没有索引的查询，可以增大 max_parallel_workers_per_gather 来加速。
SET max_parallel_workers_per_gather = 4;
如果向量已归一化为单位长度（如 OpenAI embeddings），使用内积可获得最佳性能。
SELECT * FROM items ORDER BY embedding <#> '[3,1,2]' LIMIT 5;
近似搜索
对于使用 IVFFlat 索引的查询，可以增加倒排列表数量来加速（会牺牲部分召回率）。
CREATE INDEX ON items USING ivfflat (embedding vector_l2_ops) WITH (lists = 1000);
清理（VACUUM）
HNSW 索引的 VACUUM 操作可能耗时较长。可以先重建索引来加速。
REINDEX INDEX CONCURRENTLY index_name;
VACUUM table_name;
监控
使用 pg_stat_statements 监控性能（需确保已将其添加到 shared_preload_libraries）。
CREATE EXTENSION pg_stat_statements;
查询最耗时的 SQL：
SELECT query, calls, ROUND((total_plan_time + total_exec_time) / calls) AS avg_time_ms,
ROUND((total_plan_time + total_exec_time) / 60000) AS total_time_min
FROM pg_stat_statements ORDER BY total_plan_time + total_exec_time DESC LIMIT 20;
通过对比近似搜索与精确搜索的结果来监控召回率。
BEGIN;
SET LOCAL enable_indexscan = off; -- 使用精确搜索
SELECT ...
COMMIT;
扩展
pgvector 的扩展方式与 PostgreSQL 相同。
纵向扩展：增加单个实例的内存、CPU 和存储容量。使用现有工具进行参数调优和性能监控。
横向扩展：使用只读副本，或使用 Citus 等方案进行分片（示例）。
语言支持
可以从任何具有 PostgreSQL 客户端的编程语言中使用 pgvector。甚至可以在一种语言中生成和存储向量，在另一种语言中进行查询。
常见问题
单张表最多能存储多少向量？
PostgreSQL 中非分区表默认上限为 32 TB。分区表可以有数千个该大小的分区。
是否支持复制？
是的，pgvector 使用预写式日志（WAL），支持流复制和时间点恢复（PITR）。
如果我想对超过 2,000 维的向量建立索引怎么办？
可以使用半精度向量或半精度索引来索引最多 4,000 维的向量，或使用二进制量化来索引最多 64,000 维的向量。其他方案包括子向量索引（需要模型支持）或降维。
能否在同一列中存储不同维度的向量？
可以使用 vector 作为类型（而非 vector(n)）。
CREATE TABLE embeddings (model_id bigint, item_id bigint, embedding vector, PRIMARY KEY (model_id, item_id));
但只能对维度相同的行创建索引（使用表达式索引和部分索引）：
CREATE INDEX ON embeddings USING hnsw ((embedding::vector(3)) vector_l2_ops) WHERE (model_id = 123);
查询方式：
SELECT * FROM embeddings WHERE model_id = 123 ORDER BY embedding::vector(3) <-> '[3,1,2]' LIMIT 5;
能否以更高精度存储向量？
可以使用 double precision[] 或 numeric[] 类型来存储更高精度的向量。
CREATE TABLE items (id bigserial PRIMARY KEY, embedding double precision[]);
-- PostgreSQL 数组使用 {} 而非 []
INSERT INTO items (embedding) VALUES ('{1,2,3}'), ('{4,5,6}');
可以选择添加检查约束，确保数据可以转换为 vector 类型并具有预期的维度。
ALTER TABLE items ADD CHECK (vector_dims(embedding::vector) = 3);
使用表达式索引建立索引（以较低精度）：
CREATE INDEX ON items USING hnsw ((embedding::vector(3)) vector_l2_ops);
查询方式：
SELECT * FROM items ORDER BY embedding::vector(3) <-> '[3,1,2]' LIMIT 5;
索引是否需要完全放入内存？
不需要，但与其他索引类型一样，索引能放入内存时性能通常更好。可以通过以下命令查看索引大小：
SELECT pg_size_pretty(pg_relation_size('index_name'));
故障排查
为什么查询没有使用索引？
查询需要同时包含 ORDER BY 和 LIMIT，且 ORDER BY 必须直接使用距离操作符的结果（不能是表达式），并且必须为升序排列。
-- 使用索引
ORDER BY embedding <=> '[3,1,2]' LIMIT 5;
-- 不使用索引
ORDER BY 1 - (embedding <=> '[3,1,2]') DESC LIMIT 5;
可以通过以下方式引导查询规划器使用索引：
BEGIN;
SET LOCAL enable_seqscan = off;
SELECT ...
COMMIT;
另外，如果表很小，全表扫描可能反而更快。
为什么查询没有使用并行表扫描？
查询规划器在成本估算中不考虑行外存储（TOAST），这可能导致串行扫描看起来成本更低。可以通过以下方式降低并行扫描的成本估算：
BEGIN;
SET LOCAL min_parallel_table_scan_size = 1;
SET LOCAL parallel_setup_cost = 1;
SELECT ...
COMMIT;
或者选择以内联方式存储向量：
ALTER TABLE items ALTER COLUMN embedding SET STORAGE PLAIN;
为什么添加 HNSW 索引后查询结果变少了？
结果数量受动态候选列表大小（hnsw.ef_search）的限制，默认值为 40。由于死元组或查询中的过滤条件，结果可能会更少。启用迭代索引扫描有助于解决此问题。
另外请注意，NULL 向量不会被索引（余弦距离的零向量也不会被索引）。
为什么添加 IVFFlat 索引后查询结果变少了？
很可能是在数据量相对于列表数量不足时就创建了索引。请先删除索引，等表中有更多数据后再重新创建。
结果数量也可能受探针数（ivfflat.probes）的限制。启用迭代索引扫描可以解决此问题。
另外请注意，NULL 向量不会被索引（余弦距离的零向量也不会被索引）。
参考
Vector 类型
每个向量占用 4 * 维度数 + 8 字节的存储空间。每个元素为单精度浮点数（类似于 PostgreSQL 中的 real 类型），所有元素必须为有限值（不允许 NaN、Infinity 或 -Infinity）。向量最多支持 16,000 维。
Vector 操作符
| 操作符 | 描述 | 引入版本 |
|---|
| + | 逐元素加法 | |
| - | 逐元素减法 | |
| * | 逐元素乘法 | 0.5.0 |
| || | 拼接 | 0.7.0 |
| <-> | 欧氏距离 | |
| <#> | 负内积 | |
| <=> | 余弦距离 | |
| <+> | 曼哈顿距离 | 0.7.0 |
Vector 函数
| 函数 | 描述 | 引入版本 |
|---|
| binary_quantize(vector) → bit | 二进制量化 | 0.7.0 |
| cosine_distance(vector, vector) → double precision | 余弦距离 | |
| inner_product(vector, vector) → double precision | 内积 | |
| l1_distance(vector, vector) → double precision | 曼哈顿距离 | 0.5.0 |
| l2_distance(vector, vector) → double precision | 欧氏距离 | |
| l2_normalize(vector) → vector | 欧氏范数归一化 | 0.7.0 |
| subvector(vector, integer, integer) → vector | 子向量 | 0.7.0 |
| vector_dims(vector) → integer | 维度数 | |
| vector_norm(vector) → double precision | 欧氏范数 | |
Vector 聚合函数
| 函数 | 描述 | 引入版本 |
|---|
| avg(vector) → vector | 平均值 | |
| sum(vector) → vector | 求和 | 0.5.0 |
Halfvec 类型
每个半精度向量占用 2 * 维度数 + 8 字节的存储空间。每个元素为半精度浮点数，所有元素必须为有限值（不允许 NaN、Infinity 或 -Infinity）。半精度向量最多支持 16,000 维。
Halfvec 操作符
| 操作符 | 描述 | 引入版本 |
|---|
| + | 逐元素加法 | 0.7.0 |
| - | 逐元素减法 | 0.7.0 |
| * | 逐元素乘法 | 0.7.0 |
| || | 拼接 | 0.7.0 |
| <-> | 欧氏距离 | 0.7.0 |
| <#> | 负内积 | 0.7.0 |
| <=> | 余弦距离 | 0.7.0 |
| <+> | 曼哈顿距离 | 0.7.0 |
Halfvec 函数
| 函数 | 描述 | 引入版本 |
|---|
| binary_quantize(halfvec) → bit | 二进制量化 | 0.7.0 |
| cosine_distance(halfvec, halfvec) → double precision | 余弦距离 | 0.7.0 |
| inner_product(halfvec, halfvec) → double precision | 内积 | 0.7.0 |
| l1_distance(halfvec, halfvec) → double precision | 曼哈顿距离 | 0.7.0 |
| l2_distance(halfvec, halfvec) → double precision | 欧氏距离 | 0.7.0 |
| l2_norm(halfvec) → double precision | 欧氏范数 | 0.7.0 |
| l2_normalize(halfvec) → halfvec | 欧氏范数归一化 | 0.7.0 |
| subvector(halfvec, integer, integer) → halfvec | 子向量 | 0.7.0 |
| vector_dims(halfvec) → integer | 维度数 | 0.7.0 |
Halfvec 聚合函数
| 函数 | 描述 | 引入版本 |
|---|
| avg(halfvec) → halfvec | 平均值 | 0.7.0 |
| sum(halfvec) → halfvec | 求和 | 0.7.0 |
Bit 类型
每个位向量占用 维度数 / 8 + 8 字节的存储空间。更多信息参见 PostgreSQL 文档。
Bit 操作符
| 操作符 | 描述 | 引入版本 |
|---|
| <~> | 汉明距离 | 0.7.0 |
| <%> | Jaccard 距离 | 0.7.0 |
Bit 函数
| 函数 | 描述 | 引入版本 |
|---|
| hamming_distance(bit, bit) → double precision | 汉明距离 | 0.7.0 |
| jaccard_distance(bit, bit) → double precision | Jaccard 距离 | 0.7.0 |
Sparsevec 类型
每个稀疏向量占用 8 * 非零元素数 + 16 字节的存储空间。每个元素为单精度浮点数，所有元素必须为有限值（不允许 NaN、Infinity 或 -Infinity）。稀疏向量最多支持 16,000 个非零元素。
Sparsevec 操作符
| 操作符 | 描述 | 引入版本 |
|---|
| <-> | 欧氏距离 | 0.7.0 |
| <#> | 负内积 | 0.7.0 |
| <=> | 余弦距离 | 0.7.0 |
| <+> | 曼哈顿距离 | 0.7.0 |
Sparsevec 函数
| 函数 | 描述 | 引入版本 |
|---|
| cosine_distance(sparsevec, sparsevec) → double precision | 余弦距离 | 0.7.0 |
| inner_product(sparsevec, sparsevec) → double precision | 内积 | 0.7.0 |
| l1_distance(sparsevec, sparsevec) → double precision | 曼哈顿距离 | 0.7.0 |
| l2_distance(sparsevec, sparsevec) → double precision | 欧氏距离 | 0.7.0 |
| l2_norm(sparsevec) → double precision | 欧氏范数 | 0.7.0 |
| l2_normalize(sparsevec) → sparsevec | 欧氏范数归一化 | 0.7.0 |
安装
Linux 与 Mac
编译安装扩展（支持 PostgreSQL 13+）
cd /tmp
git clone --branch v0.8.2 https://github.com/pgvector/pgvector.git
cd pgvector
make
make install # 可能需要 sudo
如果遇到问题，请参阅安装说明
也可以通过 Docker、Homebrew、PGXN、APT、Yum、pkg、APK 或 conda-forge 安装，Postgres.app 和许多托管服务商已预装此扩展。此外还有 GitHub Actions 的使用说明。
Windows
确保已安装 Visual Studio 中的 C++ 支持，并以管理员身份运行 x64 Native Tools Command Prompt for VS [版本]。然后使用 nmake 编译：
set "PGROOT=C:\Program Files\PostgreSQL\18"
cd %TEMP%
git clone --branch v0.8.2 https://github.com/pgvector/pgvector.git
cd pgvector
nmake /F Makefile.win
nmake /F Makefile.win install
如果遇到问题，请参阅安装说明
也可以通过 Docker 或 conda-forge 安装。
安装说明 - Linux 与 Mac
PostgreSQL 路径
如果机器上有多个 PostgreSQL 安装，请通过以下方式指定 pg_config 的路径：
export PG_CONFIG=/Library/PostgreSQL/18/bin/pg_config
然后重新执行安装步骤（如需要，在 make 前先执行 make clean）。如果 make install 需要 sudo，请使用：
sudo --preserve-env=PG_CONFIG make install
Mac 上常见的路径包括：
- EDB 安装器 -
/Library/PostgreSQL/18/bin/pg_config - Homebrew (arm64) -
/opt/homebrew/opt/postgresql@18/bin/pg_config - Homebrew (x86-64) -
/usr/local/opt/postgresql@18/bin/pg_config
注意：请将 18 替换为实际的 PostgreSQL 服务器版本
缺少头文件
如果编译报错 fatal error: postgres.h: No such file or directory，请确保服务器上已安装 PostgreSQL 开发文件。
对于 Ubuntu 和 Debian，使用：
sudo apt install postgresql-server-dev-18
注意：请将 18 替换为实际的 PostgreSQL 服务器版本
缺少 SDK
如果在 Mac 上编译失败且输出包含 warning: no such sysroot directory，说明 PostgreSQL 安装指向了一个已不存在的路径。
重新安装 PostgreSQL 即可修复此问题。
可移植性
默认情况下，pgvector 在某些平台上会使用 -march=native 编译以获得最佳性能。但如果要在其他机器上运行编译好的扩展，这可能导致 Illegal instruction 错误。
要以可移植方式编译，请使用：
安装说明 - Windows
缺少头文件
如果编译报错 Cannot open include file: 'postgres.h': No such file or directory，请确保 PGROOT 设置正确。
架构不匹配
如果编译报错 error C2196: case value '4' already used，请确保使用的是 x64 Native Tools Command Prompt。然后执行 nmake /F Makefile.win clean 并重新执行安装步骤。
缺少符号
如果在 PostgreSQL 17.0-17.2 版本上链接失败并提示 unresolved external symbol float_to_shortest_decimal_bufn，请升级到 PostgreSQL 17.3+。
权限问题
如果安装失败并提示 Access is denied，请以管理员身份重新执行安装步骤。
其他安装方式
Docker
获取 Docker 镜像：
docker pull pgvector/pgvector:pg18-trixie
该镜像在 PostgreSQL 镜像的基础上添加了 pgvector（请将 18 替换为实际的 PostgreSQL 服务器版本，使用方式相同）。
也可以手动构建镜像：
git clone --branch v0.8.2 https://github.com/pgvector/pgvector.git
cd pgvector
docker build --pull --build-arg PG_MAJOR=18 -t myuser/pgvector .
如果增大了 maintenance_work_mem，请确保 --shm-size 至少为该值，以避免并行 HNSW 索引构建时出错。
docker run --shm-size=1g ...
Homebrew
对于 Homebrew 安装的 PostgreSQL，可以使用：
注意：仅适用于 postgresql@18 和 postgresql@17
PGXN
从 PostgreSQL 扩展网络安装：
APT
Debian 和 Ubuntu 软件包可从 PostgreSQL APT 仓库获取。按照配置说明操作后执行：
sudo apt install postgresql-18-pgvector
注意：请将 18 替换为实际的 PostgreSQL 服务器版本
Yum
RPM 软件包可从 PostgreSQL Yum 仓库获取。按照对应发行版的配置说明操作后执行：
sudo yum install pgvector_18
# 或
sudo dnf install pgvector_18
注意：请将 18 替换为实际的 PostgreSQL 服务器版本
pkg
安装 FreeBSD 软件包：
pkg install postgresql17-pgvector
或通过 port 安装：
cd /usr/ports/databases/pgvector
make install
APK
安装 Alpine 软件包：
apk add postgresql-pgvector
conda-forge
对于 Conda 安装的 PostgreSQL，从 conda-forge 安装：
conda install -c conda-forge pgvector
该方式由 @mmcauliffe 社区维护
Postgres.app
下载 Postgres 15+ 的最新版本。
托管 PostgreSQL
pgvector 可在这些服务商上使用。
升级
安装最新版本（使用与初始安装相同的方式）。然后在每个需要升级的数据库中执行：
ALTER EXTENSION vector UPDATE;
可以通过以下命令查看当前数据库中的版本：
SELECT extversion FROM pg_extension WHERE extname = 'vector';
44 - vchord
使用Rust重写的高性能向量扩展
概览
| ID | 扩展名 | Bin | Lib | Load | Create | Trust | Reloc | 模式 |
|---|
| 1810 | vchord | 否 | 是 | 是 | 是 | 否 | 是 | - |
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PIGSTY | 1.1.1 | 1817161514 | vchord | vector |
| RPM | PIGSTY | 1.1.1 | 1817161514 | vchord_$v | pgvector_$v |
| DEB | PIGSTY | 1.1.1 | 1817161514 | postgresql-$v-vchord | postgresql-$v-pgvector |
构建
您可以使用 pig build 命令构建 vchord 扩展的 RPM / DEB 包：
pig build pkg vchord # 构建 RPM / DEB 包
安装
您可以直接安装 vchord 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install vchord; # 当前活跃 PG 版本安装
pig ext install -y vchord -v 18 # PG 18
pig ext install -y vchord -v 17 # PG 17
pig ext install -y vchord -v 16 # PG 16
pig ext install -y vchord -v 15 # PG 15
pig ext install -y vchord -v 14 # PG 14
dnf install -y vchord_18 # PG 18
dnf install -y vchord_17 # PG 17
dnf install -y vchord_16 # PG 16
dnf install -y vchord_15 # PG 15
dnf install -y vchord_14 # PG 14
apt install -y postgresql-18-vchord # PG 18
apt install -y postgresql-17-vchord # PG 17
apt install -y postgresql-16-vchord # PG 16
apt install -y postgresql-15-vchord # PG 15
apt install -y postgresql-14-vchord # PG 14
预加载配置：
shared_preload_libraries = 'vchord';
创建扩展：
CREATE EXTENSION vchord CASCADE; -- 依赖: vector
用法
将此扩展添加到 postgresql.conf 中的 shared_preload_libraries 配置项
CREATE EXTENSION vchord CASCADE;
在 embedding 列上创建索引：
CREATE INDEX ON gist_train USING vchordrq (embedding vector_l2_ops) WITH (options = $$
residual_quantization = true
[build.internal]
lists = [4096]
spherical_centroids = false
build_threads = 8
$$);
文档
查询
查询语句与 pgvector 完全相同。VectorChord 支持任意过滤操作以及 WHERE/JOIN 子句，就像 pgvecto.rs 的 VBASE 一样。
SELECT * FROM items ORDER BY embedding <-> '[3,1,2]' LIMIT 5;
支持的距离函数包括：
<-> - L2 距离<#> - （负）内积<=> - 余弦距离
由于 PostgreSQL 查询规划器的限制，我们无法直接支持类似 SELECT embedding <-> '[3,1,2]' as distance WHERE distance < 0.1 ORDER BY distance 的范围查询。
要查询特定距离范围内的向量，可以使用以下语法。
-- 查询特定距离范围内的向量
-- sphere(center, radius) 表示以 center 为圆心、radius 为半径的球体内的向量，即范围查询
-- <<->> 是 L2 距离，<<#>> 是内积，<<=>> 是余弦距离
SELECT vec FROM t WHERE vec <<->> sphere('[0.24, 0.24, 0.24]'::vector, 0.012)
查询性能调优
可以通过调整 probes 和 epsilon 参数来优化搜索性能：
-- 设置 probes 以控制扫描的列表数量。
-- 建议范围：总 `lists` 值的 3%–10%。
SET vchordrq.probes = 100;
-- 设置 epsilon 以控制重排序精度。
-- 值越小重排序越少速度越快，值越大召回率越高。
-- 建议范围：0.0–4.0。默认值为 1.9。
SET vchordrq.epsilon = 1.9;
以及 PostgreSQL 本身的设置：
-- 如果使用 SSD，将 `effective_io_concurrency` 设置为 200 以获得更快的磁盘 I/O。
SET effective_io_concurrency = 200;
-- 禁用 JIT（即时编译），因为它收益甚微（1–2%），
-- 且对单查询负载会增加额外开销。
SET jit = off;
-- 至少将总内存的 25% 分配给 `shared_buffers`。
-- 对于磁盘密集型负载，可以将其增加到总内存的 90%。使用网络存储时，建议禁用交换分区以避免 I/O 挂起。
-- 注意：此设置需要重启才能生效。
ALTER SYSTEM SET shared_buffers = '8GB';
索引预热
要预热索引，可以使用以下 SQL。在内存有限的情况下，这将显著提升性能。
-- vchordrq_prewarm(index_name::regclass) 将索引预热到共享缓冲区中
SELECT vchordrq_prewarm('gist_train_embedding_idx'::regclass);
索引构建时间
索引构建可以通过索引选项中的 build_threads 参数和 PostgreSQL 设置来实现并行化。使用以下设置优化并行度：
-- 将此值设置为可用于并行操作的 CPU 核心数。
SET max_parallel_maintenance_workers = 8;
SET max_parallel_workers = 8;
-- 调整工作进程总数。
-- 注意：此设置需要重启才能生效。
ALTER SYSTEM SET max_worker_processes = 8;
索引构建进度
可以通过查询 pg_stat_progress_create_index 视图来查看索引构建进度。
SELECT phase, round(100.0 * blocks_done / nullif(blocks_total, 0), 1) AS "%" FROM pg_stat_progress_create_index;
外部索引预计算
与纯 SQL 方式不同，外部索引预计算会先在外部进行聚类，然后将质心插入 PostgreSQL 表中。虽然过程更为复杂，但在大规模数据集（>500 万条）上，外部构建明显更快。
首先，需要使用 faiss、scikit-learn 或其他聚类库对向量进行聚类。
质心需要预先存储在一个任意名称的表中，该表包含 3 列：
- id（integer）：每个质心的 ID，必须唯一
- parent（integer，可为空）：每个质心的父 ID，普通聚类时应为 NULL
- vector（vector）：每个质心的向量表示，使用
pgvector 的 vector 类型
示例如下：
-- 创建质心表
CREATE TABLE public.centroids (id integer NOT NULL UNIQUE, parent integer, vector vector(768));
-- 插入质心数据
INSERT INTO public.centroids (id, parent, vector) VALUES (1, NULL, '{0.1, 0.2, 0.3, ..., 0.768}');
INSERT INTO public.centroids (id, parent, vector) VALUES (2, NULL, '{0.4, 0.5, 0.6, ..., 0.768}');
INSERT INTO public.centroids (id, parent, vector) VALUES (3, NULL, '{0.7, 0.8, 0.9, ..., 0.768}');
-- ...
-- 使用外部质心表创建索引
CREATE INDEX ON gist_train USING vchordrq (embedding vector_l2_ops) WITH (options = $$
[build.external]
table = 'public.centroids'
$$);
为了简化工作流程，我们提供了端到端的外部索引预计算脚本，详见 scripts。
限制
- 架构兼容性：快速扫描内核针对 x86_64 架构进行了优化。虽然可以在 aarch64 上运行，但性能可能较低。
构建
构建此扩展需要 clang-17+。
在 EL 8/9、Ubuntu 24.04 上可直接使用，但在 Ubuntu 22.04 / Debian 12 上需要手动安装。
例如，在 Ubuntu 22 / Debian 12 上安装 clang-18 并将其设置为默认的 clang：
curl --proto '=https' --tlsv1.2 -sSf https://apt.llvm.org/llvm.sh | bash -s -- 18
sudo update-alternatives --install /usr/bin/clang clang $(which clang-18) 255
45 - vectorscale
使用DiskANN算法对向量进行高效索引
概览
| ID | 扩展名 | Bin | Lib | Load | Create | Trust | Reloc | 模式 |
|---|
| 1820 | vectorscale | 否 | 是 | 否 | 是 | 否 | 否 | - |
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PIGSTY | 0.9.0 | 1817161514 | pgvectorscale | vector |
| RPM | PIGSTY | 0.9.0 | 1817161514 | pgvectorscale_$v | pgvector_$v |
| DEB | PIGSTY | 0.9.0 | 1817161514 | postgresql-$v-pgvectorscale | postgresql-$v-pgvector |
构建
您可以使用 pig build 命令构建 pgvectorscale 扩展的 RPM / DEB 包：
pig build pkg pgvectorscale # 构建 RPM / DEB 包
安装
您可以直接安装 pgvectorscale 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install pgvectorscale; # 当前活跃 PG 版本安装
pig ext install -y pgvectorscale -v 18 # PG 18
pig ext install -y pgvectorscale -v 17 # PG 17
pig ext install -y pgvectorscale -v 16 # PG 16
pig ext install -y pgvectorscale -v 15 # PG 15
pig ext install -y pgvectorscale -v 14 # PG 14
dnf install -y pgvectorscale_18 # PG 18
dnf install -y pgvectorscale_17 # PG 17
dnf install -y pgvectorscale_16 # PG 16
dnf install -y pgvectorscale_15 # PG 15
dnf install -y pgvectorscale_14 # PG 14
apt install -y postgresql-18-pgvectorscale # PG 18
apt install -y postgresql-17-pgvectorscale # PG 17
apt install -y postgresql-16-pgvectorscale # PG 16
apt install -y postgresql-15-pgvectorscale # PG 15
apt install -y postgresql-14-pgvectorscale # PG 14
创建扩展：
CREATE EXTENSION vectorscale CASCADE; -- 依赖: vector
用法
CREATE EXTENSION vectorscale CASCADE;
CREATE TABLE IF NOT EXISTS document_embedding (
id BIGINT PRIMARY KEY GENERATED BY DEFAULT AS IDENTITY,
metadata JSONB,
contents TEXT,
embedding VECTOR(1536)
);
-- 使用 diskann 索引方法创建向量索引
CREATE INDEX document_embedding_idx ON document_embedding
USING diskann (embedding);
-- 基于向量距离进行近似最近邻查询
SELECT *
FROM document_embedding
ORDER BY embedding <=> $1
LIMIT 10
46 - vectorize
在PostgreSQL中封装RAG向量检索服务
概览
| ID | 扩展名 | Bin | Lib | Load | Create | Trust | Reloc | 模式 |
|---|
| 1830 | vectorize | 否 | 是 | 是 | 是 | 否 | 否 | vectorize |
manually upgraded PGRX from 0.16.1 to 0.17.0 by Vonng; shared_preload_libraries should include vectorize and pg_cron.
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PIGSTY | 0.26.1 | 1817161514 | pg_vectorize | pg_cron, pgmq, vector |
| RPM | PIGSTY | 0.26.1 | 1817161514 | pg_vectorize_$v | pgmq_$v, pg_cron_$v, pgvector_$v |
| DEB | PIGSTY | 0.26.1 | 1817161514 | postgresql-$v-pg-vectorize | postgresql-$v-pgmq, postgresql-$v-pg-cron, postgresql-$v-pgvector |
构建
您可以使用 pig build 命令构建 pg_vectorize 扩展的 RPM / DEB 包：
pig build pkg pg_vectorize # 构建 RPM / DEB 包
安装
您可以直接安装 pg_vectorize 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install pg_vectorize; # 当前活跃 PG 版本安装
pig ext install -y pg_vectorize -v 18 # PG 18
pig ext install -y pg_vectorize -v 17 # PG 17
pig ext install -y pg_vectorize -v 16 # PG 16
pig ext install -y pg_vectorize -v 15 # PG 15
pig ext install -y pg_vectorize -v 14 # PG 14
dnf install -y pg_vectorize_18 # PG 18
dnf install -y pg_vectorize_17 # PG 17
dnf install -y pg_vectorize_16 # PG 16
dnf install -y pg_vectorize_15 # PG 15
dnf install -y pg_vectorize_14 # PG 14
apt install -y postgresql-18-pg-vectorize # PG 18
apt install -y postgresql-17-pg-vectorize # PG 17
apt install -y postgresql-16-pg-vectorize # PG 16
apt install -y postgresql-15-pg-vectorize # PG 15
apt install -y postgresql-14-pg-vectorize # PG 14
预加载配置：
shared_preload_libraries = 'pg_cron, vectorize';
创建扩展：
CREATE EXTENSION vectorize CASCADE; -- 依赖: pg_cron, pgmq, vector
用法
pg_vectorize：在 Postgres 上进行向量搜索的最简方式。
来源：README.md
一个 Postgres 扩展，自动化文本到嵌入向量的转换和编排，并提供与最流行 LLM 的集成。可以快速搭建和自动维护向量搜索、全文搜索和混合搜索，帮助你在 Postgres 上快速构建 RAG 和搜索引擎。
该项目重度依赖 pgvector（向量相似度搜索）、pgmq（后台工作进程编排）和 SentenceTransformers。
API 文档：https://chuckhend.github.io/pg_vectorize/
概览
pg_vectorize 提供两种方式为任意 Postgres 添加语义搜索、全文搜索和混合搜索，方便在 Postgres 上构建检索增强生成（RAG）。
模式概览：
- HTTP 服务器（适用于托管数据库）：运行一个独立服务连接 Postgres 并暴露 REST API（
POST /api/v1/table、GET /api/v1/search）。 - Postgres 扩展（SQL）：将扩展安装到 Postgres 中，使用
vectorize.table() 和 vectorize.search() 等 SQL 函数（需要 Postgres 的文件系统访问权限）。
快速开始 – HTTP 服务器
使用 docker compose 在本地运行 Postgres 和 HTTP 服务：
# 运行 Postgres、嵌入向量服务器和管理 API
docker compose up -d
将示例数据集加载到 Postgres（可选）：
psql postgres://postgres:postgres@localhost:5432/postgres -f server/sql/example.sql
通过 HTTP API 创建嵌入向量任务。这会为现有数据生成嵌入向量，并持续监控更新或新数据：
curl -X POST http://localhost:8080/api/v1/table -d '{
"job_name": "my_job",
"src_table": "my_products",
"src_schema": "public",
"src_columns": ["product_name", "description"],
"primary_key": "product_id",
"update_time_col": "updated_at",
"model": "sentence-transformers/all-MiniLM-L6-v2"
}' -H "Content-Type: application/json"
{"id":"16b80184-2e8e-4ee6-b7e2-1a068ff4b314"}
使用 HTTP API 搜索：
curl -G \
"http://localhost:8080/api/v1/search" \
--data-urlencode "job_name=my_job" \
--data-urlencode "query=camping backpack" \
--data-urlencode "limit=1" \
| jq .
[
{
"description": "Storage solution for carrying personal items on ones back",
"fts_rank": 1,
"price": 45.0,
"product_category": "accessories",
"product_id": 6,
"product_name": "Backpack",
"rrf_score": 0.03278688524590164,
"semantic_rank": 1,
"similarity_score": 0.6296013593673706,
"updated_at": "2025-10-05T00:14:39.220893+00:00"
}
]
选择哪种模式？
- 当 Postgres 是托管的（RDS、Cloud SQL 等）或无法安装扩展时，使用 HTTP 服务器。只需数据库中有
pgvector 即可，HTTP 服务单独运行。 - 当自托管 Postgres 且可以安装扩展时，使用 Postgres 扩展。提供数据库内体验和直接的 SQL API 进行向量化和 RAG。
快速开始 – Postgres 扩展（SQL）
CREATE EXTENSION vectorize CASCADE;
使用 vectorize.table() 创建嵌入向量任务，使用 vectorize.search() 直接从 SQL 进行语义搜索。
47 - pg_similarity
提供17种距离度量函数
概览
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | MIXED | 1.0 | 1817161514 | pg_similarity | - |
| RPM | PIGSTY | 1.0 | 1817161514 | pg_similarity_$v | - |
| DEB | PGDG | 1.0 | 1817161514 | postgresql-$v-similarity | - |
构建
您可以使用 pig build 命令构建 pg_similarity 扩展的 RPM 包：
pig build pkg pg_similarity # 构建 RPM 包
安装
您可以直接安装 pg_similarity 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install pg_similarity; # 当前活跃 PG 版本安装
pig ext install -y pg_similarity -v 18 # PG 18
pig ext install -y pg_similarity -v 17 # PG 17
pig ext install -y pg_similarity -v 16 # PG 16
pig ext install -y pg_similarity -v 15 # PG 15
pig ext install -y pg_similarity -v 14 # PG 14
dnf install -y pg_similarity_18 # PG 18
dnf install -y pg_similarity_17 # PG 17
dnf install -y pg_similarity_16 # PG 16
dnf install -y pg_similarity_15 # PG 15
dnf install -y pg_similarity_14 # PG 14
apt install -y postgresql-18-similarity # PG 18
apt install -y postgresql-17-similarity # PG 17
apt install -y postgresql-16-similarity # PG 16
apt install -y postgresql-15-similarity # PG 15
apt install -y postgresql-14-similarity # PG 14
创建扩展：
CREATE EXTENSION pg_similarity;
用法
pg_similarity：PostgreSQL 相似度查询支持。
来源：README.md
pg_similarity 是支持 PostgreSQL 相似度查询的扩展。实现与 RDBMS 紧密集成，定义了运算符，你可以使用 ~~~ 和 ~!~ 等代替传统运算符（= 和 <>）。
pg_similarity 有三个主要组件：
- 函数：实现文献中可用的相似度算法的函数集合。这些函数可作为 UDF 使用，并作为实现相似度运算符的基础；
- 运算符：基于相似度函数定义的运算符集合。它们使用相似度函数获取相似度阈值，并与用户定义的阈值比较以决定是否匹配；
- 会话变量：存储相似度函数参数的变量集合。这些变量可在运行时定义。
函数与运算符
该扩展支持一系列相似度算法。最知名的算法均已覆盖。请注意每种算法适用于特定领域。提供以下算法：
- L1 距离（又称城市街区距离或曼哈顿距离）
- 余弦距离
- Dice 系数
- 欧几里得距离
- 汉明距离
- Jaccard 系数
- Jaro 距离
- Jaro-Winkler 距离
- Levenshtein 距离
- 匹配系数
- Monge-Elkan 系数
- Needleman-Wunsch 系数
- 重叠系数
- Q-Gram 距离
- Smith-Waterman 系数
- Smith-Waterman-Gotoh 系数
- Soundex 距离
| 算法 | 函数 | 运算符 | 支持索引 | 参数 |
|---|
| L1 距离 | block(text, text) returns float8 | ~++ | 是 | pg_similarity.block_tokenizer, pg_similarity.block_threshold, pg_similarity.block_is_normalized |
| 余弦距离 | cosine(text, text) returns float8 | ~## | 是 | pg_similarity.cosine_tokenizer, pg_similarity.cosine_threshold, pg_similarity.cosine_is_normalized |
| Dice 系数 | dice(text, text) returns float8 | ~-~ | 是 | pg_similarity.dice_tokenizer, pg_similarity.dice_threshold, pg_similarity.dice_is_normalized |
| 欧几里得距离 | euclidean(text, text) returns float8 | ~!! | 是 | pg_similarity.euclidean_tokenizer, pg_similarity.euclidean_threshold, pg_similarity.euclidean_is_normalized |
| 汉明距离 | hamming(bit varying, bit varying) returns float8 / hamming_text(text, text) returns float8 | ~@~ | 否 | pg_similarity.hamming_threshold, pg_similarity.hamming_is_normalized |
| Jaccard 系数 | jaccard(text, text) returns float8 | ~?? | 是 | pg_similarity.jaccard_tokenizer, pg_similarity.jaccard_threshold, pg_similarity.jaccard_is_normalized |
| Jaro 距离 | jaro(text, text) returns float8 | ~%% | 否 | pg_similarity.jaro_threshold, pg_similarity.jaro_is_normalized |
| Jaro-Winkler 距离 | jarowinkler(text, text) returns float8 | ~@@ | 否 | pg_similarity.jarowinkler_threshold, pg_similarity.jarowinkler_is_normalized |
| Levenshtein 距离 | lev(text, text) returns float8 | ~== | 否 | pg_similarity.levenshtein_threshold, pg_similarity.levenshtein_is_normalized |
| 匹配系数 | matchingcoefficient(text, text) returns float8 | ~^^ | 是 | pg_similarity.matching_tokenizer, pg_similarity.matching_threshold, pg_similarity.matching_is_normalized |
| Monge-Elkan 系数 | mongeelkan(text, text) returns float8 | ~|| | 否 | pg_similarity.mongeelkan_tokenizer, pg_similarity.mongeelkan_threshold, pg_similarity.mongeelkan_is_normalized |
| Needleman-Wunsch 系数 | needlemanwunsch(text, text) returns float8 | ~#~ | 否 | pg_similarity.nw_threshold, pg_similarity.nw_is_normalized |
| 重叠系数 | overlapcoefficient(text, text) returns float8 | ~** | 是 | pg_similarity.overlap_tokenizer, pg_similarity.overlap_threshold, pg_similarity.overlap_is_normalized |
| Q-Gram 距离 | qgram(text, text) returns float8 | ~~~ | 是 | pg_similarity.qgram_threshold, pg_similarity.qgram_is_normalized |
| Smith-Waterman 系数 | smithwaterman(text, text) returns float8 | ~=~ | 否 | pg_similarity.sw_threshold, pg_similarity.sw_is_normalized |
| Smith-Waterman-Gotoh 系数 | smithwatermangotoh(text, text) returns float8 | ~!~ | 否 | pg_similarity.swg_threshold, pg_similarity.swg_is_normalized |
| Soundex 距离 | soundex(text, text) returns float8 | ~*~ | 否 | |
参数
多个参数控制 pg_similarity 函数和运算符的行为。可分为三类：
- tokenizer：控制字符串的分词方式。有效值为 alnum、gram、word 和 camelcase。所有 token 均为小写。默认为 alnum。
- alnum：分隔符为任何非字母数字字符。
- gram：n-gram 是使用逐一滑动技术提取的长度为 n 的子序列。
- word：分隔符为空白字符。
- camelcase：分隔符为大写字母，但大写字母也作为 token 的首字符。
- threshold：控制结果集的灵活程度。取值范围 0.0 到 1.0。默认为 0.7。
- normalized：控制相似度系数/距离是否归一化（在 0.0 和 1.0 之间）。默认为 true。
示例
运行时设置参数：
SHOW pg_similarity.levenshtein_threshold;
-- 0.7
SET pg_similarity.levenshtein_threshold TO 0.5;
SET pg_similarity.cosine_tokenizer TO camelcase;
SET pg_similarity.euclidean_is_normalized TO false;
示例用表：
CREATE TABLE foo (a text);
INSERT INTO foo VALUES('Euler'),('Oiler'),('Euler Taveira de Oliveira'),('Maria Taveira dos Santos'),('Carlos Santos Silva');
CREATE TABLE bar (b text);
INSERT INTO bar VALUES('Euler T. de Oliveira'),('Euller'),('Oliveira, Euler Taveira'),('Sr. Oliveira');
使用相似度函数
SELECT a, b, cosine(a,b), jaro(a, b), euclidean(a, b) FROM foo, bar;
使用 levenshtein 运算符 (~==)
SHOW pg_similarity.levenshtein_threshold;
-- 0.7
SELECT a, b, lev(a,b) FROM foo, bar WHERE a ~== b;
-- a | b | lev
-- ---------------------------+----------------------+----------
-- Euler | Euller | 0.833333
-- Euler Taveira de Oliveira | Euler T. de Oliveira | 0.76
SET pg_similarity.levenshtein_threshold TO 0.5;
SELECT a, b, lev(a,b) FROM foo, bar WHERE a ~== b;
-- a | b | lev
-- ---------------------------+----------------------+----------
-- Euler | Euller | 0.833333
-- Oiler | Euller | 0.5
-- Euler Taveira de Oliveira | Euler T. de Oliveira | 0.76
使用 qgram 运算符 (~~~)
SET pg_similarity.qgram_threshold TO 0.7;
SELECT a, b, qgram(a, b) FROM foo, bar WHERE a ~~~ b;
-- a | b | qgram
-- ---------------------------+-------------------------+----------
-- Euler | Euller | 0.8
-- Euler Taveira de Oliveira | Euler T. de Oliveira | 0.77551
-- Euler Taveira de Oliveira | Oliveira, Euler Taveira | 0.807692
比较不同运算符
SELECT * FROM bar WHERE b ~@@ 'euler'; -- jaro-winkler 运算符
SELECT * FROM bar WHERE b ~~~ 'euler'; -- qgram 运算符
SELECT * FROM bar WHERE b ~== 'euler'; -- levenshtein 运算符
SELECT * FROM bar WHERE b ~## 'euler'; -- cosine 运算符
48 - pg_rrf
混合检索的倒数排序融合函数
概览
| ID | 扩展名 | Bin | Lib | Load | Create | Trust | Reloc | 模式 |
|---|
| 1845 | pg_rrf | 否 | 是 | 否 | 是 | 否 | 否 | - |
manually upgraded PGRX from 0.16.1 to 0.17.0 by Vonng
版本
构建
您可以使用 pig build 命令构建 pg_rrf 扩展的 RPM / DEB 包：
pig build pkg pg_rrf # 构建 RPM / DEB 包
安装
您可以直接安装 pg_rrf 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install pg_rrf; # 当前活跃 PG 版本安装
pig ext install -y pg_rrf -v 17 # PG 17
pig ext install -y pg_rrf -v 16 # PG 16
pig ext install -y pg_rrf -v 15 # PG 15
pig ext install -y pg_rrf -v 14 # PG 14
dnf install -y pg_rrf_17 # PG 17
dnf install -y pg_rrf_16 # PG 16
dnf install -y pg_rrf_15 # PG 15
dnf install -y pg_rrf_14 # PG 14
apt install -y postgresql-17-pg-rrf # PG 17
apt install -y postgresql-16-pg-rrf # PG 16
apt install -y postgresql-15-pg-rrf # PG 15
apt install -y postgresql-14-pg-rrf # PG 14
创建扩展：
用法
来源: README 和 项目仓库。
pg_rrf 提供互惠排名融合（Reciprocal Rank Fusion，RRF）函数，用于混合检索场景下的分数融合。
它的重点是合并多个有序候选列表，而不需要手写 FULL OUTER JOIN / COALESCE 之类的连接逻辑。
核心函数
rrf(rank_a, rank_b, k)rrf3(rank_a, rank_b, rank_c, k)rrf_fuse(ids_a bigint[], ids_b bigint[], k int default 60)rrfn(ranks bigint[], k int)
README 还说明了这些分数辅助函数的行为：
- 缺失的排名会被忽略
<= 0 的排名会被忽略k <= 0 时会报错
示例
CREATE EXTENSION pg_rrf;
SELECT rrf(1, 2, 60) AS rrf_12;
SELECT rrf3(1, 2, 3, 60) AS rrf_123;
SELECT rrfn(ARRAY[1, 2, 3], 60) AS rrfn_123;
SELECT *
FROM rrf_fuse(ARRAY[10, 20, 30], ARRAY[20, 40], 60)
ORDER BY score DESC;
混合检索模式
上游 README 将 rrf_fuse 作为手工融合查询的替代方案：
WITH fused AS (
SELECT *
FROM rrf_fuse(
ARRAY(SELECT id FROM docs ORDER BY bm25_score DESC LIMIT 100),
ARRAY(SELECT id FROM docs ORDER BY embedding <=> :qvec LIMIT 100),
60
)
)
SELECT d.*, fused.score
FROM fused
JOIN docs d USING (id)
ORDER BY fused.score DESC
LIMIT 20;
需求
- PostgreSQL 14-17
- Docker 和 Docker Compose v2
README 说明构建与测试流程都在 Docker 中运行，因此该包工作流不依赖本地 PostgreSQL 或 Rust 工具链。
49 - smlar
高效的相似度搜索函数
概览
| ID | 扩展名 | Bin | Lib | Load | Create | Trust | Reloc | 模式 |
|---|
| 1850 | smlar | 否 | 是 | 否 | 是 | 否 | 是 | - |
fix pg18 break issue by https://github.com/Vonng/smlar
版本
构建
您可以使用 pig build 命令构建 smlar 扩展的 RPM / DEB 包：
pig build pkg smlar # 构建 RPM / DEB 包
安装
您可以直接安装 smlar 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install smlar; # 当前活跃 PG 版本安装
pig ext install -y smlar -v 18 # PG 18
pig ext install -y smlar -v 17 # PG 17
pig ext install -y smlar -v 16 # PG 16
pig ext install -y smlar -v 15 # PG 15
pig ext install -y smlar -v 14 # PG 14
dnf install -y smlar_18 # PG 18
dnf install -y smlar_17 # PG 17
dnf install -y smlar_16 # PG 16
dnf install -y smlar_15 # PG 15
dnf install -y smlar_14 # PG 14
apt install -y postgresql-18-smlar # PG 18
apt install -y postgresql-17-smlar # PG 17
apt install -y postgresql-16-smlar # PG 16
apt install -y postgresql-15-smlar # PG 15
apt install -y postgresql-14-smlar # PG 14
创建扩展：
用法
smlar：PostgreSQL 数组的高效相似度搜索。
来源：README
smlar 扩展提供 PostgreSQL 数组上的高效相似度搜索，支持可配置的相似度公式、GiST 和 GIN 索引，以及 TF/IDF 加权。
函数
float4 smlar(anyarray, anyarray)
计算两个数组的相似度。数组应为相同类型。
float4 smlar(anyarray, anyarray, bool useIntersect)
计算两个复合类型数组的相似度。复合类型格式如下：
CREATE TYPE type_name AS (element_name anytype, weight_name FLOAT4);
useIntersect 选项指定分母中仅使用交集元素。
float4 smlar(anyarray a, anyarray b, text formula)
通过给定公式计算两个数组的相似度。公式中的预定义变量：
N.i – 两个数组中的公共元素数量（交集）N.a – 第一个数组中的唯一元素数量N.b – 第二个数组中的唯一元素数量
示例：
SELECT smlar('{1,4,6}'::int[], '{5,4,6}');
SELECT smlar('{1,4,6}'::int[], '{5,4,6}', 'N.i / sqrt(N.a * N.b)');
-- 这两个调用是等价的。
anyarray % anyarray
如果数组的相似度大于阈值限制则返回 true。
text[] tsvector2textarray(tsvector)
将 tsvector 类型转换为文本数组。
anyarray array_unique(anyarray)
排序并去重数组。
float4 inarray(anyarray, anyelement)
如果第二个参数不存在于第一个参数中返回零，否则返回 1.0。
float4 inarray(anyarray, anyelement, float4, float4)
如果第二个参数不存在于第一个参数中返回第四个参数，否则返回第三个参数。
GUC 配置变量
smlar.threshold FLOAT
相似度低于阈值的数组不被 % 运算视为相似。
smlar.persistent_cache BOOL
全局统计缓存存储在事务无关的内存中。
smlar.type STRING
相似度公式类型：cosine（默认）、tfidf、overlap。
smlar.stattable STRING
存储集合级统计数据的表名。表应定义为：
CREATE TABLE table_name (
value data_type UNIQUE,
ndoc int4 (or bigint) NOT NULL CHECK (ndoc > 0)
);
值为 null 的行表示文档总数。仅用于 smlar.type = 'tfidf'。
smlar.tf_method STRING
词频计算方法。取值：
"n" – 简单计数（默认）"log" – 1 + log(n)"const" – TF 等于 1
仅用于 smlar.type = 'tfidf'。
smlar.idf_plus_one BOOL
如果为 false（默认），idf 计算为 log(d/df)。如果为 true，计算为 log(1+d/df)。仅用于 smlar.type = 'tfidf'。
强烈建议在 postgresql.conf 中添加：
smlar.threshold = 0.6 # 或其他 > 0 且 < 1 的值
GiST/GIN 索引支持
% 和 && 操作支持多种数组类型的 GiST 和 GIN 索引：
| 数组类型 | GIN 操作符类 | GiST 操作符类 |
|---|
bit[] | _bit_sml_ops | |
bytea[] | _bytea_sml_ops | _bytea_sml_ops |
char[] | _char_sml_ops | _char_sml_ops |
cidr[] | _cidr_sml_ops | _cidr_sml_ops |
date[] | _date_sml_ops | _date_sml_ops |
float4[] | _float4_sml_ops | _float4_sml_ops |
float8[] | _float8_sml_ops | _float8_sml_ops |
inet[] | _inet_sml_ops | _inet_sml_ops |
int2[] | _int2_sml_ops | _int2_sml_ops |
int4[] | _int4_sml_ops | _int4_sml_ops |
int8[] | _int8_sml_ops | _int8_sml_ops |
interval[] | _interval_sml_ops | _interval_sml_ops |
macaddr[] | _macaddr_sml_ops | _macaddr_sml_ops |
money[] | _money_sml_ops | |
numeric[] | _numeric_sml_ops | _numeric_sml_ops |
oid[] | _oid_sml_ops | _oid_sml_ops |
text[] | _text_sml_ops | _text_sml_ops |
time[] | _time_sml_ops | _time_sml_ops |
timestamp[] | _timestamp_sml_ops | _timestamp_sml_ops |
timestamptz[] | _timestamptz_sml_ops | _timestamptz_sml_ops |
timetz[] | _timetz_sml_ops | _timetz_sml_ops |
varbit[] | _varbit_sml_ops | |
varchar[] | _varchar_sml_ops | _varchar_sml_ops |
50 - pg_summarize
使用LLM对文本字段进行总结
概览
PG18 fix by https://github.com/Vonng/pg_summarize
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PIGSTY | 0.0.1 | 1817161514 | pg_summarize | - |
| RPM | PIGSTY | 0.0.1 | 1817161514 | pg_summarize_$v | - |
| DEB | PIGSTY | 0.0.1 | 1817161514 | postgresql-$v-pg-summarize | - |
构建
您可以使用 pig build 命令构建 pg_summarize 扩展的 RPM / DEB 包：
pig build pkg pg_summarize # 构建 RPM / DEB 包
安装
您可以直接安装 pg_summarize 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install pg_summarize; # 当前活跃 PG 版本安装
pig ext install -y pg_summarize -v 18 # PG 18
pig ext install -y pg_summarize -v 17 # PG 17
pig ext install -y pg_summarize -v 16 # PG 16
pig ext install -y pg_summarize -v 15 # PG 15
pig ext install -y pg_summarize -v 14 # PG 14
dnf install -y pg_summarize_18 # PG 18
dnf install -y pg_summarize_17 # PG 17
dnf install -y pg_summarize_16 # PG 16
dnf install -y pg_summarize_15 # PG 15
dnf install -y pg_summarize_14 # PG 14
apt install -y postgresql-18-pg-summarize # PG 18
apt install -y postgresql-17-pg-summarize # PG 17
apt install -y postgresql-16-pg-summarize # PG 16
apt install -y postgresql-15-pg-summarize # PG 15
apt install -y postgresql-14-pg-summarize # PG 14
创建扩展：
CREATE EXTENSION pg_summarize;
用法
pg_summarize：使用 LLM 进行文本摘要，基于 pgrx 构建。
来源：README.md
pg_summarize 是一个用 Rust（使用 pgrx）编写的 PostgreSQL 扩展，集成了 OpenAI API。它包含一个基础的 “Hello, pg_summarize!” 函数和一个使用 OpenAI 模型进行文本摘要的 summarize 函数。
快速开始
CREATE EXTENSION pg_summarize;
-- 测试 hello 函数
SELECT hello_pg_summarize();
-- hello_pg_summarize
-- ----------------------
-- Hello, pg_summarize
配置
该扩展从 PostgreSQL 设置中获取配置。使用 summarize 函数前需设置以下参数：
-- 设置 OpenAI API 密钥（必需）
ALTER SYSTEM SET pg_summarizer.api_key = 'your_openai_api_key';
-- 可选设置模型（默认：gpt-3.5-turbo）
ALTER SYSTEM SET pg_summarizer.model = 'gpt-3.5-turbo';
-- 或在会话级别设置提示词
SET pg_summarizer.prompt = 'Your custom prompt here';
-- 如果在 SYSTEM 级别设置，需重新加载配置
SELECT pg_reload_conf();
Summarize 函数
summarize 函数接受文本输入，发送到 OpenAI API，并返回摘要：
-- 摘要文本输入
SELECT summarize('<This is the text to be summarized.>');
-- 从现有数据创建摘要表
CREATE TABLE blogs_summary AS
SELECT blog_url, summarize(blogs_text)
FROM hexacluster_blogs;
-- 使用不同模型
SET pg_summarizer.model = 'gpt-4o';
CREATE TABLE blogs_summary_4o AS
SELECT blog_url, summarize(blogs_text)
FROM hexacluster_blogs;
工作原理
- 配置获取：
summarize 函数通过 current_setting() 从 PostgreSQL 获取设置（API 密钥、模型、提示词）。未找到设置时使用默认值。 - 默认提示词：内置提示词指示 AI 从
<text> 标签中摘要文本，重点简洁地捕获最重要的信息。 - API 调用：该函数向 OpenAI 聊天补全端点发送 POST 请求，包含配置的模型和提示词，返回摘要内容。
51 - pg_tiktoken
在PostgreSQL中计算OpenAI使用的Token数
概览
| ID | 扩展名 | Bin | Lib | Load | Create | Trust | Reloc | 模式 |
|---|
| 1870 | pg_tiktoken | 否 | 是 | 否 | 是 | 否 | 否 | - |
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PIGSTY | 0.0.1 | 1817161514 | pg_tiktoken | - |
| RPM | PIGSTY | 0.0.1 | 1817161514 | pg_tiktoken_$v | - |
| DEB | PIGSTY | 0.0.1 | 1817161514 | postgresql-$v-pg-tiktoken | - |
构建
您可以使用 pig build 命令构建 pg_tiktoken 扩展的 RPM / DEB 包：
pig build pkg pg_tiktoken # 构建 RPM / DEB 包
安装
您可以直接安装 pg_tiktoken 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install pg_tiktoken; # 当前活跃 PG 版本安装
pig ext install -y pg_tiktoken -v 18 # PG 18
pig ext install -y pg_tiktoken -v 17 # PG 17
pig ext install -y pg_tiktoken -v 16 # PG 16
pig ext install -y pg_tiktoken -v 15 # PG 15
pig ext install -y pg_tiktoken -v 14 # PG 14
dnf install -y pg_tiktoken_18 # PG 18
dnf install -y pg_tiktoken_17 # PG 17
dnf install -y pg_tiktoken_16 # PG 16
dnf install -y pg_tiktoken_15 # PG 15
dnf install -y pg_tiktoken_14 # PG 14
apt install -y postgresql-18-pg-tiktoken # PG 18
apt install -y postgresql-17-pg-tiktoken # PG 17
apt install -y postgresql-16-pg-tiktoken # PG 16
apt install -y postgresql-15-pg-tiktoken # PG 15
apt install -y postgresql-14-pg-tiktoken # PG 14
创建扩展：
CREATE EXTENSION pg_tiktoken;
用法
pg_tiktoken：用于 PostgreSQL 中 OpenAI 模型的 tiktoken 分词器。
来源：README.md
pg_tiktoken 是一个 PostgreSQL 扩展，使用 OpenAI 的 tiktoken 库提供输入分词功能。它允许你直接在 SQL 中计数和编码 token，这在处理 OpenAI 模型的输入长度限制时非常有用。
函数
tiktoken_count
计算给定编码或模型的 token 数量：
SELECT tiktoken_count('p50k_edit', 'A long time ago in a galaxy far, far away');
tiktoken_count
----------------
11
(1 row)
tiktoken_encode
获取给定编码或模型的 token ID：
SELECT tiktoken_encode('cl100k_base', 'A long time ago in a galaxy far, far away');
tiktoken_encode
----------------------------------------------------
{32,1317,892,4227,304,264,34261,3117,11,3117,3201}
(1 row)
tiktoken_count 和 tiktoken_encode 的第一个参数都可以接受编码名称或 OpenAI 模型名称。
支持的模型
| 编码名称 | OpenAI 模型 |
|---|
cl100k_base | ChatGPT 模型, text-embedding-ada-002 |
p50k_base | 代码模型, text-davinci-002, text-davinci-003 |
p50k_edit | 编辑模型如 text-davinci-edit-001, code-davinci-edit-001 |
r50k_base（或 gpt2） | GPT-3 模型如 davinci |
52 - pg4ml
PG4ML是一个机器学习框架
概览
| ID | 扩展名 | Bin | Lib | Load | Create | Trust | Reloc | 模式 |
|---|
| 1880 | pg4ml | 否 | 否 | 否 | 是 | 是 | 是 | - |
require python3
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PIGSTY | 2.0 | 1817161514 | pg4ml | plpgsql, tablefunc, cube, plpython3u |
| RPM | PIGSTY | 2.0 | 1817161514 | pg4ml_$v | - |
| DEB | PIGSTY | 2.0 | 1817161514 | postgresql-$v-pg4ml | - |
构建
您可以使用 pig build 命令构建 pg4ml 扩展的 RPM / DEB 包：
pig build pkg pg4ml # 构建 RPM / DEB 包
安装
您可以直接安装 pg4ml 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install pg4ml; # 当前活跃 PG 版本安装
pig ext install -y pg4ml -v 18 # PG 18
pig ext install -y pg4ml -v 17 # PG 17
pig ext install -y pg4ml -v 16 # PG 16
pig ext install -y pg4ml -v 15 # PG 15
pig ext install -y pg4ml -v 14 # PG 14
dnf install -y pg4ml_18 # PG 18
dnf install -y pg4ml_17 # PG 17
dnf install -y pg4ml_16 # PG 16
dnf install -y pg4ml_15 # PG 15
dnf install -y pg4ml_14 # PG 14
apt install -y postgresql-18-pg4ml # PG 18
apt install -y postgresql-17-pg4ml # PG 17
apt install -y postgresql-16-pg4ml # PG 16
apt install -y postgresql-15-pg4ml # PG 15
apt install -y postgresql-14-pg4ml # PG 14
创建扩展：
CREATE EXTENSION pg4ml CASCADE; -- 依赖: plpgsql, tablefunc, cube, plpython3u
用法
pg4ml：PostgreSQL 机器学习框架。
来源：README.md
pg4ml 是一个 PostgreSQL 扩展，完全在数据库内使用 PL/pgSQL 和 PL/Python 实现机器学习框架。它通过 SQL 提供矩阵运算、神经网络构建与训练、聚类算法和科学计算功能。
前置条件
- PostgreSQL >= 14，支持 Python3
- 依赖扩展：
plpgsql、tablefunc、cube、plpython3u
快速开始
CREATE EXTENSION pg4ml CASCADE;
-- 这也会创建所需的依赖：plpgsql, tablefunc, cube, plpython3u
功能特性
矩阵运算
框架在 sm_sc schema 下提供了全面的矩阵运算库：
- 逐元素运算：算术、比较、取整、拼接、布尔、位运算、复数和广播运算
- 矩阵运算：乘法、转置、翻转、旋转、拼接
- 构造：采样、替换、填充、字符匹配、随机生成
- 三角函数：矩阵上的广播运算
- 聚合：切片级聚合、矩阵级聚合、按切片值排序、定位极值位置
切片聚合示例
按垂直切片求平均（每组 2 行）：
SELECT sm_sc.fv_aggr_slice_avg(
array[[1.5, 11.5],
[2.1, 12.1],
[3.3, 13.3],
[4.3, 14.3],
[5.5, 15.5],
[6.1, 16.1]],
array[2, 1]
);
-- 返回: array[[1.8, 11.8],[3.8, 13.8],[5.8, 15.8]]
2x3 块上的最大池化：
SELECT sm_sc.fv_aggr_slice_max(
array[[2.3, 5.1, 8.2, 2.56, 3.33, -1.9],
[3.25, 6.4, 6.6, 6.9, -2.65, -4.6],
[-2.3, 5.1, -8.2, 2.56, -3.33, -1.9],
[3.25, -6.4, -6.6, 6.9, -2.65, -4.6]],
array[2, 3]
);
-- 返回: array[[8.2, 6.9],[5.1, 6.9]]
神经网络
框架支持深度神经网络的构建和训练：
- 节点和路径表：
sm_sc.tb_nn_node / sm_sc.tb_nn_path 用于定义网络结构 - 训练输入缓冲区：
sm_sc.tb_nn_train_input_buff 用于接收训练数据 - 任务管理：
sm_sc.tb_classify_task 用于部署和管理训练任务 - 激活函数、卷积、池化、Lambda 运算
- 损失函数、导数计算、反向传播
- 推理：
sm_sc.ft_nn_in_out 用于将测试/验证数据通过训练好的模型运行
聚类
- K-means++：通过
sm_sc.prc_kmeans_pp 过程 - DBSCAN：通过
sm_sc.prc_dbscan_pp 过程
两者都使用 sm_sc.tb_cluster_task 进行任务部署和管理。
科学计算
- 波形处理
- 计算图 JSON 序列化/反序列化
- 复数运算
- 线性代数
性能提示
- 启用调试模式：
SET session pg4ml._v_is_debug_check = '1'; - 矩阵乘法使用
plpython3u 调用 numpy 进行优化 - 调整 PostgreSQL 并行参数以支持多线程训练：
max_parallel_workers_per_gatherforce_parallel_modeparallel_setup_cost, parallel_tuple_cost
- 考虑使用
pg_strom 扩展进行 GPU 加速
53 - pgml
PostgresML：用SQL运行机器学习算法并训练模型
概览
| ID | 扩展名 | Bin | Lib | Load | Create | Trust | Reloc | 模式 |
|---|
| 1890 | pgml | 否 | 是 | 是 | 是 | 是 | 否 | pgml |
pgrx=0.12.9
版本
构建
您可以使用 pig build 命令构建 pgml 扩展的 RPM / DEB 包：
pig build pkg pgml # 构建 RPM / DEB 包
安装
您可以直接安装 pgml 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install pgml; # 当前活跃 PG 版本安装
pig ext install -y pgml -v 17 # PG 17
pig ext install -y pgml -v 16 # PG 16
pig ext install -y pgml -v 15 # PG 15
pig ext install -y pgml -v 14 # PG 14
dnf install -y pgml_17 # PG 17
dnf install -y pgml_16 # PG 16
dnf install -y pgml_15 # PG 15
dnf install -y pgml_14 # PG 14
apt install -y postgresql-17-pgml # PG 17
apt install -y postgresql-16-pgml # PG 16
apt install -y postgresql-15-pgml # PG 15
apt install -y postgresql-14-pgml # PG 14
预加载配置：
shared_preload_libraries = 'pgml';
创建扩展：
用法
在所有集群节点上安装 pgml 扩展及 Python 依赖后，即可在 PostgreSQL 集群中启用 pgml。
使用 patronictl 命令配置集群，将 pgml 添加到 shared_preload_libraries 中，并在 pgml.venv 中指定 venv 目录：
shared_preload_libraries: pgml, timescaledb, pg_stat_statements, auto_explain
pgml.venv: '/data/pgml'
完成后，重启数据库集群，然后使用 SQL 命令创建扩展：
CREATE EXTENSION vector; -- 建议同时安装 pgvector！
CREATE EXTENSION pgml; -- 在当前数据库中创建 PostgresML
SELECT pgml.version(); -- 打印 PostgresML 版本信息
如果一切正常，应当看到类似如下的输出：
# create extension pgml;
INFO: Python version: 3.11.2 (main, Oct 5 2023, 16:06:03) [GCC 8.5.0 20210514 (Red Hat 8.5.0-18)]
INFO: Scikit-learn 1.3.0, XGBoost 2.0.0, LightGBM 4.1.0, NumPy 1.26.1
CREATE EXTENSION
# SELECT pgml.version(); -- 打印 PostgresML 版本信息
version
---------
2.7.8
一切就绪！更多详情请参阅 PostgresML 官方文档：https://postgresml.org/docs/guides/use-cases/
54 - pg_search
ParadeDB BM25算法全文检索插件，ES全文检索
概览
| ID | 扩展名 | Bin | Lib | Load | Create | Trust | Reloc | 模式 |
|---|
| 2100 | pg_search | 否 | 是 | 是 | 是 | 否 | 否 | paradedb |
bm25 am conflicts with pg_textsearch; PG15-16 require shared_preload_libraries while PG17-18 do not.
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PIGSTY | 0.23.0 | 1817161514 | pg_search | - |
| RPM | PIGSTY | 0.23.0 | 1817161514 | pg_search_$v | - |
| DEB | PIGSTY | 0.23.0 | 1817161514 | postgresql-$v-pg-search | - |
构建
您可以使用 pig build 命令构建 pg_search 扩展的 DEB 包：
pig build pkg pg_search # 构建 DEB 包
安装
您可以直接安装 pg_search 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install pg_search; # 当前活跃 PG 版本安装
pig ext install -y pg_search -v 18 # PG 18
pig ext install -y pg_search -v 17 # PG 17
pig ext install -y pg_search -v 16 # PG 16
pig ext install -y pg_search -v 15 # PG 15
dnf install -y pg_search_18 # PG 18
dnf install -y pg_search_17 # PG 17
dnf install -y pg_search_16 # PG 16
dnf install -y pg_search_15 # PG 15
apt install -y postgresql-18-pg-search # PG 18
apt install -y postgresql-17-pg-search # PG 17
apt install -y postgresql-16-pg-search # PG 16
apt install -y postgresql-15-pg-search # PG 15
预加载配置：
shared_preload_libraries = 'pg_search';
创建扩展：
CREATE EXTENSION pg_search;
此扩展由 ParadeDB 团队开发，通过 PIGSTY 仓库分发
用法
README | Quickstart | Install docs
pg_search 是 ParadeDB 为 PostgreSQL 提供的全文检索扩展。它基于 Tantivy，为堆表提供 BM25 索引和查询能力。当前上游文档说明，它支持 PostgreSQL 15 及以上版本。
入门
安装文档强调一个关键要求：必须把 pg_search 加入 shared_preload_libraries，这样后台工作进程才能处理索引写入。
shared_preload_libraries = 'pg_search'
随后启用扩展：
CREATE EXTENSION pg_search;
ALTER SYSTEM SET paradedb.pg_search_telemetry TO 'off';
创建 BM25 索引
Quickstart 展示了在堆表上创建 BM25 索引的方式，且需要唯一键字段：
CREATE INDEX search_idx ON mock_items
USING bm25 (id, description, category, rating, in_stock, created_at, metadata, weight_range)
WITH (key_field='id');
现有文档强调，key_field 必须唯一，BM25 索引是搜索查询的核心访问方法。
查询
@@@ 操作符用于执行搜索查询：
SELECT description, rating, category
FROM mock_items
WHERE description @@@ 'keyboard' AND rating > 2
ORDER BY rating
LIMIT 5;
ParadeDB 还提供用于相关性评分和摘要高亮的辅助函数：
SELECT description, paradedb.score(id)
FROM mock_items
WHERE description @@@ 'keyboard'
ORDER BY paradedb.score(id) DESC
LIMIT 5;
SELECT description, paradedb.snippet(description), paradedb.score(id)
FROM mock_items
WHERE description @@@ 'keyboard'
ORDER BY paradedb.score(id) DESC
LIMIT 5;
短语搜索支持用引号包裹表达式：
SELECT description
FROM mock_items
WHERE description @@@ '"metal keyboard"';
文本配置
Quickstart 还展示了如何为文本字段配置分词器，例如英文词干提取：
CREATE INDEX search_idx ON mock_items
USING bm25 (id, (description::pdb.simple('stemmer=english')), category)
WITH (key_field='id');
更深入的部署和运行说明请参考上游 ParadeDB 文档站，它是该项目的主文档入口。
55 - pgroonga
使用Groonga，面向所有语言的高速全文检索平台
概览
require xxHash vendor repo to build
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PIGSTY | 4.0.4 | 1817161514 | pgroonga | - |
| RPM | PIGSTY | 4.0.4 | 1817161514 | pgroonga_$v | groonga-libs |
| DEB | PIGSTY | 4.0.4 | 1817161514 | postgresql-$v-pgroonga | libgroonga0 |
构建
您可以使用 pig build 命令构建 pgroonga 扩展的 RPM / DEB 包：
pig build pkg pgroonga # 构建 RPM / DEB 包
安装
您可以直接安装 pgroonga 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install pgroonga; # 当前活跃 PG 版本安装
pig ext install -y pgroonga -v 18 # PG 18
pig ext install -y pgroonga -v 17 # PG 17
pig ext install -y pgroonga -v 16 # PG 16
pig ext install -y pgroonga -v 15 # PG 15
pig ext install -y pgroonga -v 14 # PG 14
dnf install -y pgroonga_18 # PG 18
dnf install -y pgroonga_17 # PG 17
dnf install -y pgroonga_16 # PG 16
dnf install -y pgroonga_15 # PG 15
dnf install -y pgroonga_14 # PG 14
apt install -y postgresql-18-pgroonga # PG 18
apt install -y postgresql-17-pgroonga # PG 17
apt install -y postgresql-16-pgroonga # PG 16
apt install -y postgresql-15-pgroonga # PG 15
apt install -y postgresql-14-pgroonga # PG 14
创建扩展：
CREATE EXTENSION pgroonga;
用法
以下是一个关于如何使用 PGroonga 的快速教程：
CREATE EXTENSION IF NOT EXISTS pgroonga;
CREATE TABLE memos
(
id integer,
content text
);
CREATE INDEX pgroonga_content_index ON memos USING pgroonga (content);
INSERT INTO memos VALUES (1, 'PostgreSQL is a relational database management system.');
INSERT INTO memos VALUES (2, 'Groonga is a fast full text search engine that supports all languages.');
INSERT INTO memos VALUES (3, 'PGroonga is a PostgreSQL extension that uses Groonga as index.');
INSERT INTO memos VALUES (4, 'There is groonga command.');
SET enable_seqscan = off;
-- 现在让我们使用 pgroonga 进行查询
SELECT * FROM memos WHERE content &@ 'engine';
-- id | content
-- ----+------------------------------------------------------------------------
-- 2 | Groonga is a fast full text search engine that supports all languages.
-- (1 row)
SELECT * FROM memos WHERE content &@~ 'PGroonga OR PostgreSQL';
-- id | content
-- ----+----------------------------------------------------------------
-- 3 | PGroonga is a PostgreSQL extension that uses Groonga as index.
-- 1 | PostgreSQL is a relational database management system.
-- (2 rows)
SELECT * FROM memos WHERE content LIKE '%engine%';
-- id | content
-- ----+------------------------------------------------------------------------
-- 2 | Groonga is a fast full text search engine that supports all languages.
-- (1 row)
56 - pgroonga_database
PGGroonga 数据库管理模块
概览
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PIGSTY | 4.0.4 | 1817161514 | pgroonga | - |
| RPM | PIGSTY | 4.0.4 | 1817161514 | pgroonga_$v | groonga-libs |
| DEB | PIGSTY | 4.0.4 | 1817161514 | postgresql-$v-pgroonga | libgroonga0 |
| OS / PG | PG18 | PG17 | PG16 | PG15 | PG14 |
|---|
| el8.x86_64 | PIGSTY 4.0.4 | PIGSTY 4.0.4 | PIGSTY 4.0.4 | PIGSTY 4.0.4 | PIGSTY 4.0.4 |
| el8.aarch64 | PIGSTY 4.0.4 | PIGSTY 4.0.4 | PIGSTY 4.0.4 | PIGSTY 4.0.4 | PIGSTY 4.0.4 |
| el9.x86_64 | PIGSTY 4.0.4 | PIGSTY 4.0.4 | PIGSTY 4.0.4 | PIGSTY 4.0.4 | PIGSTY 4.0.4 |
| el9.aarch64 | PIGSTY 4.0.4 | PIGSTY 4.0.4 | PIGSTY 4.0.4 | PIGSTY 4.0.4 | PIGSTY 4.0.4 |
| el10.x86_64 | PIGSTY 4.0.4 | PIGSTY 4.0.4 | PIGSTY 4.0.4 | PIGSTY 4.0.4 | PIGSTY 4.0.4 |
| el10.aarch64 | PIGSTY 4.0.4 | PIGSTY 4.0.4 | PIGSTY 4.0.4 | PIGSTY 4.0.4 | PIGSTY 4.0.4 |
| d12.x86_64 | PIGSTY 4.0.4 | PIGSTY 4.0.4 | PIGSTY 4.0.4 | PIGSTY 4.0.4 | PIGSTY 4.0.4 |
| d12.aarch64 | PIGSTY 4.0.4 | PIGSTY 4.0.4 | PIGSTY 4.0.4 | PIGSTY 4.0.4 | PIGSTY 4.0.4 |
| d13.x86_64 | PIGSTY 4.0.4 | PIGSTY 4.0.4 | PIGSTY 4.0.4 | PIGSTY 4.0.4 | PIGSTY 4.0.4 |
| d13.aarch64 | PIGSTY 4.0.4 | PIGSTY 4.0.4 | PIGSTY 4.0.4 | PIGSTY 4.0.4 | PIGSTY 4.0.4 |
| u22.x86_64 | PIGSTY 4.0.4 | PIGSTY 4.0.4 | PIGSTY 4.0.4 | PIGSTY 4.0.4 | PIGSTY 4.0.4 |
| u22.aarch64 | PIGSTY 4.0.4 | PIGSTY 4.0.4 | PIGSTY 4.0.4 | PIGSTY 4.0.4 | PIGSTY 4.0.4 |
| u24.x86_64 | PIGSTY 4.0.4 | PIGSTY 4.0.4 | PIGSTY 4.0.4 | PIGSTY 4.0.4 | PIGSTY 4.0.4 |
| u24.aarch64 | PIGSTY 4.0.4 | PIGSTY 4.0.4 | PIGSTY 4.0.4 | PIGSTY 4.0.4 | PIGSTY 4.0.4 |
构建
您可以使用 pig build 命令构建 pgroonga 扩展的 RPM / DEB 包：
pig build pkg pgroonga # 构建 RPM / DEB 包
安装
您可以直接安装 pgroonga 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install pgroonga; # 当前活跃 PG 版本安装
pig ext install -y pgroonga -v 18 # PG 18
pig ext install -y pgroonga -v 17 # PG 17
pig ext install -y pgroonga -v 16 # PG 16
pig ext install -y pgroonga -v 15 # PG 15
pig ext install -y pgroonga -v 14 # PG 14
dnf install -y pgroonga_18 # PG 18
dnf install -y pgroonga_17 # PG 17
dnf install -y pgroonga_16 # PG 16
dnf install -y pgroonga_15 # PG 15
dnf install -y pgroonga_14 # PG 14
apt install -y postgresql-18-pgroonga # PG 18
apt install -y postgresql-17-pgroonga # PG 17
apt install -y postgresql-16-pgroonga # PG 16
apt install -y postgresql-15-pgroonga # PG 15
apt install -y postgresql-14-pgroonga # PG 14
创建扩展：
CREATE EXTENSION pgroonga_database;
用法
PGroonga 文档 | GitHub: pgroonga/pgroonga
pgroonga_database 是 PGroonga 项目的子扩展。它为 PGroonga 提供数据库管理功能，PGroonga 使 PostgreSQL 成为支持所有语言的快速全文搜索平台。
PGroonga 是一个全面的全文搜索解决方案，以 Groonga 作为后端。它开箱即用地支持所有语言（包括中日韩 CJK），并提供丰富功能：
- 支持所有语言的快速全文搜索
- 丰富的查询语法（查询语言、脚本语法）
- JSON 搜索
- 感知 HTML/XML 标签的高亮
- 相似搜索
- 同义词扩展
- 自动补全
- 查询日志分析
PGroonga 文档非常详尽，涵盖数百页。详细用法、API 参考、运算符、函数和调优指南请参见官方文档：
快速开始
CREATE EXTENSION pgroonga_database;
CREATE EXTENSION pgroonga;
-- 创建包含文本内容的表
CREATE TABLE memos (
id integer,
content text
);
-- 创建 PGroonga 索引
CREATE INDEX pgroonga_content_index ON memos USING pgroonga (content);
-- 插入数据
INSERT INTO memos VALUES (1, 'PostgreSQL is a relational database management system.');
INSERT INTO memos VALUES (2, 'Groonga is a fast full text search engine that supports all languages.');
INSERT INTO memos VALUES (3, 'PGroonga is a PostgreSQL extension that uses Groonga as its backend.');
-- 全文搜索
SELECT * FROM memos WHERE content &@~ 'PostgreSQL OR Groonga';
57 - pg_bigm
基于二字组的多语言全文检索扩展
概览
| ID | 扩展名 | Bin | Lib | Load | Create | Trust | Reloc | 模式 |
|---|
| 2120 | pg_bigm | 否 | 是 | 是 | 是 | 否 | 是 | - |
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | MIXED | 1.2 | 1817161514 | pg_bigm | - |
| RPM | PGDG | 1.2 | 1817161514 | pg_bigm_$v | - |
| DEB | PIGSTY | 1.2 | 1817161514 | postgresql-$v-pg-bigm | - |
构建
您可以使用 pig build 命令构建 pg_bigm 扩展的 RPM / DEB 包：
pig build pkg pg_bigm # 构建 RPM / DEB 包
安装
您可以直接安装 pg_bigm 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install pg_bigm; # 当前活跃 PG 版本安装
pig ext install -y pg_bigm -v 18 # PG 18
pig ext install -y pg_bigm -v 17 # PG 17
pig ext install -y pg_bigm -v 16 # PG 16
pig ext install -y pg_bigm -v 15 # PG 15
pig ext install -y pg_bigm -v 14 # PG 14
dnf install -y pg_bigm_18 # PG 18
dnf install -y pg_bigm_17 # PG 17
dnf install -y pg_bigm_16 # PG 16
dnf install -y pg_bigm_15 # PG 15
dnf install -y pg_bigm_14 # PG 14
apt install -y postgresql-18-pg-bigm # PG 18
apt install -y postgresql-17-pg-bigm # PG 17
apt install -y postgresql-16-pg-bigm # PG 16
apt install -y postgresql-15-pg-bigm # PG 15
apt install -y postgresql-14-pg-bigm # PG 14
预加载配置：
shared_preload_libraries = 'pg_bigm';
创建扩展：
CREATE EXTENSION pg_bigm;
用法
pg_bigm 文档 | GitHub: pgbigm/pg_bigm
pg_bigm 模块为 PostgreSQL 提供全文搜索能力。它允许用户创建 2-gram（bigram）索引，以加速全文搜索。
pg_bigm 采用 PostgreSQL License 发布，是一种宽松的开源许可证，和 BSD、MIT 类似。
功能特性
- Bigram 索引：为文本列创建 2-gram（bigram）GIN 索引
- 更快的 LIKE 搜索：加速
LIKE 查询，包括前缀、后缀和子串搜索 - 全语言支持：无需额外配置即可支持包括中文、日文、韩文在内的任意语言
- 简单 API：提供相似度搜索函数和运算符
函数与运算符
函数
| 函数 | 返回类型 | 说明 |
|---|
likequery(text) | text | 根据关键字生成全文搜索查询 |
show_bigm(text) | text[] | 显示给定字符串中的所有 2-gram |
pg_gin_pending_stats(regclass) | record | 返回 GIN 索引待处理列表中的页面数和元组数 |
运算符
| 运算符 | 说明 |
|---|
text =% text | 当左右操作数的相似度大于等于 pg_bigm.similarity_limit 时返回 true |
GUC 参数
| 参数 | 类型 | 默认值 | 说明 |
|---|
pg_bigm.last_update | text | - | 显示模块最后更新日期（只读） |
pg_bigm.enable_recheck | bool | on | 控制索引扫描期间是否执行复查 |
pg_bigm.gin_key_limit | int | 0 | 限制全文搜索使用的最大 bigram 数量，0 表示不限制 |
pg_bigm.similarity_limit | real | 0.3 | 设置 =% 运算符的最小相似度阈值 |
示例
基本全文搜索
-- 创建扩展
CREATE EXTENSION pg_bigm;
-- 创建含文本数据的表
CREATE TABLE documents (id serial PRIMARY KEY, content text);
INSERT INTO documents (content) VALUES
('PostgreSQL is a powerful database'),
('Full text search with bigram indexing'),
('Japanese text: 日本語テキスト検索');
-- 创建 bigram 索引
CREATE INDEX docs_bigm_idx ON documents USING gin (content gin_bigm_ops);
-- 使用 LIKE 搜索
SELECT * FROM documents WHERE content LIKE '%search%';
-- 使用 likequery 函数搜索
SELECT * FROM documents WHERE content LIKE likequery('database');
相似度搜索
-- 显示字符串的 bigram
SELECT show_bigm('PostgreSQL');
-- 相似度搜索
SET pg_bigm.similarity_limit = 0.2;
SELECT * FROM documents WHERE content =% 'database search';
与 pg_trgm 的比较
pg_bigm 相较于内置的 pg_trgm 有以下优势：
| 特性 | pg_bigm | pg_trgm |
|---|
| N-gram 类型 | 2-gram（bigram） | 3-gram（trigram） |
| 最小搜索字符串 | 1 个字符 | 3 个字符 |
| 非字母语言 | 完全支持 | 有限支持 |
| LIKE 搜索类型 | 前缀、后缀和子串 | 前缀、后缀和子串 |
更完整的高级用法和性能调优，请参见 pg_bigm 官方文档。
58 - zhparser
中文分词，全文搜索解析器
概览
| ID | 扩展名 | Bin | Lib | Load | Create | Trust | Reloc | 模式 |
|---|
| 2130 | zhparser | 否 | 是 | 否 | 是 | 否 | 是 | - |
版本
构建
您可以使用 pig build 命令构建 zhparser 扩展的 RPM / DEB 包：
pig build pkg zhparser # 构建 RPM / DEB 包
安装
您可以直接安装 zhparser 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install zhparser; # 当前活跃 PG 版本安装
pig ext install -y zhparser -v 18 # PG 18
pig ext install -y zhparser -v 17 # PG 17
pig ext install -y zhparser -v 16 # PG 16
pig ext install -y zhparser -v 15 # PG 15
pig ext install -y zhparser -v 14 # PG 14
dnf install -y zhparser_18 # PG 18
dnf install -y zhparser_17 # PG 17
dnf install -y zhparser_16 # PG 16
dnf install -y zhparser_15 # PG 15
dnf install -y zhparser_14 # PG 14
apt install -y postgresql-18-zhparser # PG 18
apt install -y postgresql-17-zhparser # PG 17
apt install -y postgresql-16-zhparser # PG 16
apt install -y postgresql-15-zhparser # PG 15
apt install -y postgresql-14-zhparser # PG 14
创建扩展：
CREATE EXTENSION zhparser;
用法
GitHub: amutu/zhparser
zhparser 是基于 SCWS（Simple Chinese Word Segmentation）分词库的 PostgreSQL 中文全文搜索扩展。
功能特性
- 为 PostgreSQL 全文搜索提供中文分词
- 基于 SCWS（简易中文分词）库
- 支持自定义词典（TXT 和 XDB 格式）
- 数据库级自定义词表（v2.1 起）
- 多个可调参数控制分词行为
快速开始
-- 创建扩展
CREATE EXTENSION zhparser;
-- 创建使用 zhparser 的文本搜索配置
CREATE TEXT SEARCH CONFIGURATION chinese (PARSER = zhparser);
-- 添加词类映射
ALTER TEXT SEARCH CONFIGURATION chinese ADD MAPPING FOR n,v,a,i,e,l WITH simple;
-- 测试中文分词
SELECT to_tsvector('chinese', '小明硕士毕业于中国科学院计算所，后在日本京都大学深造');
-- 创建表和中文全文搜索索引
CREATE TABLE articles (id serial PRIMARY KEY, title text, body text);
CREATE INDEX articles_body_idx ON articles
USING gin (to_tsvector('chinese', body));
-- 中文全文搜索查询
SELECT * FROM articles
WHERE to_tsvector('chinese', body) @@ to_tsquery('chinese', '中国');
配置参数
zhparser 提供多个 GUC 参数控制分词行为：
| 参数 | 默认值 | 说明 |
|---|
zhparser.punctuation_ignore | off | 忽略所有标点符号 |
zhparser.seg_with_duality | off | 对长词进行二元分词 |
zhparser.dict_in_memory | off | 将整个词典加载到内存 |
zhparser.multi_short | off | 短词复合分词 |
zhparser.multi_duality | off | 二元复合分词 |
zhparser.multi_zmain | off | 首次复合分词中的关键词 |
zhparser.multi_zall | off | 使用所有复合分词 |
词类
zhparser 支持 SCWS 的以下词类：
| 代码 | 说明 |
|---|
a | 形容词 |
b | 区别词 |
c | 连词 |
d | 副词 |
e | 叹词 |
f | 方位词 |
g | 词根 |
h | 前缀 |
i | 成语 |
j | 简称 |
k | 后缀 |
l | 临时习语 |
m | 数词 |
n | 名词 |
o | 拟声词 |
p | 介词 |
q | 量词 |
r | 代词 |
s | 处所词 |
t | 时间词 |
u | 助词 |
v | 动词 |
w | 标点符号 |
x | 未知 |
y | 语气词 |
z | 状态词 |
自定义词典
基于文件的词典
将自定义词典文件放在共享目录（通常为 $SHAREDIR/tsearch_data/）：
- TXT 格式：每行一个词
- XDB 格式：编译后的 SCWS 词典格式
自定义词典优先于内置词典。
数据库级自定义词（v2.1+）
-- 通过 zhparser 内置表添加自定义词
INSERT INTO zhparser.zhprs_custom_word VALUES ('中国科学院计算所');
-- 重新加载自定义词典（同步后需重新连接才能生效）
SELECT sync_zhprs_custom_word();
-- 验证带自定义词的分词结果
SELECT to_tsvector('chinese', '小明硕士毕业于中国科学院计算所');
Docker 快速启动
docker run --name pgzhparser -d \
-e POSTGRES_PASSWORD=somepassword \
zhparser/zhparser:bookworm-16
59 - pg_bestmatch
在数据库内生成BM25稀疏向量
概览
| ID | 扩展名 | Bin | Lib | Load | Create | Trust | Reloc | 模式 |
|---|
| 2140 | pg_bestmatch | 否 | 是 | 是 | 是 | 否 | 否 | bm_catalog |
manual updated pgrx by Vonng
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PIGSTY | 0.0.2 | 1817161514 | pg_bestmatch | - |
| RPM | PIGSTY | 0.0.2 | 1817161514 | pg_bestmatch_$v | - |
| DEB | PIGSTY | 0.0.2 | 1817161514 | postgresql-$v-pg-bestmatch | - |
构建
您可以使用 pig build 命令构建 pg_bestmatch 扩展的 RPM / DEB 包：
pig build pkg pg_bestmatch # 构建 RPM / DEB 包
安装
您可以直接安装 pg_bestmatch 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install pg_bestmatch; # 当前活跃 PG 版本安装
pig ext install -y pg_bestmatch -v 18 # PG 18
pig ext install -y pg_bestmatch -v 17 # PG 17
pig ext install -y pg_bestmatch -v 16 # PG 16
pig ext install -y pg_bestmatch -v 15 # PG 15
pig ext install -y pg_bestmatch -v 14 # PG 14
dnf install -y pg_bestmatch_18 # PG 18
dnf install -y pg_bestmatch_17 # PG 17
dnf install -y pg_bestmatch_16 # PG 16
dnf install -y pg_bestmatch_15 # PG 15
dnf install -y pg_bestmatch_14 # PG 14
apt install -y postgresql-18-pg-bestmatch # PG 18
apt install -y postgresql-17-pg-bestmatch # PG 17
apt install -y postgresql-16-pg-bestmatch # PG 16
apt install -y postgresql-15-pg-bestmatch # PG 15
apt install -y postgresql-14-pg-bestmatch # PG 14
预加载配置：
shared_preload_libraries = 'pg_bestmatch';
创建扩展：
CREATE EXTENSION pg_bestmatch;
用法
- 仓库：https://github.com/tensorchord/pg_bestmatch.rs
- 基准测试：https://hazyresearch.stanford.edu/blog/2024-05-20-m2-bert-retrieval
工作原理
- 通过
bm25_create(table_name, column_name, statistic_name); 基于文档集创建 BM25 统计信息，该操作会创建一个物化视图来记录统计数据。 - 使用
bm25_document_to_svector(statistic_name, passage) 生成文档的稀疏向量 - 查询时，使用
bm25_query_to_svector(statistic_name, query) 生成查询的稀疏向量 - 通过查询稀疏向量与文档稀疏向量的点积计算相关性得分
- 目前使用 HuggingFace 分词器和
bert-base-uncased 词汇表来进行分词。未来可能会支持更多分词器配置选项。
安装
CREATE EXTENSION pg_bestmatch;
SET search_path TO public, bm_catalog;
示例
以下是一个使用 Stanford LoCo 基准测试 数据集演示本扩展用法的完整工作流。
- 加载数据集。如果您想使用该数据集体验
pg_bestmatch，可以使用以下脚本。
wget https://huggingface.co/api/datasets/hazyresearch/LoCoV1-Documents/parquet/default/test/0.parquet -O documents.parquet
wget https://huggingface.co/api/datasets/hazyresearch/LoCoV1-Queries/parquet/default/test/0.parquet -O queries.parquet
import pandas as pd
from sqlalchemy import create_engine
import numpy as np
from psycopg2.extensions import register_adapter, AsIs
def adapter_numpy_float64(numpy_float64):
return AsIs(numpy_float64)
def adapter_numpy_int64(numpy_int64):
return AsIs(numpy_int64)
def adapter_numpy_float32(numpy_float32):
return AsIs(numpy_float32)
def adapter_numpy_int32(numpy_int32):
return AsIs(numpy_int32)
def adapter_numpy_array(numpy_array):
return AsIs(tuple(numpy_array))
register_adapter(np.float64, adapter_numpy_float64)
register_adapter(np.int64, adapter_numpy_int64)
register_adapter(np.float32, adapter_numpy_float32)
register_adapter(np.int32, adapter_numpy_int32)
register_adapter(np.ndarray, adapter_numpy_array)
db_url = "postgresql://localhost:5432/pg_bestmatch_test"
engine = create_engine(db_url)
def load_documents():
df = pd.read_parquet("documents.parquet")
df.to_sql("documents", engine, if_exists='replace', index=False)
def load_queries():
df = pd.read_parquet("queries.parquet")
df['answer_pids'] = df['answer_pids'].apply(lambda x: str(x[0]))
df.to_sql("queries", engine, if_exists='replace', index=False)
load_documents()
load_queries()
- 为
documents 表创建 BM25 统计信息。
SELECT bm25_create('documents', 'passage', 'documents_passage_bm25', 0.75, 1.2);
- 在
documents 和 queries 表中添加向量列，并更新文档和查询的向量表示。
ALTER TABLE documents ADD COLUMN embedding svector; -- pgvecto.rs 用户
ALTER TABLE documents ADD COLUMN embedding sparsevec; -- pgvector 用户
UPDATE documents SET embedding = bm25_document_to_svector('documents_passage_bm25', passage)::svector; -- pgvecto.rs 用户
UPDATE documents SET embedding = bm25_document_to_svector('documents_passage_bm25', passage, 'pgvector')::sparsevec; -- pgvector 用户
- （可选）在稀疏向量列上创建向量索引。
CREATE INDEX ON documents USING vectors (embedding svector_dot_ops); -- pgvecto.rs 用户
CREATE INDEX ON documents USING ivfflat (embedding sparsevec_ip_ops); -- pgvector 用户
- 执行向量搜索，为每个查询找到最相关的文档。
ALTER TABLE queries ADD COLUMN embedding svector; -- pgvecto.rs 用户
ALTER TABLE queries ADD COLUMN embedding sparsevec; -- pgvector 用户
UPDATE queries SET embedding = bm25_query_to_svector('documents_passage_bm25', query)::svector; -- pgvecto.rs 用户
UPDATE queries SET embedding = bm25_query_to_svector('documents_passage_bm25', query, 'pgvector')::sparsevec; -- pgvector 用户
SELECT sum((array[answer_pids] = array(SELECT pid FROM documents WHERE queries.dataset = documents.dataset ORDER BY queries.embedding <#> documents.embedding LIMIT 1))::int) FROM queries;
此工作流展示了如何利用本扩展在 PostgreSQL 中结合 BM25 文本查询与向量搜索。BM25 在该数据集上的 Top 1 召回率为 0.77。如果您能复现该结果，说明操作正确。
与 pg_search 的比较
pg_bestmatch.rs 仅提供生成稀疏向量的方法，不支持基于索引的搜索（可通过 pgvecto.rs 或 pgvector 实现）。pg_search 通过外部 tantivy 引擎执行 BM25 检索，在与事务、过滤器或 JOIN 操作结合使用时可能存在限制。由于 pg_bestmatch.rs 完全原生于 PostgreSQL，因此在 PostgreSQL 内部与这些操作具有完全的兼容性。
函数参考
tokenize- 说明：将输入字符串分词为独立的词元。
- 示例：
SELECT tokenize('i have an apple'); -- 结果：{i,have,an,apple}
bm25_create- 说明：为指定的表和列创建 BM25 统计信息。
- 用法：
SELECT bm25_create('documents', 'passage', 'documents_passage_bm25');
- 参数：
table_name：表名。column_name：列名。stat_name：BM25 统计信息名称。b：BM25 参数（默认值 0.75）。k：BM25 参数（默认值 1.2）。
bm25_refresh- 说明：更新 BM25 统计信息以反映底层数据的变化。
- 用法：
SELECT bm25_refresh('documents_passage_bm25');
- 参数：
stat_name：要更新的 BM25 统计信息名称。
bm25_drop- 说明：删除指定表和列的 BM25 统计信息。
- 用法：
SELECT bm25_drop('documents_passage_bm25');
- 参数：
stat_name：要删除的 BM25 统计信息名称。
bm25_document_to_svector- 说明：将文档文本转换为稀疏向量表示。
- 用法：
SELECT bm25_document_to_svector('documents_passage_bm25', 'document_text');
- 参数：
stat_name：BM25 统计信息名称。document_text：文档文本内容。style：输出 pgvecto.rs 风格或 pgvector 风格的稀疏向量。
bm25_query_to_svector- 说明：将查询文本转换为稀疏向量表示。
- 用法：
SELECT bm25_query_to_svector('documents_passage_bm25', 'We begin, as always, with the text.');
- 参数：
stat_name：BM25 统计信息名称。query_text：查询文本内容。style：输出 pgvecto.rs 风格或 pgvector 风格的稀疏向量。
60 - vchord_bm25
BM25排序算法
概览
| ID | 扩展名 | Bin | Lib | Load | Create | Trust | Reloc | 模式 |
|---|
| 2150 | vchord_bm25 | 否 | 是 | 是 | 是 | 否 | 否 | bm25_catalog |
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PIGSTY | 0.3.0 | 1817161514 | vchord_bm25 | - |
| RPM | PIGSTY | 0.3.0 | 1817161514 | vchord_bm25_$v | - |
| DEB | PIGSTY | 0.3.0 | 1817161514 | postgresql-$v-vchord-bm25 | - |
构建
您可以使用 pig build 命令构建 vchord_bm25 扩展的 RPM / DEB 包：
pig build pkg vchord_bm25 # 构建 RPM / DEB 包
安装
您可以直接安装 vchord_bm25 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install vchord_bm25; # 当前活跃 PG 版本安装
pig ext install -y vchord_bm25 -v 18 # PG 18
pig ext install -y vchord_bm25 -v 17 # PG 17
pig ext install -y vchord_bm25 -v 16 # PG 16
pig ext install -y vchord_bm25 -v 15 # PG 15
pig ext install -y vchord_bm25 -v 14 # PG 14
dnf install -y vchord_bm25_18 # PG 18
dnf install -y vchord_bm25_17 # PG 17
dnf install -y vchord_bm25_16 # PG 16
dnf install -y vchord_bm25_15 # PG 15
dnf install -y vchord_bm25_14 # PG 14
apt install -y postgresql-18-vchord-bm25 # PG 18
apt install -y postgresql-17-vchord-bm25 # PG 17
apt install -y postgresql-16-vchord-bm25 # PG 16
apt install -y postgresql-15-vchord-bm25 # PG 15
apt install -y postgresql-14-vchord-bm25 # PG 14
预加载配置：
shared_preload_libraries = 'vchord_bm25';
创建扩展：
CREATE EXTENSION vchord_bm25;
用法
GitHub: tensorchord/VectorChord-bm25
VectorChord-BM25 是一个实现 BM25 排序算法的 PostgreSQL 扩展，基于 Block-WeakAnd 算法。它设计与 pg_tokenizer 配合使用，支持自定义文本分词。
架构
该扩展由三个主要组件组成：
- 分词器：将文本转换为
bm25vector（存储词汇 ID 和词频的稀疏向量） - bm25vector：用于存储分词后文本的自定义数据类型
- bm25vector 索引：加速搜索和排序操作
快速开始
-- 启用所需扩展
CREATE EXTENSION IF NOT EXISTS pg_tokenizer CASCADE;
CREATE EXTENSION IF NOT EXISTS vchord_bm25 CASCADE;
-- 创建分词器（如用于英文的 LLMLingua2）
SELECT create_tokenizer('tokenizer1', $$
model = "llmlingua2"
$$);
-- 创建包含文本内容的表
CREATE TABLE documents (
id SERIAL PRIMARY KEY,
passage TEXT,
embedding bm25vector
);
-- 将文本段落分词为 bm25vector
UPDATE documents SET embedding = tokenize(passage, 'tokenizer1');
-- 创建 BM25 索引
CREATE INDEX documents_embedding_bm25 ON documents USING bm25 (embedding bm25_ops);
-- 使用 BM25 排序查询
SELECT id, passage, embedding <&> to_bm25query('documents_embedding_bm25', tokenize('search query', 'tokenizer1')) AS score
FROM documents
ORDER BY score
LIMIT 10;
注意：VectorChord-BM25 中的 BM25 分数为负数，越负表示相关性越高。
<&> 运算符
<&> 运算符计算存储的 bm25vector 与查询 bm25vector 之间的 BM25 相关性分数。查询必须用 to_bm25query() 包装，它接受索引名称和分词后的查询：
-- 基本搜索查询
-- to_bm25query(索引名称, 分词后的查询)
SELECT id, passage, embedding <&> to_bm25query('documents_embedding_bm25', tokenize('database system', 'tokenizer1')) AS score
FROM documents
ORDER BY score
LIMIT 10;
语言支持
VectorChord-BM25 通过不同的分词器配置支持多种语言：
| 语言 | 方式 | 模型/预分词器 |
|---|
| 英语 | 预训练模型 | model = "llmlingua2" 或 model = "bert_base_uncased" |
| 中文 | 带结巴预分词器的自定义模型 | [pre_tokenizer.jieba] |
| 日语 | 带 Lindera 预分词器的自定义模型 | Lindera + IPADIC 词典 |
| 自定义 | 通过文本分析器训练的用户模型 | create_custom_model_tokenizer_and_trigger() |
中文文本搜索示例
中文文本需要带结巴预分词器的自定义模型（而非预训练模型）：
-- 创建带结巴预分词器的文本分析器
SELECT create_text_analyzer('zh_text_analyzer', $$
[pre_tokenizer.jieba]
$$);
-- 创建在语料上训练的自定义模型分词器
SELECT create_custom_model_tokenizer_and_trigger(
tokenizer_name => 'zh_tokenizer',
model_name => 'zh_model',
text_analyzer_name => 'zh_text_analyzer',
table_name => 'documents',
source_column => 'passage',
target_column => 'embedding'
);
自定义分词器模型
对于领域特定术语，你可以创建带停用词、词干提取和其他过滤器的文本分析器，然后使用 create_custom_model_tokenizer_and_trigger() 在语料上训练自定义模型。
与替代方案的比较
| 特性 | VectorChord-BM25 | PostgreSQL tsvector + ts_rank |
|---|
| 排序算法 | BM25 | tf-idf 变体 |
| 自定义分词器 | 支持（通过 pg_tokenizer） | 仅限内置配置 |
| 索引类型 | 专用 BM25 索引 | GIN 索引 |
| 原生 PostgreSQL | 是（扩展） | 内置 |
| 语言支持 | 通过模型可扩展 | 通过文本搜索配置 |
61 - pg_tokenizer
用于全文检索的分词器
概览
| ID | 扩展名 | Bin | Lib | Load | Create | Trust | Reloc | 模式 |
|---|
| 2160 | pg_tokenizer | 否 | 是 | 是 | 是 | 否 | 否 | tokenizer_catalog |
PG18 fix by Vonng
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PIGSTY | 0.1.1 | 1817161514 | pg_tokenizer | - |
| RPM | PIGSTY | 0.1.1 | 1817161514 | pg_tokenizer_$v | - |
| DEB | PIGSTY | 0.1.1 | 1817161514 | postgresql-$v-pg-tokenizer | - |
构建
您可以使用 pig build 命令构建 pg_tokenizer 扩展的 RPM / DEB 包：
pig build pkg pg_tokenizer # 构建 RPM / DEB 包
安装
您可以直接安装 pg_tokenizer 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install pg_tokenizer; # 当前活跃 PG 版本安装
pig ext install -y pg_tokenizer -v 18 # PG 18
pig ext install -y pg_tokenizer -v 17 # PG 17
pig ext install -y pg_tokenizer -v 16 # PG 16
pig ext install -y pg_tokenizer -v 15 # PG 15
pig ext install -y pg_tokenizer -v 14 # PG 14
dnf install -y pg_tokenizer_18 # PG 18
dnf install -y pg_tokenizer_17 # PG 17
dnf install -y pg_tokenizer_16 # PG 16
dnf install -y pg_tokenizer_15 # PG 15
dnf install -y pg_tokenizer_14 # PG 14
apt install -y postgresql-18-pg-tokenizer # PG 18
apt install -y postgresql-17-pg-tokenizer # PG 17
apt install -y postgresql-16-pg-tokenizer # PG 16
apt install -y postgresql-15-pg-tokenizer # PG 15
apt install -y postgresql-14-pg-tokenizer # PG 14
预加载配置：
shared_preload_libraries = 'pg_tokenizer';
创建扩展：
CREATE EXTENSION pg_tokenizer;
用法
GitHub: tensorchord/pg_tokenizer.rs
pg_tokenizer 是一个为全文搜索提供分词器的 PostgreSQL 扩展。它设计与 VectorChord-bm25 配合使用，提供原生 BM25 排序索引支持。
快速开始
CREATE EXTENSION pg_tokenizer;
-- 使用 LLMLingua2 模型创建分词器
SELECT create_tokenizer('tokenizer1', $$
model = "llmlingua2"
$$);
-- 分词文本
SELECT tokenize('PostgreSQL is a powerful, open-source object-relational database system. It has over 15 years of active development.', 'tokenizer1');
分词器模型
pg_tokenizer 支持多种分词器模型，适用于不同语言和场景：
| 模型 | 语言 | 说明 |
|---|
llmlingua2 | 英语 | 基于 BERT 的 LLMLingua2 分词器 |
jieba | 中文 | 结巴中文分词 |
lindera/ipadic | 日语 | 带 IPADIC 词典的 Lindera 分词器 |
| 自定义模型 | 任意 | 用户训练的领域特定文本模型 |
创建分词器
-- 英文分词器
SELECT create_tokenizer('en_tokenizer', $$
model = "llmlingua2"
$$);
-- 中文分词器
SELECT create_tokenizer('zh_tokenizer', $$
model = "jieba"
$$);
-- 日文分词器
SELECT create_tokenizer('ja_tokenizer', $$
model = "lindera/ipadic"
$$);
文本分词
-- 分词英文文本
SELECT tokenize('full text search in PostgreSQL', 'en_tokenizer');
-- 分词中文文本
SELECT tokenize('PostgreSQL是一个强大的数据库系统', 'zh_tokenizer');
文本分析器
pg_tokenizer 还提供文本分析器功能，将分词与额外的文本处理步骤结合。详细的文本分析器用法请参见文本分析器文档。
与 VectorChord-BM25 集成
pg_tokenizer 通常与 VectorChord-BM25 配合使用以获得完整的 BM25 排序支持：
CREATE EXTENSION IF NOT EXISTS pg_tokenizer CASCADE;
CREATE EXTENSION IF NOT EXISTS vchord_bm25 CASCADE;
-- 创建分词器
SELECT create_tokenizer('my_tokenizer', $$
model = "llmlingua2"
$$);
-- 将文本分词为 bm25vector 用于索引和搜索
SELECT tokenize('your search query', 'my_tokenizer');
文档
更多详情请参见完整文档：
62 - biscuit
使用IAM的高性能文本模式匹配
概览
| ID | 扩展名 | Bin | Lib | Load | Create | Trust | Reloc | 模式 |
|---|
| 2170 | biscuit | 否 | 是 | 否 | 是 | 否 | 否 | public |
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PIGSTY | 2.2.2 | 1817161514 | pg_biscuit | plpgsql |
| RPM | PIGSTY | 2.2.2 | 1817161514 | pg_biscuit_$v | - |
| DEB | PIGSTY | 2.2.2 | 1817161514 | postgresql-$v-biscuit | - |
构建
您可以使用 pig build 命令构建 pg_biscuit 扩展的 RPM / DEB 包：
pig build pkg pg_biscuit # 构建 RPM / DEB 包
安装
您可以直接安装 pg_biscuit 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install pg_biscuit; # 当前活跃 PG 版本安装
pig ext install -y pg_biscuit -v 18 # PG 18
pig ext install -y pg_biscuit -v 17 # PG 17
pig ext install -y pg_biscuit -v 16 # PG 16
dnf install -y pg_biscuit_18 # PG 18
dnf install -y pg_biscuit_17 # PG 17
dnf install -y pg_biscuit_16 # PG 16
apt install -y postgresql-18-biscuit # PG 18
apt install -y postgresql-17-biscuit # PG 17
apt install -y postgresql-16-biscuit # PG 16
创建扩展：
CREATE EXTENSION biscuit CASCADE; -- 依赖: plpgsql
用法
README | Docs
biscuit 是 PostgreSQL 的一种索引访问方法，专为 LIKE 和 ILIKE 模式匹配优化，也支持多列检索。上游将其定位为一种确定性的位图索引，可避免基于 trigram 的搜索常见的误命中复查开销。
快速上手
创建扩展，并在一个或多个文本列上建立 Biscuit 索引：
CREATE EXTENSION biscuit;
CREATE INDEX idx_users_name ON users USING biscuit(name);
CREATE INDEX idx_products_search
ON products USING biscuit(name, description, category);
带通配符的常见查询同样可以使用该索引：
SELECT * FROM users WHERE name LIKE '%john%';
SELECT * FROM users WHERE name NOT LIKE 'a%b%c';
SELECT COUNT(*) FROM users WHERE name LIKE '%test%';
SELECT *
FROM products
WHERE name LIKE '%widget%'
AND description LIKE '%blue%'
AND category LIKE 'electronics%'
LIMIT 10;
索引行为
Biscuit 为每个字符串维护位图位置索引，能够同时匹配正向和反向字符位置。上游设计强调：
- 正向索引，用于匹配字符在精确位置上的出现
- 反向索引，用于按字符串末尾倒数位置匹配字符
ILIKE 的大小写不敏感变体- 用于快速长度过滤的精确长度位图和最小长度位图
对于 LIKE 'abc%def' 这类模式，Biscuit 可以把前缀位图、后缀位图以及最小长度过滤合并起来，从而在不执行 heap 复查的情况下得到精确结果。
模式类型
上游文档对常见模式给出了优化路径：
- 精确匹配，例如
'abc' - 前缀匹配，例如
'abc%' - 后缀匹配，例如
'%xyz' - 子串匹配，例如
'%abc%' - 多列谓词，Biscuit 会按估计选择性重排谓词顺序
性能说明
上游 README 强调了纯位图求值及多项执行优化，包括：
- 中间位图为空时提前结束
- 对稀疏和稠密数据直接使用 roaring bitmap
- 后缀谓词使用反向位置查找
- 对 TID 做排序，以提高 heap 访问局部性
- 对聚合查询和
LIMIT 的特殊处理
项目 README 还给出了一个 100 万行测试表的基准方案，用来比较 Biscuit 索引与 trigram 方案。
需求
当前上游 README 列出的源码构建要求包括：
- PostgreSQL 16 或更高版本
- 标准构建工具，如
gcc、make 和 pg_config - 可选的 CRoaring，用于提升性能
该项目通过 PGXN 发布包，并在 Read the Docs 上维护独立文档站。
63 - pg_textsearch
带有BM25排序的全文搜索扩展
概览
bm25 am conflicts with pg_search; must be preloaded via shared_preload_libraries.
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PIGSTY | 1.0.0 | 1817161514 | pg_textsearch | - |
| RPM | PIGSTY | 1.0.0 | 1817161514 | pg_textsearch_$v | - |
| DEB | PIGSTY | 1.0.0 | 1817161514 | postgresql-$v-textsearch | - |
构建
您可以使用 pig build 命令构建 pg_textsearch 扩展的 RPM / DEB 包：
pig build pkg pg_textsearch # 构建 RPM / DEB 包
安装
您可以直接安装 pg_textsearch 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install pg_textsearch; # 当前活跃 PG 版本安装
pig ext install -y pg_textsearch -v 18 # PG 18
pig ext install -y pg_textsearch -v 17 # PG 17
dnf install -y pg_textsearch_18 # PG 18
dnf install -y pg_textsearch_17 # PG 17
apt install -y postgresql-18-textsearch # PG 18
apt install -y postgresql-17-textsearch # PG 17
预加载配置：
shared_preload_libraries = 'pg_textsearch';
创建扩展：
CREATE EXTENSION pg_textsearch;
用法
pg_textsearch: 使用 BM25 的 PostgreSQL 现代排序文本搜索
pg_textsearch 提供基于 BM25 评分并结合 Block-Max WAND 优化的现代排序文本搜索。它语法简洁，支持快速 top-k 查询、并行索引构建以及分区表。
添加到 shared_preload_libraries：
shared_preload_libraries = 'pg_textsearch'
CREATE EXTENSION pg_textsearch;
快速开始
CREATE TABLE documents (id bigserial PRIMARY KEY, content text);
INSERT INTO documents (content) VALUES
('PostgreSQL is a powerful database system'),
('BM25 is an effective ranking function'),
('Full text search with custom scoring');
-- 创建 BM25 索引
CREATE INDEX docs_idx ON documents USING bm25(content) WITH (text_config='english');
-- 使用 <@> 运算符查询（返回负 BM25 分数，分数越低匹配越好）
SELECT * FROM documents
ORDER BY content <@> 'database system'
LIMIT 5;
查询
-- 从列自动检测索引
SELECT * FROM documents
ORDER BY content <@> 'database system'
LIMIT 5;
-- 显式指定索引
SELECT * FROM documents
WHERE content <@> to_bm25query('database system', 'docs_idx') < -1.0;
过滤
前置过滤会在评分前缩减行数，适合选择性强的过滤条件：
CREATE INDEX ON documents (category_id);
SELECT * FROM documents
WHERE category_id = 123
ORDER BY content <@> 'search terms'
LIMIT 10;
后置过滤会先执行 BM25 扫描，再应用过滤条件：
SELECT * FROM documents
WHERE content <@> to_bm25query('search terms', 'docs_idx') < -5.0
ORDER BY content <@> 'search terms'
LIMIT 10;
索引选项
| 选项 | 默认值 | 说明 |
|---|
text_config | （必需） | PostgreSQL 文本搜索配置 |
k1 | 1.2 | 词频饱和参数 |
b | 0.75 | 长度归一化参数 |
CREATE INDEX ON documents USING bm25(content)
WITH (text_config='english', k1=1.5, b=0.8);
-- 语言专用配置
CREATE INDEX ON french_docs USING bm25(content) WITH (text_config='french');
CREATE INDEX ON german_docs USING bm25(content) WITH (text_config='german');
数据类型
bm25query - 表示 BM25 评分查询：
SELECT to_bm25query('search query text', 'docs_idx');
-- docs_idx:search query text
64 - pg_pinyin
PostgreSQL 拼音转写与检索辅助扩展
概览
| ID | 扩展名 | Bin | Lib | Load | Create | Trust | Reloc | 模式 |
|---|
| 2190 | pg_pinyin | 否 | 是 | 否 | 是 | 否 | 是 | pinyin |
pgrx 0.17.0; optional tokenizer-input overload can integrate with pg_search
版本
构建
您可以使用 pig build 命令构建 pg_pinyin 扩展的 RPM / DEB 包：
pig build pkg pg_pinyin # 构建 RPM / DEB 包
安装
您可以直接安装 pg_pinyin 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install pg_pinyin; # 当前活跃 PG 版本安装
pig ext install -y pg_pinyin -v 18 # PG 18
pig ext install -y pg_pinyin -v 17 # PG 17
pig ext install -y pg_pinyin -v 16 # PG 16
pig ext install -y pg_pinyin -v 15 # PG 15
pig ext install -y pg_pinyin -v 14 # PG 14
dnf install -y pg_pinyin_18 # PG 18
dnf install -y pg_pinyin_17 # PG 17
dnf install -y pg_pinyin_16 # PG 16
dnf install -y pg_pinyin_15 # PG 15
dnf install -y pg_pinyin_14 # PG 14
apt install -y postgresql-18-pinyin # PG 18
apt install -y postgresql-17-pinyin # PG 17
apt install -y postgresql-16-pinyin # PG 16
apt install -y postgresql-15-pinyin # PG 15
apt install -y postgresql-14-pinyin # PG 14
创建扩展：
CREATE EXTENSION pg_pinyin;
用法
pg_pinyin: PostgreSQL 的拼音转换与搜索辅助
将中文字符转换为拼音罗马化，用于搜索和索引。可与 pg_trgm 配合实现模糊拼音搜索，或与 pg_search 配合实现基于词的搜索。
CREATE EXTENSION pg_pinyin;
函数
| 函数 | 说明 |
|---|
pinyin_char_romanize(text) | 字符级拼音罗马化 |
pinyin_char_romanize(text, suffix) | 使用自定义词典后缀 |
pinyin_word_romanize(text) | 词级拼音罗马化 |
pinyin_word_romanize(text, suffix) | 使用自定义词典后缀 |
生成列 + Trigram 搜索
CREATE EXTENSION IF NOT EXISTS pg_pinyin;
CREATE EXTENSION IF NOT EXISTS pg_trgm;
CREATE TABLE voice (
id bigserial PRIMARY KEY,
description text NOT NULL,
pinyin text GENERATED ALWAYS AS (public.pinyin_char_romanize(description)) STORED
);
CREATE INDEX voice_pinyin_trgm_idx ON voice USING gin (pinyin gin_trgm_ops);
INSERT INTO voice (description) VALUES ('郑爽ABC');
SELECT id, description, pinyin FROM voice;
自定义词典
在 pinyin schema 中提供带后缀的自定义词典表：
CREATE TABLE IF NOT EXISTS pinyin.pinyin_mapping_suffix1 (
character text PRIMARY KEY,
pinyin text NOT NULL
);
CREATE TABLE IF NOT EXISTS pinyin.pinyin_words_suffix1 (
word text PRIMARY KEY,
pinyin text NOT NULL
);
INSERT INTO pinyin.pinyin_mapping_suffix1 (character, pinyin)
VALUES ('郑', '|zhengx|')
ON CONFLICT (character) DO UPDATE SET pinyin = EXCLUDED.pinyin;
-- 使用自定义词典
SELECT public.pinyin_char_romanize('郑爽ABC', '_suffix1');
65 - pg_kazsearch
PostgreSQL 哈萨克语全文检索扩展
概览
Upstream release/package version is 2.0.0; extension control version is 0.1.0.
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PIGSTY | 0.1.0 | 1817161514 | pg_kazsearch | - |
| RPM | PIGSTY | 2.0.0 | 1817161514 | pg_kazsearch_$v | - |
| DEB | PIGSTY | 2.0.0 | 1817161514 | postgresql-$v-pg-kazsearch | - |
构建
您可以使用 pig build 命令构建 pg_kazsearch 扩展的 RPM / DEB 包：
pig build pkg pg_kazsearch # 构建 RPM / DEB 包
安装
您可以直接安装 pg_kazsearch 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install pg_kazsearch; # 当前活跃 PG 版本安装
pig ext install -y pg_kazsearch -v 18 # PG 18
pig ext install -y pg_kazsearch -v 17 # PG 17
pig ext install -y pg_kazsearch -v 16 # PG 16
dnf install -y pg_kazsearch_18 # PG 18
dnf install -y pg_kazsearch_17 # PG 17
dnf install -y pg_kazsearch_16 # PG 16
apt install -y postgresql-18-pg-kazsearch # PG 18
apt install -y postgresql-17-pg-kazsearch # PG 17
apt install -y postgresql-16-pg-kazsearch # PG 16
创建扩展：
CREATE EXTENSION pg_kazsearch;
用法
来源: README 和 项目仓库。
pg_kazsearch 是一个面向哈萨克语的 PostgreSQL 全文检索扩展。
上游 README 将其描述为使用 pgrx 构建的 Rust 扩展，它接入 PostgreSQL 的文本检索流水线。
它会创建一个可直接使用的配置 kazakh_cfg，以及配套词典 pg_kazsearch_dict。
快速开始
CREATE EXTENSION pg_kazsearch;
SELECT to_tsvector('kazakh_cfg', 'президенттің жарлығы');
-- 'жарлық':2 'президент':1
SELECT ts_lexize('pg_kazsearch_dict', 'алмаларымыздағы');
-- {алма}
使用场景
README 展示了以下典型用法：
- 对单个哈萨克语词语做词干提取
- 使用
to_tsvector('kazakh_cfg', ...) 构建 tsvector - 为表添加生成列类型的
tsvector - 用 GIN 索引这些列
- 使用
websearch_to_tsquery('kazakh_cfg', ...) 进行检索
示例表工作流：
ALTER TABLE articles ADD COLUMN fts tsvector
GENERATED ALWAYS AS (
setweight(to_tsvector('kazakh_cfg', title), 'A') ||
setweight(to_tsvector('kazakh_cfg', body), 'B')
) STORED;
CREATE INDEX idx_fts ON articles USING GIN (fts);
SELECT title FROM articles
WHERE fts @@ websearch_to_tsquery('kazakh_cfg', 'президенттің жарлығы')
ORDER BY ts_rank_cd(fts, websearch_to_tsquery('kazakh_cfg', 'президенттің жарлығы')) DESC
LIMIT 10;
调优
可以在运行时调整惩罚权重：
ALTER TEXT SEARCH DICTIONARY pg_kazsearch_dict (w_deriv = 3.5, w_short_char = 100.0);
部署
README 列出了三种支持的安装路径：
- 预编译的 Debian/Ubuntu 软件包
- 基于
ghcr.io/darkhanakh/pg-kazsearch 的 Docker 镜像 - 使用
cargo pgrx install 从源码构建
本项目的仓库元数据对应 PostgreSQL 16-18。
66 - hunspell_cs_cz
Hunspell捷克语全文检索词典
概览
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PIGSTY | 1.0 | 1817161514 | hunspell_cs_cz | - |
| RPM | PIGSTY | 1.0 | 1817161514 | hunspell_cs_cz_$v | - |
| DEB | PIGSTY | 1.0 | 1817161514 | postgresql-$v-hunspell-cs-cz | - |
构建
您可以使用 pig build 命令构建 hunspell_cs_cz 扩展的 RPM / DEB 包：
pig build pkg hunspell_cs_cz # 构建 RPM / DEB 包
安装
您可以直接安装 hunspell_cs_cz 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install hunspell_cs_cz; # 当前活跃 PG 版本安装
pig ext install -y hunspell_cs_cz -v 18 # PG 18
pig ext install -y hunspell_cs_cz -v 17 # PG 17
pig ext install -y hunspell_cs_cz -v 16 # PG 16
pig ext install -y hunspell_cs_cz -v 15 # PG 15
pig ext install -y hunspell_cs_cz -v 14 # PG 14
dnf install -y hunspell_cs_cz_18 # PG 18
dnf install -y hunspell_cs_cz_17 # PG 17
dnf install -y hunspell_cs_cz_16 # PG 16
dnf install -y hunspell_cs_cz_15 # PG 15
dnf install -y hunspell_cs_cz_14 # PG 14
apt install -y postgresql-18-hunspell-cs-cz # PG 18
apt install -y postgresql-17-hunspell-cs-cz # PG 17
apt install -y postgresql-16-hunspell-cs-cz # PG 16
apt install -y postgresql-15-hunspell-cs-cz # PG 15
apt install -y postgresql-14-hunspell-cs-cz # PG 14
创建扩展：
CREATE EXTENSION hunspell_cs_cz;
用法
hunspell_cs_cz: PostgreSQL 的捷克语 Hunspell 词典
用于 PostgreSQL 全文搜索的捷克语 Hunspell 词典和文本搜索配置。
CREATE EXTENSION hunspell_cs_cz;
SELECT ts_lexize('czech_hunspell', 'příběhy');
SELECT to_tsvector('czech_hunspell', 'příběhy');
该扩展提供 czech_hunspell 词典和文本搜索配置。
67 - hunspell_de_de
Hunspell德语全文检索词典
概览
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PIGSTY | 1.0 | 1817161514 | hunspell_de_de | - |
| RPM | PIGSTY | 1.0 | 1817161514 | hunspell_de_de_$v | - |
| DEB | PIGSTY | 1.0 | 1817161514 | postgresql-$v-hunspell-de-de | - |
构建
您可以使用 pig build 命令构建 hunspell_de_de 扩展的 RPM / DEB 包：
pig build pkg hunspell_de_de # 构建 RPM / DEB 包
安装
您可以直接安装 hunspell_de_de 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install hunspell_de_de; # 当前活跃 PG 版本安装
pig ext install -y hunspell_de_de -v 18 # PG 18
pig ext install -y hunspell_de_de -v 17 # PG 17
pig ext install -y hunspell_de_de -v 16 # PG 16
pig ext install -y hunspell_de_de -v 15 # PG 15
pig ext install -y hunspell_de_de -v 14 # PG 14
dnf install -y hunspell_de_de_18 # PG 18
dnf install -y hunspell_de_de_17 # PG 17
dnf install -y hunspell_de_de_16 # PG 16
dnf install -y hunspell_de_de_15 # PG 15
dnf install -y hunspell_de_de_14 # PG 14
apt install -y postgresql-18-hunspell-de-de # PG 18
apt install -y postgresql-17-hunspell-de-de # PG 17
apt install -y postgresql-16-hunspell-de-de # PG 16
apt install -y postgresql-15-hunspell-de-de # PG 15
apt install -y postgresql-14-hunspell-de-de # PG 14
创建扩展：
CREATE EXTENSION hunspell_de_de;
用法
hunspell_de_de: PostgreSQL 的德语 Hunspell 词典
用于 PostgreSQL 全文搜索的德语 Hunspell 词典和文本搜索配置。
CREATE EXTENSION hunspell_de_de;
SELECT ts_lexize('german_hunspell', 'Geschichten');
SELECT to_tsvector('german_hunspell', 'Geschichten');
该扩展提供 german_hunspell 词典和文本搜索配置。
68 - hunspell_en_us
Hunspell英语全文检索词典
概览
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PIGSTY | 1.0 | 1817161514 | hunspell_en_us | - |
| RPM | PIGSTY | 1.0 | 1817161514 | hunspell_en_us_$v | - |
| DEB | PIGSTY | 1.0 | 1817161514 | postgresql-$v-hunspell-en-us | - |
构建
您可以使用 pig build 命令构建 hunspell_en_us 扩展的 RPM / DEB 包：
pig build pkg hunspell_en_us # 构建 RPM / DEB 包
安装
您可以直接安装 hunspell_en_us 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install hunspell_en_us; # 当前活跃 PG 版本安装
pig ext install -y hunspell_en_us -v 18 # PG 18
pig ext install -y hunspell_en_us -v 17 # PG 17
pig ext install -y hunspell_en_us -v 16 # PG 16
pig ext install -y hunspell_en_us -v 15 # PG 15
pig ext install -y hunspell_en_us -v 14 # PG 14
dnf install -y hunspell_en_us_18 # PG 18
dnf install -y hunspell_en_us_17 # PG 17
dnf install -y hunspell_en_us_16 # PG 16
dnf install -y hunspell_en_us_15 # PG 15
dnf install -y hunspell_en_us_14 # PG 14
apt install -y postgresql-18-hunspell-en-us # PG 18
apt install -y postgresql-17-hunspell-en-us # PG 17
apt install -y postgresql-16-hunspell-en-us # PG 16
apt install -y postgresql-15-hunspell-en-us # PG 15
apt install -y postgresql-14-hunspell-en-us # PG 14
创建扩展：
CREATE EXTENSION hunspell_en_us;
用法
hunspell_en_us: PostgreSQL 的英语（美国） Hunspell 词典
用于 PostgreSQL 全文搜索的英语（美国） Hunspell 词典和文本搜索配置。
CREATE EXTENSION hunspell_en_us;
SELECT ts_lexize('english_hunspell', 'stories');
SELECT to_tsvector('english_hunspell', 'stories');
该扩展提供 english_hunspell 词典和文本搜索配置。
69 - hunspell_fr
Hunspell法语全文检索词典
概览
| ID | 扩展名 | Bin | Lib | Load | Create | Trust | Reloc | 模式 |
|---|
| 2273 | hunspell_fr | 否 | 否 | 否 | 是 | 否 | 是 | - |
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PIGSTY | 1.0 | 1817161514 | hunspell_fr | - |
| RPM | PIGSTY | 1.0 | 1817161514 | hunspell_fr_$v | - |
| DEB | PIGSTY | 1.0 | 1817161514 | postgresql-$v-hunspell-fr | - |
构建
您可以使用 pig build 命令构建 hunspell_fr 扩展的 RPM / DEB 包：
pig build pkg hunspell_fr # 构建 RPM / DEB 包
安装
您可以直接安装 hunspell_fr 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install hunspell_fr; # 当前活跃 PG 版本安装
pig ext install -y hunspell_fr -v 18 # PG 18
pig ext install -y hunspell_fr -v 17 # PG 17
pig ext install -y hunspell_fr -v 16 # PG 16
pig ext install -y hunspell_fr -v 15 # PG 15
pig ext install -y hunspell_fr -v 14 # PG 14
dnf install -y hunspell_fr_18 # PG 18
dnf install -y hunspell_fr_17 # PG 17
dnf install -y hunspell_fr_16 # PG 16
dnf install -y hunspell_fr_15 # PG 15
dnf install -y hunspell_fr_14 # PG 14
apt install -y postgresql-18-hunspell-fr # PG 18
apt install -y postgresql-17-hunspell-fr # PG 17
apt install -y postgresql-16-hunspell-fr # PG 16
apt install -y postgresql-15-hunspell-fr # PG 15
apt install -y postgresql-14-hunspell-fr # PG 14
创建扩展：
CREATE EXTENSION hunspell_fr;
用法
hunspell_fr: PostgreSQL 的法语 Hunspell 词典
用于 PostgreSQL 全文搜索的法语 Hunspell 词典和文本搜索配置。
CREATE EXTENSION hunspell_fr;
SELECT ts_lexize('french_hunspell', 'histoires');
SELECT to_tsvector('french_hunspell', 'histoires');
该扩展提供 french_hunspell 词典和文本搜索配置。
70 - hunspell_ne_np
Hunspell尼泊尔语全文检索词典
概览
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PIGSTY | 1.0 | 1817161514 | hunspell_ne_np | - |
| RPM | PIGSTY | 1.0 | 1817161514 | hunspell_ne_np_$v | - |
| DEB | PIGSTY | 1.0 | 1817161514 | postgresql-$v-hunspell-ne-np | - |
构建
您可以使用 pig build 命令构建 hunspell_ne_np 扩展的 RPM / DEB 包：
pig build pkg hunspell_ne_np # 构建 RPM / DEB 包
安装
您可以直接安装 hunspell_ne_np 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install hunspell_ne_np; # 当前活跃 PG 版本安装
pig ext install -y hunspell_ne_np -v 18 # PG 18
pig ext install -y hunspell_ne_np -v 17 # PG 17
pig ext install -y hunspell_ne_np -v 16 # PG 16
pig ext install -y hunspell_ne_np -v 15 # PG 15
pig ext install -y hunspell_ne_np -v 14 # PG 14
dnf install -y hunspell_ne_np_18 # PG 18
dnf install -y hunspell_ne_np_17 # PG 17
dnf install -y hunspell_ne_np_16 # PG 16
dnf install -y hunspell_ne_np_15 # PG 15
dnf install -y hunspell_ne_np_14 # PG 14
apt install -y postgresql-18-hunspell-ne-np # PG 18
apt install -y postgresql-17-hunspell-ne-np # PG 17
apt install -y postgresql-16-hunspell-ne-np # PG 16
apt install -y postgresql-15-hunspell-ne-np # PG 15
apt install -y postgresql-14-hunspell-ne-np # PG 14
创建扩展：
CREATE EXTENSION hunspell_ne_np;
用法
hunspell_ne_np: PostgreSQL 的尼泊尔语 Hunspell 词典
用于 PostgreSQL 全文搜索的尼泊尔语 Hunspell 词典和文本搜索配置。
CREATE EXTENSION hunspell_ne_np;
SELECT ts_lexize('nepali_hunspell', 'कथाहरू');
SELECT to_tsvector('nepali_hunspell', 'कथाहरू');
该扩展提供 nepali_hunspell 词典和文本搜索配置。
71 - hunspell_nl_nl
Hunspell荷兰语全文检索词典
概览
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PIGSTY | 1.0 | 1817161514 | hunspell_nl_nl | - |
| RPM | PIGSTY | 1.0 | 1817161514 | hunspell_nl_nl_$v | - |
| DEB | PIGSTY | 1.0 | 1817161514 | postgresql-$v-hunspell-nl-nl | - |
构建
您可以使用 pig build 命令构建 hunspell_nl_nl 扩展的 RPM / DEB 包：
pig build pkg hunspell_nl_nl # 构建 RPM / DEB 包
安装
您可以直接安装 hunspell_nl_nl 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install hunspell_nl_nl; # 当前活跃 PG 版本安装
pig ext install -y hunspell_nl_nl -v 18 # PG 18
pig ext install -y hunspell_nl_nl -v 17 # PG 17
pig ext install -y hunspell_nl_nl -v 16 # PG 16
pig ext install -y hunspell_nl_nl -v 15 # PG 15
pig ext install -y hunspell_nl_nl -v 14 # PG 14
dnf install -y hunspell_nl_nl_18 # PG 18
dnf install -y hunspell_nl_nl_17 # PG 17
dnf install -y hunspell_nl_nl_16 # PG 16
dnf install -y hunspell_nl_nl_15 # PG 15
dnf install -y hunspell_nl_nl_14 # PG 14
apt install -y postgresql-18-hunspell-nl-nl # PG 18
apt install -y postgresql-17-hunspell-nl-nl # PG 17
apt install -y postgresql-16-hunspell-nl-nl # PG 16
apt install -y postgresql-15-hunspell-nl-nl # PG 15
apt install -y postgresql-14-hunspell-nl-nl # PG 14
创建扩展：
CREATE EXTENSION hunspell_nl_nl;
用法
hunspell_nl_nl: PostgreSQL 的荷兰语 Hunspell 词典
用于 PostgreSQL 全文搜索的荷兰语 Hunspell 词典和文本搜索配置。
CREATE EXTENSION hunspell_nl_nl;
SELECT ts_lexize('dutch_hunspell', 'verhalen');
SELECT to_tsvector('dutch_hunspell', 'verhalen');
该扩展提供 dutch_hunspell 词典和文本搜索配置。
72 - hunspell_nn_no
Hunspell挪威语全文检索词典
概览
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PIGSTY | 1.0 | 1817161514 | hunspell_nn_no | - |
| RPM | PIGSTY | 1.0 | 1817161514 | hunspell_nn_no_$v | - |
| DEB | PIGSTY | 1.0 | 1817161514 | postgresql-$v-hunspell-nn-no | - |
构建
您可以使用 pig build 命令构建 hunspell_nn_no 扩展的 RPM / DEB 包：
pig build pkg hunspell_nn_no # 构建 RPM / DEB 包
安装
您可以直接安装 hunspell_nn_no 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install hunspell_nn_no; # 当前活跃 PG 版本安装
pig ext install -y hunspell_nn_no -v 18 # PG 18
pig ext install -y hunspell_nn_no -v 17 # PG 17
pig ext install -y hunspell_nn_no -v 16 # PG 16
pig ext install -y hunspell_nn_no -v 15 # PG 15
pig ext install -y hunspell_nn_no -v 14 # PG 14
dnf install -y hunspell_nn_no_18 # PG 18
dnf install -y hunspell_nn_no_17 # PG 17
dnf install -y hunspell_nn_no_16 # PG 16
dnf install -y hunspell_nn_no_15 # PG 15
dnf install -y hunspell_nn_no_14 # PG 14
apt install -y postgresql-18-hunspell-nn-no # PG 18
apt install -y postgresql-17-hunspell-nn-no # PG 17
apt install -y postgresql-16-hunspell-nn-no # PG 16
apt install -y postgresql-15-hunspell-nn-no # PG 15
apt install -y postgresql-14-hunspell-nn-no # PG 14
创建扩展：
CREATE EXTENSION hunspell_nn_no;
用法
hunspell_nn_no: PostgreSQL 的挪威语（尼诺斯克） Hunspell 词典
用于 PostgreSQL 全文搜索的挪威语（尼诺斯克） Hunspell 词典和文本搜索配置。
CREATE EXTENSION hunspell_nn_no;
SELECT ts_lexize('norwegian_hunspell', 'historier');
SELECT to_tsvector('norwegian_hunspell', 'historier');
该扩展提供 norwegian_hunspell 词典和文本搜索配置。
73 - hunspell_pt_pt
Hunspell葡萄牙语全文检索词典
概览
WARNING, conflict with pg built-in dict file, not recommended
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PIGSTY | 1.0 | 1817161514 | hunspell_pt_pt | - |
| RPM | PIGSTY | 1.0 | 1817161514 | hunspell_pt_pt_$v | - |
| DEB | PIGSTY | 1.0 | 1817161514 | postgresql-$v-hunspell-pt-pt | - |
构建
您可以使用 pig build 命令构建 hunspell_pt_pt 扩展的 RPM / DEB 包：
pig build pkg hunspell_pt_pt # 构建 RPM / DEB 包
安装
您可以直接安装 hunspell_pt_pt 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install hunspell_pt_pt; # 当前活跃 PG 版本安装
pig ext install -y hunspell_pt_pt -v 18 # PG 18
pig ext install -y hunspell_pt_pt -v 17 # PG 17
pig ext install -y hunspell_pt_pt -v 16 # PG 16
pig ext install -y hunspell_pt_pt -v 15 # PG 15
pig ext install -y hunspell_pt_pt -v 14 # PG 14
dnf install -y hunspell_pt_pt_18 # PG 18
dnf install -y hunspell_pt_pt_17 # PG 17
dnf install -y hunspell_pt_pt_16 # PG 16
dnf install -y hunspell_pt_pt_15 # PG 15
dnf install -y hunspell_pt_pt_14 # PG 14
apt install -y postgresql-18-hunspell-pt-pt # PG 18
apt install -y postgresql-17-hunspell-pt-pt # PG 17
apt install -y postgresql-16-hunspell-pt-pt # PG 16
apt install -y postgresql-15-hunspell-pt-pt # PG 15
apt install -y postgresql-14-hunspell-pt-pt # PG 14
创建扩展：
CREATE EXTENSION hunspell_pt_pt;
用法
hunspell_pt_pt: PostgreSQL 的葡萄牙语 Hunspell 词典
用于 PostgreSQL 全文搜索的葡萄牙语 Hunspell 词典和文本搜索配置。
CREATE EXTENSION hunspell_pt_pt;
SELECT ts_lexize('portuguese_hunspell', 'histórias');
SELECT to_tsvector('portuguese_hunspell', 'histórias');
该扩展提供 portuguese_hunspell 词典和文本搜索配置。
74 - hunspell_ru_ru
Hunspell俄语全文检索词典
概览
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PIGSTY | 1.0 | 1817161514 | hunspell_ru_ru | - |
| RPM | PIGSTY | 1.0 | 1817161514 | hunspell_ru_ru_$v | - |
| DEB | PIGSTY | 1.0 | 1817161514 | postgresql-$v-hunspell-ru-ru | - |
构建
您可以使用 pig build 命令构建 hunspell_ru_ru 扩展的 RPM / DEB 包：
pig build pkg hunspell_ru_ru # 构建 RPM / DEB 包
安装
您可以直接安装 hunspell_ru_ru 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install hunspell_ru_ru; # 当前活跃 PG 版本安装
pig ext install -y hunspell_ru_ru -v 18 # PG 18
pig ext install -y hunspell_ru_ru -v 17 # PG 17
pig ext install -y hunspell_ru_ru -v 16 # PG 16
pig ext install -y hunspell_ru_ru -v 15 # PG 15
pig ext install -y hunspell_ru_ru -v 14 # PG 14
dnf install -y hunspell_ru_ru_18 # PG 18
dnf install -y hunspell_ru_ru_17 # PG 17
dnf install -y hunspell_ru_ru_16 # PG 16
dnf install -y hunspell_ru_ru_15 # PG 15
dnf install -y hunspell_ru_ru_14 # PG 14
apt install -y postgresql-18-hunspell-ru-ru # PG 18
apt install -y postgresql-17-hunspell-ru-ru # PG 17
apt install -y postgresql-16-hunspell-ru-ru # PG 16
apt install -y postgresql-15-hunspell-ru-ru # PG 15
apt install -y postgresql-14-hunspell-ru-ru # PG 14
创建扩展：
CREATE EXTENSION hunspell_ru_ru;
用法
hunspell_ru_ru: PostgreSQL 的俄语 Hunspell 词典
用于 PostgreSQL 全文搜索的俄语 Hunspell 词典和文本搜索配置。
CREATE EXTENSION hunspell_ru_ru;
SELECT ts_lexize('russian_hunspell', 'рассказы');
SELECT to_tsvector('russian_hunspell', 'рассказы');
该扩展提供 russian_hunspell 词典和文本搜索配置。
75 - hunspell_ru_ru_aot
Hunspell俄语全文检索词典（来自AOT.ru小组）
概览
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PIGSTY | 1.0 | 1817161514 | hunspell_ru_ru_aot | - |
| RPM | PIGSTY | 1.0 | 1817161514 | hunspell_ru_ru_aot_$v | - |
| DEB | PIGSTY | 1.0 | 1817161514 | postgresql-$v-hunspell-ru-ru-aot | - |
构建
您可以使用 pig build 命令构建 hunspell_ru_ru_aot 扩展的 RPM / DEB 包：
pig build pkg hunspell_ru_ru_aot # 构建 RPM / DEB 包
安装
您可以直接安装 hunspell_ru_ru_aot 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install hunspell_ru_ru_aot; # 当前活跃 PG 版本安装
pig ext install -y hunspell_ru_ru_aot -v 18 # PG 18
pig ext install -y hunspell_ru_ru_aot -v 17 # PG 17
pig ext install -y hunspell_ru_ru_aot -v 16 # PG 16
pig ext install -y hunspell_ru_ru_aot -v 15 # PG 15
pig ext install -y hunspell_ru_ru_aot -v 14 # PG 14
dnf install -y hunspell_ru_ru_aot_18 # PG 18
dnf install -y hunspell_ru_ru_aot_17 # PG 17
dnf install -y hunspell_ru_ru_aot_16 # PG 16
dnf install -y hunspell_ru_ru_aot_15 # PG 15
dnf install -y hunspell_ru_ru_aot_14 # PG 14
apt install -y postgresql-18-hunspell-ru-ru-aot # PG 18
apt install -y postgresql-17-hunspell-ru-ru-aot # PG 17
apt install -y postgresql-16-hunspell-ru-ru-aot # PG 16
apt install -y postgresql-15-hunspell-ru-ru-aot # PG 15
apt install -y postgresql-14-hunspell-ru-ru-aot # PG 14
创建扩展：
CREATE EXTENSION hunspell_ru_ru_aot;
用法
hunspell_ru_ru_aot: PostgreSQL 的俄语（AOT）Hunspell 词典
用于 PostgreSQL 全文搜索的俄语（AOT 变体）Hunspell 词典和文本搜索配置。
CREATE EXTENSION hunspell_ru_ru_aot;
SELECT ts_lexize('russian_aot_hunspell', 'рассказы');
SELECT to_tsvector('russian_aot_hunspell', 'рассказы');
该扩展提供 russian_aot_hunspell 词典和文本搜索配置。
76 - fuzzystrmatch
确定字符串之间的相似性和距离
概览
版本
| PG18 | PG17 | PG16 | PG15 | PG14 |
|---|
| 1.2 | 1.2 | 1.2 | 1.2 | 1.2 |
安装
提示：这是 PostgreSQL 内核自带的 contrib 扩展
CREATE EXTENSION fuzzystrmatch;
用法
fuzzystrmatch: 判断字符串之间的相似度和距离
fuzzystrmatch 模块提供了判断字符串之间相似度和距离的函数。
CREATE EXTENSION fuzzystrmatch;
Soundex
将字符串转换为 Soundex 编码（适用于匹配发音相似的名称）：
SELECT soundex('Anne'), soundex('Ann'), difference('Anne', 'Ann');
-- A500, A500, 4
SELECT soundex('Anne'), soundex('Andrew'), difference('Anne', 'Andrew');
-- A500, A536, 2
SELECT soundex('Anne'), soundex('Margaret'), difference('Anne', 'Margaret');
-- A500, M626, 0
difference 函数返回 0-4，其中 4 表示最相似。
Daitch-Mokotoff Soundex
返回 Daitch-Mokotoff soundex 编码集合（对非英语名称效果更好）：
SELECT daitch_mokotoff('George');
-- {595000}
SELECT daitch_mokotoff('John');
-- {160000,460000}
-- 查找发音类似 'Schwartzenegger' 的名称
SELECT * FROM s WHERE daitch_mokotoff(nm) && daitch_mokotoff('Schwartzenegger');
支持 GIN 索引：
CREATE INDEX ON s USING gin (daitch_mokotoff(nm) gin__int_ops);
Levenshtein 距离
计算两个字符串之间的编辑距离（插入、删除、替换）：
SELECT levenshtein('GUMBO', 'GAMBOL');
-- 2
SELECT levenshtein('GUMBO', 'GAMBOL', 2, 1, 1);
-- 3（自定义代价：插入=2，删除=1，替换=1）
-- 有界版本（更快，提前终止）
SELECT levenshtein_less_equal('extensive', 'exhaustive', 2);
-- 3（实际距离超过阈值，返回实际值）
SELECT levenshtein_less_equal('extensive', 'exhaustive', 4);
-- 4
返回字符串的 metaphone 编码：
SELECT metaphone('GUMBO', 4);
-- KM
返回主要和备选编码（处理更多名称变体）：
SELECT dmetaphone('gumbo');
-- KMP
SELECT dmetaphone_alt('gumbo');
-- KMP
77 - pg_trgm
文本相似度测量函数与模糊检索
概览
| ID | 扩展名 | Bin | Lib | Load | Create | Trust | Reloc | 模式 |
|---|
| 2390 | pg_trgm | 否 | 是 | 否 | 是 | 是 | 否 | - |
版本
| PG18 | PG17 | PG16 | PG15 | PG14 |
|---|
| 1.6 | 1.6 | 1.6 | 1.6 | 1.6 |
安装
提示：这是 PostgreSQL 内核自带的 contrib 扩展
CREATE EXTENSION pg_trgm;
用法
pg_trgm: 基于三元组的文本相似度度量和索引搜索
pg_trgm 模块提供了基于三元组匹配来确定字母数字文本相似度的函数和运算符，以及用于快速字符串相似度搜索的索引运算符类。
CREATE EXTENSION pg_trgm;
三元组是从字符串中提取的三个连续字符组。如果两个字符串共享许多三元组，则它们是相似的。
函数
| 函数 | 说明 |
|---|
similarity(text, text) → real | 返回 0 到 1 之间的相似度 |
show_trgm(text) → text[] | 返回字符串中所有三元组的数组 |
word_similarity(text, text) → real | 第一个字符串与第二个中最相似词的相似度 |
strict_word_similarity(text, text) → real | 类似但词边界匹配更严格 |
show_limit() → real | （已弃用） 返回 pg_trgm.similarity_threshold |
set_limit(real) → real | （已弃用） 设置 pg_trgm.similarity_threshold |
SELECT similarity('word', 'two words');
-- 0.36363637
SELECT show_trgm('word');
-- {" w"," wo",ord,"rd ",wor}
运算符
| 运算符 | 说明 |
|---|
text % text → boolean | 相似度 > pg_trgm.similarity_threshold 时为 true |
text <% text → boolean | 词相似度 > pg_trgm.word_similarity_threshold 时为 true |
text %> text → boolean | <% 的交换子 |
text <<% text → boolean | 严格词相似度 > 阈值时为 true |
text %>> text → boolean | <<% 的交换子 |
text <-> text → real | 距离（1 - 相似度） |
text <<-> text → real | 词距离（1 - 词相似度） |
text <->> text → real | <<-> 的交换子 |
text <<<-> text → real | 严格词距离 |
text <->>> text → real | <<<-> 的交换子 |
GUC 参数
| 参数 | 默认值 | 说明 |
|---|
pg_trgm.similarity_threshold | 0.3 | % 运算符的阈值 |
pg_trgm.word_similarity_threshold | 0.6 | <% 和 %> 运算符的阈值 |
pg_trgm.strict_word_similarity_threshold | 0.5 | <<% 和 %>> 运算符的阈值 |
索引支持
GiST 和 GIN 索引支持相似度运算符：
-- GIN 索引（查找更快，构建更慢）
CREATE INDEX trgm_idx ON test_trgm USING GIN (t gin_trgm_ops);
-- GiST 索引（支持 KNN 的距离运算符）
CREATE INDEX trgm_idx ON test_trgm USING GIST (t gist_trgm_ops);
-- 自定义签名长度的 GiST 索引
CREATE INDEX trgm_idx ON test_trgm USING GIST (t gist_trgm_ops(siglen=32));
文本搜索示例
使用三元组索引加速 LIKE / ILIKE / 正则查询：
SELECT t, similarity(t, 'word') AS sml
FROM test_trgm
WHERE t % 'word'
ORDER BY sml DESC, t;
-- 使用距离运算符的 KNN 搜索
SELECT t, t <-> 'word' AS dist
FROM test_trgm
ORDER BY dist
LIMIT 10;
GIN 和 GiST 三元组索引也能自动加速 LIKE、ILIKE、~ 和 ~* 查询。
78 - citus
Citus 分布式数据库
概览
conflict with hydra
版本
构建
您可以使用 pig build 命令构建 citus 扩展的 RPM / DEB 包：
pig build pkg citus # 构建 RPM / DEB 包
安装
您可以直接安装 citus 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install citus; # 当前活跃 PG 版本安装
pig ext install -y citus -v 18 # PG 18
pig ext install -y citus -v 17 # PG 17
pig ext install -y citus -v 16 # PG 16
dnf install -y citus_18 # PG 18
dnf install -y citus_17 # PG 17
dnf install -y citus_16 # PG 16
apt install -y postgresql-18-citus # PG 18
apt install -y postgresql-17-citus # PG 17
apt install -y postgresql-16-citus # PG 16
预加载配置：
shared_preload_libraries = 'citus';
创建扩展：
用法
citus: 面向多租户和实时分析的分布式 PostgreSQL
Citus 将 PostgreSQL 转变为分布式数据库，通过在多个节点间分片表来实现水平扩展。它支持多租户 SaaS 工作负载、实时分析和高吞吐量事务场景，同时保留完整的 PostgreSQL 功能集。
核心文档：
快速开始
启用扩展并添加工作节点：
CREATE EXTENSION citus;
-- 将协调节点添加到集群
SELECT citus_set_coordinator_host('coord-host', 5432);
SELECT * FROM citus_add_node('worker-1', 5432);
SELECT * FROM citus_add_node('worker-2', 5432);
-- 验证集群状态
SELECT * FROM citus_get_active_worker_nodes();
创建分布式表
通过指定分布列（分片键）来分布表。具有相同键值的行会被协同定位在同一个分片上。
CREATE TABLE events (
tenant_id INT,
event_id BIGSERIAL,
event_time TIMESTAMPTZ DEFAULT now(),
event_type TEXT,
payload JSONB,
PRIMARY KEY (tenant_id, event_id)
);
-- 按 tenant_id 进行哈希分布（默认：32 个分片）
SELECT create_distributed_table('events', 'tenant_id');
可以控制分片数量：
SELECT create_distributed_table('events', 'tenant_id', shard_count := 64);
引用表
需要与分布式表进行连接的小型查找表应创建为引用表。引用表会被完整复制到每个节点。
CREATE TABLE countries (
code CHAR(2) PRIMARY KEY,
name TEXT NOT NULL
);
SELECT create_reference_table('countries');
引用表可以与任何分布式表进行无限制的连接。
协同定位
基于相同列类型和分片数量进行分布的表会自动协同定位，即具有匹配分布键的行存储在同一节点上。这使得高效的本地连接成为可能。
CREATE TABLE tenants (
id INT PRIMARY KEY,
name TEXT
);
SELECT create_distributed_table('tenants', 'id');
CREATE TABLE orders (
tenant_id INT REFERENCES tenants(id),
order_id BIGSERIAL,
amount NUMERIC,
PRIMARY KEY (tenant_id, order_id)
);
SELECT create_distributed_table('orders', 'tenant_id');
-- 此连接被下推到各节点执行（无跨分片流量）
SELECT t.name, sum(o.amount)
FROM tenants t JOIN orders o ON t.id = o.tenant_id
GROUP BY t.name;
也可以显式指定协同定位组：
SELECT create_distributed_table('orders', 'tenant_id',
colocate_with := 'tenants');
分布式查询
Citus 尽可能将查询下推到各个分片。过滤分布列的查询会被路由到单个分片：
-- 单分片查询（快速，只访问一个节点）
SELECT * FROM events WHERE tenant_id = 42;
跨分片查询会在所有工作节点上并行执行：
-- 跨所有分片的并行聚合
SELECT event_type, count(*), avg(payload->>'duration')::numeric
FROM events
WHERE event_time > now() - INTERVAL '1 hour'
GROUP BY event_type
ORDER BY count DESC
LIMIT 10;
分布式连接
协同定位表之间基于分布列的连接在每个分片上本地执行：
-- 协同定位连接：高效，无数据移动
SELECT e.*, o.amount
FROM events e JOIN orders o
ON e.tenant_id = o.tenant_id
WHERE e.tenant_id = 42;
与引用表的连接可从任何分布式表发起：
SELECT e.*, c.name AS country_name
FROM events e JOIN countries c ON e.payload->>'country' = c.code;
节点管理
-- 添加新节点
SELECT * FROM citus_add_node('worker-3', 5432);
-- 移除节点（先将分片迁移到其他节点）
SELECT * FROM citus_drain_node('worker-1', 5432);
SELECT * FROM citus_remove_node('worker-1', 5432);
-- 临时禁用节点
SELECT * FROM citus_disable_node('worker-2', 5432);
SELECT * FROM citus_activate_node('worker-2', 5432);
-- 查看当前集群状态
SELECT * FROM citus_get_active_worker_nodes();
分片再平衡
添加或移除节点后，通过再平衡分片来均匀分配数据：
-- 再平衡所有分布式表
SELECT citus_rebalance_start();
-- 监控再平衡进度
SELECT * FROM citus_rebalance_status();
-- 再平衡特定表
SELECT rebalance_table_shards('events');
分片管理
-- 查看分片分布
SELECT * FROM citus_shards;
-- 查看分片大小
SELECT table_name, shard_count, citus_total_relation_size(table_name::text)
FROM citus_tables;
-- 将特定分片迁移到另一个节点
SELECT citus_move_shard_placement(shard_id, 'source-host', 5432, 'dest-host', 5432);
配置参数
用于调优 Citus 的关键 GUC 参数：
-- 多分片查询时每个节点的并行连接数
SET citus.max_adaptive_executor_pool_size = 4;
-- 分片复制因子（默认 1；无流复制时可设为 2 以实现高可用）
SET citus.shard_replication_factor = 1;
-- 控制执行器行为
SET citus.multi_shard_modify_mode = 'parallel'; -- 或 'sequential'
SET citus.enable_repartition_joins = on; -- 启用重分区连接
-- 任务分配策略
SET citus.task_assignment_policy = 'round-robin'; -- 或 'greedy'、'first-replica'
-- 记录分布式查询日志
SET citus.log_multi_join_order = on;
SET citus.explain_all_tasks = on;
示例：多租户 SaaS 模式
典型的多租户模式将所有租户相关的表按 tenant_id 进行分布：
CREATE TABLE tenants (
tenant_id INT PRIMARY KEY,
name TEXT,
plan TEXT DEFAULT 'free',
created_at TIMESTAMPTZ DEFAULT now()
);
SELECT create_distributed_table('tenants', 'tenant_id');
CREATE TABLE users (
tenant_id INT,
user_id BIGSERIAL,
email TEXT,
PRIMARY KEY (tenant_id, user_id)
);
SELECT create_distributed_table('users', 'tenant_id');
CREATE TABLE projects (
tenant_id INT,
project_id BIGSERIAL,
name TEXT,
owner_id BIGINT,
PRIMARY KEY (tenant_id, project_id)
);
SELECT create_distributed_table('projects', 'tenant_id');
-- 共享查找表：复制到每个节点
CREATE TABLE plans (
name TEXT PRIMARY KEY,
max_users INT,
max_projects INT
);
SELECT create_reference_table('plans');
-- 所有限定在单个租户范围内的连接都是协同定位的，查询速度快
SELECT u.email, p.name AS project
FROM users u
JOIN projects p ON u.tenant_id = p.tenant_id AND u.user_id = p.owner_id
WHERE u.tenant_id = 7;
示例：实时分析
用于仪表板和分析的分布式聚合：
CREATE TABLE page_views (
site_id INT,
url TEXT,
view_time TIMESTAMPTZ DEFAULT now(),
user_agent TEXT,
country CHAR(2)
);
SELECT create_distributed_table('page_views', 'site_id');
-- 实时汇总：跨分片并行执行
SELECT
date_trunc('minute', view_time) AS minute,
count(*) AS views,
count(DISTINCT country) AS countries
FROM page_views
WHERE site_id = 1
AND view_time > now() - INTERVAL '1 hour'
GROUP BY minute
ORDER BY minute DESC;
-- 所有站点的热门页面（跨分片并行查询）
SELECT url, count(*) AS views
FROM page_views
WHERE view_time > now() - INTERVAL '24 hours'
GROUP BY url
ORDER BY views DESC
LIMIT 20;
79 - citus_columnar
Citus 列式存储引擎
概览
conflict with hydra columnar, no pg18
版本
| OS / PG | PG18 | PG17 | PG16 | PG15 | PG14 |
|---|
| el8.x86_64 | PIGSTY 14.0.0 | PIGSTY 14.0.0 | PIGSTY 14.0.0 | PIGSTY 13.2.0 | PIGSTY 13.0.0 |
| el8.aarch64 | PIGSTY 14.0.0 | PIGSTY 14.0.0 | PIGSTY 14.0.0 | PIGSTY 13.2.0 | PIGSTY 13.0.0 |
| el9.x86_64 | PIGSTY 14.0.0 | PIGSTY 14.0.0 | PIGSTY 14.0.0 | PIGSTY 13.2.0 | PIGSTY 13.0.0 |
| el9.aarch64 | PIGSTY 14.0.0 | PIGSTY 14.0.0 | PIGSTY 14.0.0 | PIGSTY 13.2.0 | PIGSTY 13.0.0 |
| el10.x86_64 | PIGSTY 14.0.0 | PIGSTY 14.0.0 | PIGSTY 14.0.0 | PIGSTY 13.2.0 | PIGSTY MISS |
| el10.aarch64 | PIGSTY 14.0.0 | PIGSTY 14.0.0 | PIGSTY 14.0.0 | PIGSTY 13.2.0 | PIGSTY MISS |
| d12.x86_64 | PIGSTY 14.0.0 | PIGSTY 14.0.0 | PIGSTY 14.0.0 | PIGSTY 13.2.0 | PIGSTY 13.0.0 |
| d12.aarch64 | PIGSTY 14.0.0 | PIGSTY 14.0.0 | PIGSTY 14.0.0 | PIGSTY 13.2.0 | PIGSTY 13.0.0 |
| d13.x86_64 | PIGSTY 14.0.0 | PIGSTY 14.0.0 | PIGSTY 14.0.0 | PIGSTY 13.2.0 | PIGSTY MISS |
| d13.aarch64 | PIGSTY 14.0.0 | PIGSTY 14.0.0 | PIGSTY 14.0.0 | PIGSTY 13.2.0 | PIGSTY MISS |
| u22.x86_64 | PIGSTY 14.0.0 | PIGSTY 14.0.0 | PIGSTY 14.0.0 | PIGSTY 13.2.0 | PIGSTY 13.0.0 |
| u22.aarch64 | PIGSTY 14.0.0 | PIGSTY 14.0.0 | PIGSTY 14.0.0 | PIGSTY 13.2.0 | PIGSTY 13.0.0 |
| u24.x86_64 | PIGSTY 14.0.0 | PIGSTY 14.0.0 | PIGSTY 14.0.0 | PIGSTY 13.2.0 | PIGSTY 13.0.0 |
| u24.aarch64 | PIGSTY 14.0.0 | PIGSTY 14.0.0 | PIGSTY 14.0.0 | PIGSTY 13.2.0 | PIGSTY 13.0.0 |
构建
您可以使用 pig build 命令构建 citus 扩展的 RPM / DEB 包：
pig build pkg citus # 构建 RPM / DEB 包
安装
您可以直接安装 citus 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install citus; # 当前活跃 PG 版本安装
pig ext install -y citus -v 18 # PG 18
pig ext install -y citus -v 17 # PG 17
pig ext install -y citus -v 16 # PG 16
dnf install -y citus_18 # PG 18
dnf install -y citus_17 # PG 17
dnf install -y citus_16 # PG 16
apt install -y postgresql-18-citus # PG 18
apt install -y postgresql-17-citus # PG 17
apt install -y postgresql-16-citus # PG 16
创建扩展：
CREATE EXTENSION citus_columnar;
用法
citus_columnar: PostgreSQL 的列式存储访问方法
Citus Columnar 为 PostgreSQL 提供列式存储引擎。它以列式格式存储数据并自动压缩，非常适合在仅追加数据上执行分析工作负载，这类查询通常只读取部分列。
核心文档：
创建列式表
创建表时使用 USING columnar 子句：
CREATE TABLE events (
event_id BIGINT,
event_time TIMESTAMPTZ,
event_type TEXT,
user_id INT,
payload JSONB
) USING columnar;
压缩选项
可按表配置压缩方式。支持的方法：zstd（默认）、lz4、pglz、none。
ALTER TABLE events SET (
columnar.compression = zstd,
columnar.compression_level = 3
);
块组和条带设置
列式存储将数据组织为条带（stripe），每个条带包含多个块组（chunk group）。调整这些参数会影响压缩率和查询性能。
ALTER TABLE events SET (
columnar.stripe_row_limit = 150000, -- 每个条带的最大行数（默认 150000）
columnar.chunk_group_row_limit = 10000 -- 每个块组的行数（默认 10000）
);
适用场景
列式存储最适合以下场景：
- 分析和报表：查询只读取宽表中的少数列
- 仅追加工作负载（如日志、事件、时序归档）
- 大型事实表：需要批量扫描和聚合
- 冷数据归档：高压缩率非常有价值
限制
- 不支持 UPDATE 或 DELETE：列式表仅支持追加
- 不支持索引：仅支持顺序/列式扫描
- 不支持 TOAST：大值内联存储
- 不支持作为发布端的逻辑复制
- 不支持 tid 扫描
列投影和块组跳过
列式存储自动仅读取查询中引用的列（列投影），并跳过 min/max 元数据与查询条件不匹配的块组：
-- 仅读取 event_type 和 event_time 列；跳过不相关的块组
SELECT event_type, count(*)
FROM events
WHERE event_time > '2025-01-01'
GROUP BY event_type;
监控列式存储
查看条带和块组的元数据：
-- 查看列式表的条带信息
SELECT * FROM columnar.stripe WHERE relation = 'events'::regclass;
-- 查看块组详情
SELECT * FROM columnar.chunk_group WHERE relation = 'events'::regclass;
-- 检查存储大小和压缩率
SELECT pg_size_pretty(pg_total_relation_size('events')) AS total_size;
堆表和列式表之间的转换
将现有堆表转换为列式表：
-- 创建列式副本
CREATE TABLE events_columnar (LIKE events) USING columnar;
INSERT INTO events_columnar SELECT * FROM events;
-- 或使用 ALTER TABLE（Citus 11+）
SELECT alter_table_set_access_method('events', 'columnar');
将列式表转换回堆表：
SELECT alter_table_set_access_method('events', 'heap');
与分区结合使用
将列式存储与分区结合，保持近期数据在堆表中（支持更新/索引），将较旧的分区归档为列式存储：
CREATE TABLE events (
event_time TIMESTAMPTZ,
data JSONB
) PARTITION BY RANGE (event_time);
-- 近期数据：堆表（支持索引和更新）
CREATE TABLE events_current PARTITION OF events
FOR VALUES FROM ('2025-01-01') TO ('2026-01-01');
-- 归档数据：列式表（压缩存储，读取优化）
CREATE TABLE events_archive PARTITION OF events
FOR VALUES FROM ('2024-01-01') TO ('2025-01-01')
USING columnar;
80 - columnar
开源列式存储扩展
概览
| ID | 扩展名 | Bin | Lib | Load | Create | Trust | Reloc | 模式 |
|---|
| 2410 | columnar | 否 | 是 | 否 | 是 | 否 | 否 | - |
conflict with citus columnar, obsolete, no longer maintained
版本
构建
您可以使用 pig build 命令构建 hydra 扩展的 RPM / DEB 包：
pig build pkg hydra # 构建 RPM / DEB 包
安装
您可以直接安装 hydra 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install hydra; # 当前活跃 PG 版本安装
pig ext install -y hydra -v 16 # PG 16
pig ext install -y hydra -v 15 # PG 15
pig ext install -y hydra -v 14 # PG 14
dnf install -y hydra_16 # PG 16
dnf install -y hydra_15 # PG 15
dnf install -y hydra_14 # PG 14
apt install -y postgresql-16-hydra # PG 16
apt install -y postgresql-15-hydra # PG 15
apt install -y postgresql-14-hydra # PG 14
创建扩展：
CREATE EXTENSION columnar;
81 - pg_analytics
由 DuckDB 驱动的数据分析引擎
概览
| ID | 扩展名 | Bin | Lib | Load | Create | Trust | Reloc | 模式 |
|---|
| 2420 | pg_analytics | 否 | 是 | 是 | 是 | 否 | 否 | paradedb |
archived, no longer maintained
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PIGSTY | 0.3.7 | 1817161514 | pg_analytics | - |
| RPM | PIGSTY | 0.3.7 | 1817161514 | pg_analytics_$v | - |
| DEB | PIGSTY | 0.3.7 | 1817161514 | postgresql-$v-pg-analytics | - |
安装
您可以直接安装 pg_analytics 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install pg_analytics; # 当前活跃 PG 版本安装
pig ext install -y pg_analytics -v 17 # PG 17
pig ext install -y pg_analytics -v 16 # PG 16
pig ext install -y pg_analytics -v 15 # PG 15
pig ext install -y pg_analytics -v 14 # PG 14
dnf install -y pg_analytics_17 # PG 17
dnf install -y pg_analytics_16 # PG 16
dnf install -y pg_analytics_15 # PG 15
dnf install -y pg_analytics_14 # PG 14
apt install -y postgresql-17-pg-analytics # PG 17
apt install -y postgresql-16-pg-analytics # PG 16
apt install -y postgresql-15-pg-analytics # PG 15
apt install -y postgresql-14-pg-analytics # PG 14
预加载配置：
shared_preload_libraries = 'pg_analytics';
创建扩展：
CREATE EXTENSION pg_analytics;
此扩展已于 2025 年 3 月归档，不再维护。ParadeDB 的分析功能已整合到 pg_search 中。建议使用 pg_duckdb 或 pg_mooncake 作为数据湖分析的替代方案。
用法
https://github.com/paradedb/pg_analytics
示例：从 S3 读取 Parquet 文件：
CREATE EXTENSION pg_analytics;
CREATE FOREIGN DATA WRAPPER parquet_wrapper HANDLER parquet_fdw_handler VALIDATOR parquet_fdw_validator;
-- 提供 S3 凭证
CREATE SERVER parquet_server FOREIGN DATA WRAPPER parquet_wrapper;
-- 创建外部表并自动生成表结构
CREATE FOREIGN TABLE trips ()
SERVER parquet_server
OPTIONS (files 's3://paradedb-benchmarks/yellow_tripdata_2024-01.parquet');
-- 完成！现在可以像查询普通 PostgreSQL 表一样查询远程 Parquet 文件
SELECT COUNT(*) FROM trips;
count
---------
2964624
(1 row)
该外部数据包装器目前仅支持只读操作。
Iceberg 支持
CREATE EXTENSION pg_analytics;
CREATE FOREIGN DATA WRAPPER iceberg_wrapper
HANDLER iceberg_fdw_handler
VALIDATOR iceberg_fdw_validator;
CREATE SERVER iceberg_server
FOREIGN DATA WRAPPER iceberg_wrapper;
-- 请将示例中的占位结构替换为实际的表结构定义
CREATE FOREIGN TABLE iceberg_table (x INT)
SERVER iceberg_server
OPTIONS (files 's3://bucket/iceberg_folder');
-- 完成！现在可以查询 Iceberg 表了
SELECT COUNT(*) FROM iceberg_table;
82 - pg_duckdb
在PostgreSQL中的嵌入式DuckDB扩展
概览
| ID | 扩展名 | Bin | Lib | Load | Create | Trust | Reloc | 模式 |
|---|
| 2430 | pg_duckdb | 否 | 是 | 是 | 是 | 否 | 否 | public |
conflict with duckdb_fdw
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PIGSTY | 1.1.1 | 1817161514 | pg_duckdb | - |
| RPM | PIGSTY | 1.1.1 | 1817161514 | pg_duckdb_$v | - |
| DEB | PIGSTY | 1.1.1 | 1817161514 | postgresql-$v-pg-duckdb | - |
构建
您可以使用 pig build 命令构建 pg_duckdb 扩展的 RPM / DEB 包：
pig build pkg pg_duckdb # 构建 RPM / DEB 包
安装
您可以直接安装 pg_duckdb 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install pg_duckdb; # 当前活跃 PG 版本安装
pig ext install -y pg_duckdb -v 18 # PG 18
pig ext install -y pg_duckdb -v 17 # PG 17
pig ext install -y pg_duckdb -v 16 # PG 16
pig ext install -y pg_duckdb -v 15 # PG 15
pig ext install -y pg_duckdb -v 14 # PG 14
dnf install -y pg_duckdb_18 # PG 18
dnf install -y pg_duckdb_17 # PG 17
dnf install -y pg_duckdb_16 # PG 16
dnf install -y pg_duckdb_15 # PG 15
dnf install -y pg_duckdb_14 # PG 14
apt install -y postgresql-18-pg-duckdb # PG 18
apt install -y postgresql-17-pg-duckdb # PG 17
apt install -y postgresql-16-pg-duckdb # PG 16
apt install -y postgresql-15-pg-duckdb # PG 15
apt install -y postgresql-14-pg-duckdb # PG 14
预加载配置：
shared_preload_libraries = 'pg_duckdb';
创建扩展：
CREATE EXTENSION pg_duckdb;
用法
pg_duckdb 文档
快速上手
使用 pig 安装 pg_duckdb：
pig repo set
pig install pg_duckdb
编辑 postgresql.conf，然后重启使配置生效
shared_preload_libraries = 'pg_duckdb'
duckdb.allow_community_extensions = true
加速查询
通过 DuckDB 可以直接查询现有的 PostgreSQL 表，无需做任何修改：
-- pgbench -is 1000 # 使用 pgbench 初始化一些测试数据
CREATE EXTENSION pg_duckdb;
-- 默认行为，使用 PostgreSQL 原生引擎
SET duckdb.force_execution = false;
EXPLAIN ANALYZE SELECT count(*) FROM pgbench_accounts;
-- 现在查询将由 pg_duckdb 执行
SET duckdb.force_execution = true;
EXPLAIN ANALYZE SELECT count(*) FROM pgbench_accounts;
在本地笔记本电脑的 4 核虚拟机上，查询耗时从 8 秒降至 4 秒：
postgres@el9:5432/postgres=# SET duckdb.force_execution = true;
EXPLAIN ANALYZE SELECT count(*) FROM pgbench_accounts;
SET
Time: 0.206 ms
QUERY PLAN
------------------------------------------------------------------------------------------------------
Custom Scan (DuckDBScan) (cost=0.00..0.00 rows=0 width=0) (actual time=0.001..0.001 rows=0 loops=1)
DuckDB Execution Plan:
┌─────────────────────────────────────┐
│┌───────────────────────────────────┐│
││ Query Profiling Information ││
│└───────────────────────────────────┘│
└─────────────────────────────────────┘
EXPLAIN ANALYZE SELECT count(*) AS count FROM pgduckdb.public.pgbench_accounts
┌────────────────────────────────────────────────┐
│┌──────────────────────────────────────────────┐│
││ Total Time: 3.89s ││
│└──────────────────────────────────────────────┘│
└────────────────────────────────────────────────┘
┌───────────────────────────┐
│ QUERY │
└─────────────┬─────────────┘
┌─────────────┴─────────────┐
│ EXPLAIN_ANALYZE │
│ ──────────────────── │
│ 0 rows │
│ (0.00s) │
└─────────────┬─────────────┘
┌─────────────┴─────────────┐
│ UNGROUPED_AGGREGATE │
│ ──────────────────── │
│ Aggregates: │
│ count_star() │
│ │
│ 1 row │
│ (0.00s) │
└─────────────┬─────────────┘
┌─────────────┴─────────────┐
│ TABLE_SCAN │
│ ──────────────────── │
│ Table: │
│ pgbench_accounts │
│ │
│ 100,000,000 rows │
│ (3.88s) │
└───────────────────────────┘
数据湖
以下示例演示如何使用本地 MinIO 实例操作数据湖：
SELECT duckdb.create_simple_secret(
type := 'S3', key_id := 's3user_data', secret := 'S3User.Data',
endpoint := 'https://sss.pigsty:9000', url_style := 'path'
);
83 - pg_mooncake
PostgreSQL列式存储表
概览
| ID | 扩展名 | Bin | Lib | Load | Create | Trust | Reloc | 模式 |
|---|
| 2440 | pg_mooncake | 否 | 否 | 是 | 是 | 否 | 否 | - |
unpublished release
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PIGSTY | 0.2.0 | 1817161514 | pg_mooncake | pg_duckdb |
| RPM | PIGSTY | 0.2.0 | 1817161514 | pg_mooncake_$v | - |
| DEB | PIGSTY | 0.2.0 | 1817161514 | postgresql-$v-pg-mooncake | - |
构建
您可以使用 pig build 命令构建 pg_mooncake 扩展的 RPM / DEB 包：
pig build pkg pg_mooncake # 构建 RPM / DEB 包
安装
您可以直接安装 pg_mooncake 扩展包的预置二进制包，首先确保 PGDG 和 PIGSTY 仓库已经添加并启用：
pig repo add pgsql -u # 添加仓库并更新缓存
使用 pig 或者是 apt/yum/dnf 安装扩展：
pig install pg_mooncake; # 当前活跃 PG 版本安装
pig ext install -y pg_mooncake -v 18 # PG 18
pig ext install -y pg_mooncake -v 17 # PG 17
pig ext install -y pg_mooncake -v 16 # PG 16
pig ext install -y pg_mooncake -v 15 # PG 15
pig ext install -y pg_mooncake -v 14 # PG 14
dnf install -y pg_mooncake_18 # PG 18
dnf install -y pg_mooncake_17 # PG 17
dnf install -y pg_mooncake_16 # PG 16
dnf install -y pg_mooncake_15 # PG 15
dnf install -y pg_mooncake_14 # PG 14
apt install -y postgresql-18-pg-mooncake # PG 18
apt install -y postgresql-17-pg-mooncake # PG 17
apt install -y postgresql-16-pg-mooncake # PG 16
apt install -y postgresql-15-pg-mooncake # PG 15
apt install -y postgresql-14-pg-mooncake # PG 14
预加载配置：
shared_preload_libraries = 'pg_duckdb, pg_mooncake';
创建扩展：
CREATE EXTENSION pg_mooncake CASCADE; -- 依赖: pg_duckdb
用法
pg_mooncake 是一个 Postgres 扩展，能够为表创建 Iceberg 格式的列存镜像，设计为 pg_duckdb 的子扩展。
pg_mooncake 文档：https://docs.mooncake.dev/
快速上手
使用 pig 安装 pg_duckdb 和 pg_mooncake：
pig repo set
pig install pg_duckdb pg_mooncake
编辑 postgresql.conf，然后重启使配置生效
shared_preload_libraries = 'pg_duckdb,pg_mooncake'
duckdb.allow_community_extensions = true
wal_level = logical
入门示例
-- 连同 pg_duckdb 一起创建扩展
CREATE EXTENSION pg_mooncake CASCADE;
-- 接下来，创建一张普通的 Postgres 表 trades：
CREATE TABLE trades(
id bigint PRIMARY KEY,
symbol text,
time timestamp,
price real
);
-- 然后，创建一个列存镜像 trades_iceberg，与 trades 保持同步：
CALL mooncake.create_table('trades_iceberg', 'trades');
-- 现在，向 trades 中插入一些数据：
INSERT INTO trades VALUES
(1, 'AMD', '2024-06-05 10:00:00', 119),
(2, 'AMZN', '2024-06-05 10:05:00', 207),
(3, 'AAPL', '2024-06-05 10:10:00', 203),
(4, 'AMZN', '2024-06-05 10:15:00', 210);
-- 最后，使用 duckdb 进行查询
EXPLAIN
SELECT avg(price) FROM trades_iceberg WHERE symbol = 'AMZN';
执行计划中将显示 DuckDBScan：
QUERY PLAN
------------------------------------------------------------
Custom Scan (DuckDBScan) (cost=0.00..0.00 rows=0 width=0)
DuckDB Execution Plan:
┌───────────────────────────┐
│ UNGROUPED_AGGREGATE │
│ ──────────────────── │
│ Aggregates: avg(#0) │
└─────────────┬─────────────┘
┌─────────────┴─────────────┐
│ PROJECTION │
│ ──────────────────── │
│ CAST(price AS DOUBLE) │
│ │
│ ~0 rows │
└─────────────┬─────────────┘
┌─────────────┴─────────────┐
│ MOONCAKE_SCAN │
│ ──────────────────── │
│ Table: trades_iceberg │
│ Projections: price │
│ │
│ Filters: │
│ symbol='AMZN' │
│ │
│ ~0 rows │
└───────────────────────────┘
84 - storage_engine
带向量化执行的 colcompress 与 rowcompress 表访问方法
概览
release 1.0.7; SQL v1.0
版本
| 类型 | 仓库 | 版本 | PG 大版本 | 包名 | 依赖 |
|---|
| EXT | PIGSTY | 1.0.7 | 1817161514 | storage_engine | - |
| RPM | PIGSTY | 1.0.7 | 1817161514 | storage_engine_$v | - |
| DEB | PIGSTY | 1.0.7 | 1817161514 | postgresql-$v-storage-engine | - |