PostgreSQL バージョン確認完全ガイド – あらゆる方法と活用テクニック

「使っているPostgreSQLのバージョンって何だっけ？」 「新機能を使いたいけど、対応しているかな？」 「セキュリティアップデートは適用されている？」

PostgreSQLのバージョンを正確に把握することは、データベース管理において非常に重要です。バージョンによって使える機能が違いますし、セキュリティパッチの適用状況も確認できます。

この記事では、PostgreSQLのバージョンを確認する様々な方法から、バージョン情報の詳しい読み方、互換性の確認方法まで、実践的に解説していきます。

バージョン確認の基本的な方法

方法1：SELECT version() – 最も詳細な情報

-- SQLクエリでバージョンを確認（最も詳細）
SELECT version();

-- 結果例
-- version
-- ------------------------------------------------------------------------
-- PostgreSQL 15.3 on x86_64-pc-linux-gnu, compiled by gcc (GCC) 11.3.0, 64-bit

-- より見やすく整形
SELECT 
    split_part(version(), ' ', 2) AS postgresql_version,
    split_part(version(), ' on ', 2) AS system_info;

取得できる情報：

• PostgreSQLのバージョン番号
• オペレーティングシステム
• コンパイラ情報
• ビット数（32bit/64bit）

方法2：SHOW server_version – シンプルな表示

-- バージョン番号のみを表示
SHOW server_version;

-- 結果例
-- server_version
-- ---------------
-- 15.3

-- 詳細なバージョン番号
SHOW server_version_num;

-- 結果例
-- server_version_num
-- -------------------
-- 150003

server_version_numの読み方：

• 150003 = 15.0003 = バージョン 15.3
• 140012 = 14.0012 = バージョン 14.12
• 090605 = 9.6.5 = バージョン 9.6.5

方法3：psqlコマンドラインから確認

# psql起動時に表示される
psql -U postgres
# psql (15.3)
# Type "help" for help.

# psqlのバージョンを確認
psql --version
# psql (PostgreSQL) 15.3

# より詳細な情報
psql -V
# psql (PostgreSQL) 15.3

方法4：コマンドラインから直接確認

# PostgreSQLサーバーのバージョン
postgres --version
# postgres (PostgreSQL) 15.3

# または
postgres -V
# postgres (PostgreSQL) 15.3

# パッケージマネージャーで確認（Ubuntu/Debian）
dpkg -l | grep postgresql

# パッケージマネージャーで確認（RHEL/CentOS）
rpm -qa | grep postgresql

# パッケージマネージャーで確認（macOS Homebrew）
brew list --versions postgresql

方法5：pg_configコマンドを使用

# pg_configでバージョンと詳細情報を確認
pg_config --version
# PostgreSQL 15.3

# すべての設定情報を表示
pg_config

# 特定の情報のみ取得
pg_config --bindir     # バイナリのディレクトリ
pg_config --configure  # コンパイルオプション
pg_config --cflags     # コンパイルフラグ

システムカタログからの詳細情報取得

PostgreSQL内部情報の確認

-- システム設定からバージョン情報を取得
SELECT 
    name,
    setting,
    unit,
    category,
    short_desc
FROM pg_settings
WHERE name LIKE '%version%'
ORDER BY name;

-- 結果例
-- name                | setting | unit | category      | short_desc
-- -------------------+---------+------+---------------+--------------------------------
-- server_version     | 15.3    |      | Preset Options| Shows the server version
-- server_version_num | 150003  |      | Preset Options| Shows the server version number

-- 拡張機能のバージョンも含めて確認
SELECT 
    name,
    default_version,
    installed_version,
    comment
FROM pg_available_extensions
WHERE installed_version IS NOT NULL
ORDER BY name;

バージョン互換性の確認

-- 現在のバージョンと互換性レベルを確認
SELECT 
    current_setting('server_version') AS current_version,
    current_setting('server_version_num')::int AS version_num,
    CASE 
        WHEN current_setting('server_version_num')::int >= 150000 THEN 'PostgreSQL 15.x'
        WHEN current_setting('server_version_num')::int >= 140000 THEN 'PostgreSQL 14.x'
        WHEN current_setting('server_version_num')::int >= 130000 THEN 'PostgreSQL 13.x'
        WHEN current_setting('server_version_num')::int >= 120000 THEN 'PostgreSQL 12.x'
        WHEN current_setting('server_version_num')::int >= 110000 THEN 'PostgreSQL 11.x'
        WHEN current_setting('server_version_num')::int >= 100000 THEN 'PostgreSQL 10.x'
        ELSE 'PostgreSQL 9.x or older'
    END AS major_version,
    CASE 
        WHEN current_setting('server_version_num')::int >= 140000 THEN 'Current stable'
        WHEN current_setting('server_version_num')::int >= 120000 THEN 'Older stable'
        WHEN current_setting('server_version_num')::int >= 100000 THEN 'Extended support'
        ELSE 'End of life - アップグレード推奨'
    END AS support_status;

プログラムからバージョンを確認

Python（psycopg2）

import psycopg2

# データベースに接続
conn = psycopg2.connect(
    host="localhost",
    database="postgres",
    user="postgres",
    password="password"
)

cursor = conn.cursor()

# バージョンを取得
cursor.execute("SELECT version()")
version = cursor.fetchone()[0]
print(f"PostgreSQL version: {version}")

# サーバーバージョン番号を取得
print(f"Server version: {conn.server_version}")
# 150003 のような数値が返る

# メジャーバージョンとマイナーバージョンを分離
major = conn.server_version // 10000
minor = conn.server_version % 10000
print(f"Major: {major}, Minor: {minor}")

conn.close()

Node.js（pg）

const { Client } = require('pg');

async function checkVersion() {
    const client = new Client({
        host: 'localhost',
        database: 'postgres',
        user: 'postgres',
        password: 'password',
    });

    await client.connect();

    // バージョンを取得
    const result = await client.query('SELECT version()');
    console.log('PostgreSQL version:', result.rows[0].version);

    // サーバーバージョン番号を取得
    const versionNum = await client.query('SHOW server_version_num');
    console.log('Version number:', versionNum.rows[0].server_version_num);

    await client.end();
}

checkVersion();

Java（JDBC）

import java.sql.*;

public class PostgreSQLVersion {
    public static void main(String[] args) {
        String url = "jdbc:postgresql://localhost:5432/postgres";
        String user = "postgres";
        String password = "password";

        try (Connection conn = DriverManager.getConnection(url, user, password)) {
            // メタデータからバージョンを取得
            DatabaseMetaData metaData = conn.getMetaData();
            System.out.println("Database Product Version: " + 
                metaData.getDatabaseProductVersion());
            System.out.println("Driver Version: " + 
                metaData.getDriverVersion());
            
            // SQLクエリでバージョンを取得
            Statement stmt = conn.createStatement();
            ResultSet rs = stmt.executeQuery("SELECT version()");
            if (rs.next()) {
                System.out.println("PostgreSQL Version: " + rs.getString(1));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

バージョン別の主要機能確認

利用可能な機能をバージョンで判定

-- バージョンに応じた機能の可用性チェック
DO $$
DECLARE
    version_num INTEGER;
    features TEXT := '';
BEGIN
    version_num := current_setting('server_version_num')::INTEGER;
    
    -- PostgreSQL 15の新機能
    IF version_num >= 150000 THEN
        features := features || 'PostgreSQL 15 features available:' || chr(10);
        features := features || '- MERGE statement' || chr(10);
        features := features || '- JSON_TABLE' || chr(10);
        features := features || '- Improved compression' || chr(10);
    END IF;
    
    -- PostgreSQL 14の機能
    IF version_num >= 140000 THEN
        features := features || 'PostgreSQL 14 features available:' || chr(10);
        features := features || '- Multirange types' || chr(10);
        features := features || '- JSON subscripting' || chr(10);
        features := features || '- VACUUM improvements' || chr(10);
    END IF;
    
    -- PostgreSQL 13の機能
    IF version_num >= 130000 THEN
        features := features || 'PostgreSQL 13 features available:' || chr(10);
        features := features || '- Incremental sorting' || chr(10);
        features := features || '- Parallel VACUUM' || chr(10);
        features := features || '- Deduplication for B-tree indexes' || chr(10);
    END IF;
    
    -- PostgreSQL 12の機能
    IF version_num >= 120000 THEN
        features := features || 'PostgreSQL 12 features available:' || chr(10);
        features := features || '- Generated columns' || chr(10);
        features := features || '- JSON path queries' || chr(10);
        features := features || '- CTE materialization control' || chr(10);
    END IF;
    
    RAISE NOTICE '%', features;
END $$;

機能の互換性チェック

-- 特定の機能が使えるかチェックする関数
CREATE OR REPLACE FUNCTION check_feature_compatibility(feature_name TEXT)
RETURNS BOOLEAN AS $$
DECLARE
    version_num INTEGER;
BEGIN
    version_num := current_setting('server_version_num')::INTEGER;
    
    CASE feature_name
        WHEN 'MERGE' THEN
            RETURN version_num >= 150000;
        WHEN 'MULTIRANGE' THEN
            RETURN version_num >= 140000;
        WHEN 'GENERATED_COLUMNS' THEN
            RETURN version_num >= 120000;
        WHEN 'PARALLEL_VACUUM' THEN
            RETURN version_num >= 130000;
        WHEN 'PROCEDURES' THEN
            RETURN version_num >= 110000;
        WHEN 'DECLARATIVE_PARTITIONING' THEN
            RETURN version_num >= 100000;
        ELSE
            RETURN FALSE;
    END CASE;
END;
$$ LANGUAGE plpgsql;

-- 使用例
SELECT 
    'MERGE' AS feature,
    check_feature_compatibility('MERGE') AS available
UNION ALL
SELECT 
    'GENERATED_COLUMNS',
    check_feature_compatibility('GENERATED_COLUMNS')
UNION ALL
SELECT 
    'PARALLEL_VACUUM',
    check_feature_compatibility('PARALLEL_VACUUM');

クライアントとサーバーのバージョン不一致確認

psqlとサーバーのバージョン比較

-- psqlクライアントとサーバーのバージョンを比較
\echo 'Client version:' :VERSION
SELECT 'Server version: ' || version() AS server_version;

-- プログラムで確認
CREATE OR REPLACE FUNCTION check_version_compatibility()
RETURNS TABLE(
    component TEXT,
    version TEXT,
    status TEXT
) AS $$
BEGIN
    RETURN QUERY
    SELECT 
        'PostgreSQL Server'::TEXT,
        current_setting('server_version')::TEXT,
        'Active'::TEXT
    UNION ALL
    SELECT 
        'Protocol Version'::TEXT,
        current_setting('server_version_num')::TEXT,
        CASE 
            WHEN current_setting('server_version_num')::INT >= 100000 THEN 'Modern'
            ELSE 'Legacy'
        END::TEXT;
END;
$$ LANGUAGE plpgsql;

SELECT * FROM check_version_compatibility();

複数サーバーのバージョン管理

バージョン情報を収集するスクリプト

#!/bin/bash
# check_all_pg_versions.sh

# サーバーリスト
SERVERS=("localhost:5432" "db-server1:5432" "db-server2:5433")

echo "PostgreSQL Version Check Report"
echo "================================"
echo ""

for SERVER in "${SERVERS[@]}"; do
    HOST=$(echo $SERVER | cut -d: -f1)
    PORT=$(echo $SERVER | cut -d: -f2)
    
    echo "Server: $HOST:$PORT"
    VERSION=$(psql -h $HOST -p $PORT -U postgres -t -c "SELECT version()" 2>/dev/null)
    
    if [ $? -eq 0 ]; then
        echo "Version: $VERSION"
    else
        echo "Version: Connection failed"
    fi
    echo "---"
done

バージョン情報の定期収集

-- バージョン履歴を記録するテーブル
CREATE TABLE IF NOT EXISTS version_history (
    id SERIAL PRIMARY KEY,
    check_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    hostname TEXT,
    port INTEGER,
    pg_version TEXT,
    pg_version_num INTEGER,
    os_info TEXT,
    compiler_info TEXT
);

-- バージョン情報を記録する関数
CREATE OR REPLACE FUNCTION log_version_info()
RETURNS VOID AS $$
DECLARE
    full_version TEXT;
BEGIN
    SELECT version() INTO full_version;
    
    INSERT INTO version_history (
        hostname,
        port,
        pg_version,
        pg_version_num,
        os_info,
        compiler_info
    )
    SELECT 
        inet_server_addr()::TEXT,
        inet_server_port(),
        split_part(full_version, ' ', 2),
        current_setting('server_version_num')::INTEGER,
        split_part(split_part(full_version, ' on ', 2), ', compiled', 1),
        split_part(full_version, 'compiled by ', 2);
END;
$$ LANGUAGE plpgsql;

-- 定期実行（例：毎日）
SELECT log_version_info();

-- 履歴を確認
SELECT 
    check_date,
    hostname || ':' || port AS server,
    pg_version,
    os_info
FROM version_history
ORDER BY check_date DESC
LIMIT 10;

アップグレード判定と計画

アップグレードの必要性を判定

-- アップグレード推奨度を判定する関数
CREATE OR REPLACE FUNCTION check_upgrade_recommendation()
RETURNS TABLE(
    current_version TEXT,
    latest_stable TEXT,
    support_status TEXT,
    upgrade_priority TEXT,
    recommendation TEXT
) AS $$
DECLARE
    version_num INTEGER;
    major_version INTEGER;
BEGIN
    version_num := current_setting('server_version_num')::INTEGER;
    major_version := version_num / 10000;
    
    RETURN QUERY
    SELECT 
        current_setting('server_version')::TEXT,
        '16.0'::TEXT AS latest_stable,  -- 2024年12月時点
        CASE 
            WHEN major_version >= 15 THEN 'Current stable'
            WHEN major_version >= 13 THEN 'Supported'
            WHEN major_version >= 11 THEN 'Extended support'
            ELSE 'End of life'
        END::TEXT,
        CASE 
            WHEN major_version >= 15 THEN 'Low'
            WHEN major_version >= 13 THEN 'Medium'
            WHEN major_version >= 11 THEN 'High'
            ELSE 'Critical'
        END::TEXT,
        CASE 
            WHEN major_version >= 15 THEN 'Up to date - no immediate action needed'
            WHEN major_version >= 13 THEN 'Plan upgrade within 6-12 months'
            WHEN major_version >= 11 THEN 'Upgrade recommended within 3-6 months'
            ELSE 'Immediate upgrade required for security'
        END::TEXT;
END;
$$ LANGUAGE plpgsql;

SELECT * FROM check_upgrade_recommendation();

拡張機能の互換性確認

-- インストール済み拡張機能とバージョンの確認
SELECT 
    e.extname AS extension_name,
    e.extversion AS current_version,
    x.default_version AS available_version,
    CASE 
        WHEN e.extversion = x.default_version THEN 'Up to date'
        ELSE 'Update available'
    END AS status,
    obj_description(e.oid, 'pg_extension') AS description
FROM pg_extension e
LEFT JOIN pg_available_extensions x ON e.extname = x.name
WHERE e.extname NOT IN ('plpgsql')  -- デフォルト拡張を除外
ORDER BY e.extname;

-- 拡張機能のアップデート可能性を確認
SELECT 
    name,
    installed_version,
    default_version,
    CASE 
        WHEN installed_version IS NULL THEN 'Not installed'
        WHEN installed_version = default_version THEN 'Current'
        ELSE 'Update to ' || default_version
    END AS action
FROM pg_available_extensions
WHERE installed_version IS NOT NULL
  AND installed_version != default_version;

Docker環境でのバージョン確認

Dockerコンテナのバージョン確認

# 実行中のPostgreSQLコンテナを確認
docker ps | grep postgres

# コンテナ内でバージョン確認
docker exec -it postgres_container psql -U postgres -c "SELECT version()"

# イメージのバージョンタグを確認
docker images | grep postgres

# docker-compose.ymlでバージョン指定
cat docker-compose.yml | grep "image:"
# image: postgres:15.3-alpine

Docker Composeでの複数バージョン管理

# docker-compose.yml
version: '3.8'

services:
  postgres15:
    image: postgres:15.3-alpine
    environment:
      POSTGRES_PASSWORD: password
    ports:
      - "5432:5432"
    
  postgres14:
    image: postgres:14.9-alpine
    environment:
      POSTGRES_PASSWORD: password
    ports:
      - "5433:5432"
    
  postgres13:
    image: postgres:13.12-alpine
    environment:
      POSTGRES_PASSWORD: password
    ports:
      - "5434:5432"

クラウド環境でのバージョン確認

AWS RDS

-- RDS特有の情報を含めて確認
SELECT 
    version() AS postgresql_version,
    current_setting('rds.extensions') AS rds_extensions;

-- RDSのエンジンバージョンを確認
SELECT 
    aurora_version() AS aurora_version  -- Aurora PostgreSQLの場合
WHERE EXISTS (
    SELECT 1 FROM pg_proc WHERE proname = 'aurora_version'
);

Google Cloud SQL

# gcloudコマンドで確認
gcloud sql instances describe INSTANCE_NAME | grep databaseVersion

# Cloud Consoleから確認も可能

Azure Database for PostgreSQL

# Azure CLIで確認
az postgres server show \
    --resource-group myresourcegroup \
    --name myserver \
    --query version

バージョン確認の自動化

監視スクリプト

#!/usr/bin/env python3
import psycopg2
import json
from datetime import datetime

def check_postgresql_versions(servers):
    """複数のPostgreSQLサーバーのバージョンをチェック"""
    results = []
    
    for server in servers:
        try:
            conn = psycopg2.connect(**server['connection'])
            cursor = conn.cursor()
            
            # バージョン情報を取得
            cursor.execute("SELECT version()")
            full_version = cursor.fetchone()[0]
            
            cursor.execute("SELECT current_setting('server_version')")
            short_version = cursor.fetchone()[0]
            
            cursor.execute("SELECT current_setting('server_version_num')")
            version_num = cursor.fetchone()[0]
            
            results.append({
                'server': server['name'],
                'status': 'OK',
                'version': short_version,
                'version_num': version_num,
                'full_version': full_version,
                'checked_at': datetime.now().isoformat()
            })
            
            conn.close()
            
        except Exception as e:
            results.append({
                'server': server['name'],
                'status': 'ERROR',
                'error': str(e),
                'checked_at': datetime.now().isoformat()
            })
    
    return results

# サーバーリスト
servers = [
    {
        'name': 'Production DB',
        'connection': {
            'host': 'prod-db.example.com',
            'database': 'postgres',
            'user': 'postgres',
            'password': 'password'
        }
    },
    {
        'name': 'Development DB',
        'connection': {
            'host': 'dev-db.example.com',
            'database': 'postgres',
            'user': 'postgres',
            'password': 'password'
        }
    }
]

# チェック実行
results = check_postgresql_versions(servers)
print(json.dumps(results, indent=2))

# アラート判定
for result in results:
    if result['status'] == 'ERROR':
        print(f"ALERT: {result['server']} is not accessible!")
    elif result.get('version_num', '0') < '130000':
        print(f"WARNING: {result['server']} needs upgrade (version: {result.get('version', 'unknown')})")

トラブルシューティング

バージョンが確認できない場合

-- 権限の確認
SELECT has_function_privilege('version()', 'EXECUTE');

-- 代替方法1：システムカタログから
SELECT setting FROM pg_settings WHERE name = 'server_version';

-- 代替方法2：ファイルシステムから（スーパーユーザーのみ）
SELECT pg_read_file('PG_VERSION');

バージョン不一致の警告

-- クライアントとサーバーのバージョン不一致を検出
DO $$
DECLARE
    server_major INTEGER;
    msg TEXT;
BEGIN
    server_major := (current_setting('server_version_num')::INTEGER / 10000);
    
    -- ここでクライアントバージョンと比較
    -- 実際の実装では、アプリケーション側で確認
    
    msg := format('Server version: PostgreSQL %s', current_setting('server_version'));
    RAISE NOTICE '%', msg;
END $$;

まとめ：バージョン管理で安定運用を実現

PostgreSQLのバージョン確認について、様々な方法と活用テクニックを解説してきました。

重要なポイント：

1. SELECT version()が最も詳細な情報を提供
2. server_version_numで数値比較が可能
3. クライアントとサーバーのバージョン整合性を確認
4. 定期的なバージョンチェックで適切なアップグレード計画
5. 拡張機能のバージョンも含めて管理

バージョン情報は単なる数字ではなく、以下の判断材料になります：

• 使用可能な機能の確認
• セキュリティアップデートの必要性
• パフォーマンス改善の機会
• 互換性の問題の予防

今すぐ実践：

1. 現在のバージョンを確認
2. サポート状況をチェック
3. アップグレード計画を立案
4. 定期的な確認の仕組みを構築

適切なバージョン管理で、安定したPostgreSQL運用を実現しましょう！