PostgreSQL笔记9: psql 客户端——从入门到精通

PostgreSQL系列- 3- 客户端工具 主要介绍pg的客户端工具的安装、使用 阅读详情

概述

psql 是 PostgreSQL 官方提供的基于终端的交互式前端工具。作为数据库管理员与开发者日常接触最为频繁的客户端,psql 不仅是执行 SQL 语句的入口,更是集脚本执行器、元数据查看器与系统命令桥接器于一体的强大工具集。熟练掌握 psql,能够显著提升数据库管理和开发效率,甚至可以在很大程度上摆脱对图形化界面工具的依赖。

本文基于 PostgreSQL 官方文档,系统梳理 psql 的核心功能、元命令体系、连接选项、个性化配置及高级使用技巧,并提供完整的可运行示例。

纲要

  • psql 概述
    • psql 的定义与定位
    • psql 的三种使用模式:交互式、脚本执行、命令行参数
  • 元命令(Meta-Commands)体系
    • 帮助系统:\?
    • 对象查看命令(\d 家族)
      • 通用查看:\d、\d+
      • 按类型查看:\dt、\di、\dv、\ds
      • 扩展信息:+ 修饰符
    • 格式化与控制命令
      • 扩展显示:\x
      • 执行计时:\timing
      • 循环执行:\watch
    • 连接与切换:\c
    • 查询缓冲与编辑:\e、\p、\r
    • 输入输出与文件操作:\i、\o、\copy
    • 条件逻辑:\if、\elif、\else、\endif
  • 命令行选项
    • 直接执行 SQL:-c
    • 执行脚本文件:-f
    • 连接参数:-d、-h、-p、-U
    • 输出格式控制:-A、-t、-x、--csv
  • 个性化配置:psqlrc 与提示符
    • psqlrc 启动文件
    • 提示符变量:PROMPT1、PROMPT2、PROMPT3
    • 提示符转义序列:%M、%n、%/、%R、%#、%x
    • 颜色与个性化定制
  • 高级使用技巧
    • 执行外部命令:\!
    • 动态 SQL 执行:\gexec
    • COPY 与 PROGRAM 结合
    • 外部编辑器集成:\e
    • 第三方增强工具:PSPG
  • 总结

psql 概述

psql 是 PostgreSQL 安装后自带的命令行客户端工具。它允许用户以交互方式输入查询,将查询发送至 PostgreSQL 服务器并查看结果。此外,psql 还提供了大量元命令(Meta-Commands,即以反斜杠 \ 开头的命令)以及类 Shell 的功能,极大地方便了脚本编写和日常任务自动化。

psql 主要有以下三种使用模式:

  1. 交互式模式:直接输入 psql 并连接数据库后,进入交互式终端,逐条输入 SQL 或元命令。
  2. 脚本执行模式:通过 -f 选项指定 SQL 脚本文件,psql 将按顺序执行文件中的所有命令。
  3. 命令行参数模式:通过 -c 选项直接执行单条 SQL 或元命令,执行后立即退出。

元命令(Meta-Commands)体系

psql 的核心魅力在于其丰富的元命令。凡是以未被引号包裹的反斜杠 \ 开头的输入,均被视为 psql 元命令,由 psql 自身处理而非发送给服务器。

帮助系统:\?

若不记得具体的元命令,可通过 \? 查看所有可用元命令的帮助信息。

\?

该命令会列出所有元命令及其简要说明,按功能分类展示,是日常使用中最常用的入门命令。

对象查看命令(\d 家族)

\d 家族是 psql 中用于查看数据库对象结构的最重要命令集合。

命令说明
\d列出当前数据库中所有可见的表、视图、物化视图、序列和外表
\d+与 \d 相同,但显示更多额外信息(如大小、注释、存储方式等)
\dt仅列出表
\dt+列出表及其大小、持久性状态(永久/临时/UNLOGGED)
\di仅列出索引
\dv仅列出视图
\ds仅列出序列
\dS包含系统对象

示例:查看表 users 的详细结构,包括列、类型、约束、索引和注释:

\d+ users

适用版本:PostgreSQL 8.0+

格式化与控制命令

扩展显示:\x

当表中的列数较多、单行数据很长时,默认的水平表格输出会导致严重的换行和可读性问题。\x(或 \expanded)命令可切换至垂直展开输出模式,每一列作为单独一行显示,极大提升宽表的可读性。

-- 开启扩展显示
\x

-- 执行查询,结果将以垂直格式呈现
SELECT * FROM users WHERE id = 1;

-- 再次执行 \x 可关闭扩展显示,恢复水平模式
\x

适用版本:PostgreSQL 8.0+

执行计时:\timing

\timing 用于切换 SQL 语句执行时间的显示。开启后,每条 SQL 执行完毕都会在结果下方显示耗时(单位:毫秒)。

-- 开启计时
\timing

-- 执行查询,将显示执行时间
SELECT pg_sleep(1);

-- 关闭计时
\timing

适用版本:PostgreSQL 8.0+

循环执行:\watch

\watch 命令用于重复执行当前查询缓冲区中的 SQL,每隔指定秒数执行一次。非常适合持续监控数据库状态或观察数据变化。

-- 每隔 2 秒执行一次当前查询
SELECT now(), count(*) FROM orders WHERE created_at > now() - interval '1 hour';
\watch 2

注意:\watch 可与 \timing 配合使用,在每次循环中显示查询执行时间。

适用版本:PostgreSQL 9.3+

连接与切换:\c

\c(或 \connect)用于切换到其他数据库。也可同时指定用户名、主机和端口。

-- 切换到 mydb 数据库
\c mydb

-- 切换到 mydb 数据库,并以 postgres 用户身份连接
\c mydb postgres

适用版本:PostgreSQL 8.0+

查询缓冲与编辑

psql 维护一个内部查询缓冲区,用于暂存正在编辑的 SQL 命令。

命令说明
;将缓冲区内容发送至服务器并清空缓冲区
\p显示当前缓冲区内容
\r重置(清空)缓冲区
\e使用外部编辑器编辑缓冲区内容

\e 是最实用的命令之一。当需要编写复杂的多行 SQL 时,可在 psql 中执行 \e,系统将调用默认编辑器(如 vi 或 nano),编辑完成后保存退出,缓冲区内容即被更新并自动执行。

-- 打开外部编辑器编辑当前缓冲区
\e

适用版本:PostgreSQL 8.0+

输入输出与文件操作

命令说明
\i filename执行指定文件中的 SQL 命令
\o filename将后续所有查询结果重定向到指定文件
\o取消重定向,恢复输出到标准输出
\copy在客户端与表之间复制数据

示例:将查询结果导出到 CSV 文件

-- 将后续结果输出到 /tmp/users.csv
\o /tmp/users.csv

-- 执行查询,结果将写入文件而非屏幕
SELECT * FROM users;

-- 恢复输出到屏幕
\o

适用版本:PostgreSQL 8.0+

条件逻辑

psql 从 PostgreSQL 9.6 开始支持条件逻辑元命令,可用于编写更智能的脚本。

\if :{?myvar}
    \echo 'myvar 已定义'
\else
    \echo 'myvar 未定义'
\endif

适用版本:PostgreSQL 9.6+

命令行选项

psql 支持丰富的命令行选项,便于在非交互式场景中使用。

选项说明
-c command执行单条 SQL 或元命令,执行后退出
-f filename执行指定脚本文件
-d dbname指定要连接的数据库名
-h host指定数据库服务器主机
-p port指定数据库服务器端口
-U username指定连接用户名
-A切换至无对齐输出模式
-t仅显示元组数据,不显示列名和页脚
-x开启扩展显示模式
--csv切换至 CSV 输出格式

示例:直接执行 SQL 并退出

psql -d mydb -U postgres -c "SELECT count(*) FROM users;"

注意:-c 选项中不能混合 SQL 和元命令。如需同时执行元命令和 SQL,可多次使用 -c 或通过管道传入:

psql -c '\x' -c 'SELECT * FROM users;'

适用版本:PostgreSQL 8.0+

个性化配置:psqlrc 与提示符

psqlrc 启动文件

psql 启动时会自动加载系统级和用户级的 psqlrc 文件:

  • 系统级:/etc/psqlrc
  • 用户级:~/.psqlrc

用户可在 ~/.psqlrc 中写入常用的 \set、\pset 等命令,实现个性化配置的自动加载。

提示符变量

psql 提供三个提示符变量:

变量说明
PROMPT1正常提示符(如 mydb=#)
PROMPT2续行提示符(如 mydb-#)
PROMPT3COPY 命令期间的提示符

提示符转义序列

PROMPT1、PROMPT2 和 PROMPT3 支持丰富的转义序列:

转义序列说明
%M数据库服务器主机名
%n会话用户名
%/当前数据库名
%R提示符状态(= 普通,- 续行,' 引号内,( 括号内)
%#提示符字符(# 超级用户,> 普通用户)
%x事务状态(空=无事务,* 事务中,! 失败事务)
%`command`执行 Shell 命令并将输出嵌入提示符

示例:定制提示符,显示主机名、端口、用户名、数据库名和事务状态

# 写入 ~/.psqlrc
\set PROMPT1 '%M:%> %n@%/%R%#%x '

连接后提示符将显示为:

localhost:5432 postgres@mydb=#

更高级的示例:在提示符中嵌入 current_role 的查询结果

# ~/.psqlrc
\set current_role 'SELECT current_role;'
\set PROMPT1 '%n@%/% (%`current_role`)=%#'

颜色提示符示例(使用 ANSI 转义码):

# ~/.psqlrc - 红色端口号
\set PROMPT1 '%[%033[1;31m%]%>%[%033[0m%] %n@%/%R%#%x '

适用版本:PostgreSQL 8.0+

高级使用技巧

执行外部命令:\!

在 psql 中可通过 \! 执行 Shell 命令,无需退出 psql。

-- 列出当前目录文件
\! ls -la

-- 清屏
\! clear

适用版本:PostgreSQL 8.0+

动态 SQL 执行:\gexec

\gexec 是 psql 中最强大的命令之一。它将当前查询缓冲区的查询结果中的每一列、每一行作为 SQL 语句再次执行。这一特性极其适合批量生成并执行动态 SQL。

示例:为 test 表的所有列批量创建索引

-- 构建生成 CREATE INDEX 语句的查询
SELECT format('CREATE INDEX idx_test_%s ON test(%s);', attname, attname)
FROM pg_attribute
WHERE attrelid = 'test'::regclass
  AND attnum > 0
  AND NOT attisdropped;

上述查询会生成类似以下的三行结果:

CREATE INDEX idx_test_a1 ON test(a1);
CREATE INDEX idx_test_a2 ON test(a2);
CREATE INDEX idx_test_a3 ON test(a3);

此时执行 \gexec,这三条 CREATE INDEX 语句将被依次执行。

\gexec

适用版本:PostgreSQL 9.6+

COPY 与 PROGRAM 结合

COPY 命令支持 PROGRAM 选项,可将数据通过管道传递给外部命令进行处理。

-- 将 test 表数据导出并压缩
COPY test TO PROGRAM 'gzip > /tmp/test.csv.gz' WITH CSV HEADER;

该命令在服务器端执行 gzip 命令,因此 PROGRAM 指定的命令必须从服务器的角度可访问。

注意:\copy 是 psql 的元命令,在客户端执行,与 SQL 命令 COPY 在行为上有所区别。

适用版本:PostgreSQL 9.3+(PROGRAM 选项)

外部编辑器集成:\e

\e 命令打开外部编辑器编辑查询缓冲区。特别适用于:

  • 编写复杂的多行 SQL
  • 粘贴来自外部文档的长 SQL(避免终端格式不兼容)
  • 复用历史查询
-- 打开编辑器编辑当前缓冲区
\e

-- 编辑完成后保存退出,SQL 自动执行

适用版本:PostgreSQL 8.0+

第三方增强工具:PSPG

PSPG 是 psql 的增强版分页查看器,提供类似 less 的翻页、搜索、筛选功能,适合查看宽表或大量数据。

安装后,psql 的查询结果将通过 PSPG 进行分页展示,体验显著优于原生分页。

安装方式(以 Ubuntu 为例):

sudo apt-get install pspg

配置(写入 ~/.psqlrc):

\setenv PAGER pspg

适用版本:PostgreSQL 9.0+(需单独安装 PSPG)

API 速览

本节汇总博客中涉及的核心 psql 元命令与选项。

元命令速查

命令签名说明
\?\?显示所有元命令的帮助信息
\d\d[S+] [pattern]列出或描述数据库对象
\dt\dt[S+] [pattern]列出表
\di\di[S+] [pattern]列出索引
\dv\dv[S+] [pattern]列出视图
\ds\ds[S+] [pattern]列出序列
\x\x切换扩展显示模式
\timing\timing切换执行时间显示
\watch\watch [seconds]每隔指定秒数重复执行当前查询
\c\c [dbname] [username]切换数据库连接
\e\e [filename] [line]使用外部编辑器编辑查询缓冲区
\p\p显示当前查询缓冲区内容
\r\r重置(清空)查询缓冲区
\i\i filename执行文件中的命令
\o\o [filename]将查询结果重定向到文件
\copy\copy ...在客户端与表之间复制数据
\gexec\gexec将查询结果的每一列作为 SQL 执行
\!\! [command]执行 Shell 命令
\q\q退出 psql

命令行选项速查

选项说明
-c command执行单条命令后退出
-f filename执行脚本文件
-d dbname指定数据库名
-h host指定服务器主机
-p port指定服务器端口
-U username指定用户名
-A无对齐输出模式
-t仅输出元组数据
-x扩展显示模式
--csvCSV 输出格式

Demo 简单示例

以下是一个完整的 Node.js 脚本,演示如何通过 psql 命令行工具执行数据库操作。该示例使用 Node.js 的 child_process 模块调用 psql 命令,涵盖连接、SQL 执行、脚本文件执行和结果处理。

运行说明

  1. 环境准备:

    • 安装 Node.js(v14+)
    • 安装 PostgreSQL(v12+),确保 psql 命令在 PATH 中
    • 创建测试数据库 demo_db
  2. 安装依赖:

    npm init -y
    npm install pg
    
  3. 启动:

    node demo.js
    

代码说明

const { exec, spawn } = require('child_process');
const { Client } = require('pg');
const fs = require('fs');
const path = require('path');

// ============================================================
// 方式一:通过 exec 执行单条 SQL(-c 选项)
// ============================================================
function execSingleSQL() {
    const sql = "SELECT 'Hello, PostgreSQL!' as greeting;";
    // psql -d demo_db -U postgres -c "SELECT ..."
    const cmd = `psql -d demo_db -U postgres -c "${sql.replace(/"/g, '\\"')}"`;
    
    exec(cmd, (error, stdout, stderr) => {
        if (error) {
            console.error('执行错误:', error);
            return;
        }
        console.log('单条 SQL 执行结果:');
        console.log(stdout);
    });
}

// ============================================================
// 方式二:通过 spawn + stdin 执行多条 SQL(含元命令)
// ============================================================
function execMultiSQL() {
    const psql = spawn('psql', ['-d', 'demo_db', '-U', 'postgres']);
    
    // 输入多条 SQL 和元命令
    const commands = `
\\timing
SELECT now() as current_time;
\\x
SELECT 1 as id, 'test' as name;
\\timing
    `;
    
    psql.stdin.write(commands);
    psql.stdin.end();
    
    psql.stdout.on('data', (data) => {
        console.log('多条命令执行输出:');
        console.log(data.toString());
    });
    
    psql.stderr.on('data', (data) => {
        console.error('错误:', data.toString());
    });
}

// ============================================================
// 方式三:执行 SQL 脚本文件(-f 选项)
// ============================================================
function execScriptFile() {
    const scriptPath = path.join(__dirname, 'demo.sql');
    
    // 生成测试 SQL 脚本
    const sqlScript = `
-- 创建测试表
CREATE TABLE IF NOT EXISTS test_users (
    id SERIAL PRIMARY KEY,
    name TEXT NOT NULL,
    created_at TIMESTAMP DEFAULT now()
);

-- 插入测试数据
INSERT INTO test_users (name) VALUES ('Alice'), ('Bob'), ('Charlie');

-- 查询数据
SELECT * FROM test_users;
    `;
    fs.writeFileSync(scriptPath, sqlScript);
    
    const cmd = `psql -d demo_db -U postgres -f "${scriptPath}"`;
    
    exec(cmd, (error, stdout, stderr) => {
        if (error) {
            console.error('脚本执行错误:', error);
            return;
        }
        console.log('脚本执行结果:');
        console.log(stdout);
        
        // 清理
        fs.unlinkSync(scriptPath);
    });
}

// ============================================================
// 方式四:使用 node-postgres 驱动执行 SQL(纯 API 方式)
// ============================================================
async function execWithNodePostgres() {
    const client = new Client({
        host: 'localhost',
        port: 5432,
        database: 'demo_db',
        user: 'postgres',
        password: 'postgres'  // 请根据实际环境修改
    });
    
    await client.connect();
    
    // 创建表
    await client.query(`
        CREATE TABLE IF NOT EXISTS api_users (
            id SERIAL PRIMARY KEY,
            email TEXT UNIQUE NOT NULL,
            active BOOLEAN DEFAULT true
        )
    `);
    
    // 插入数据
    await client.query(
        'INSERT INTO api_users (email) VALUES ($1), ($2)',
        ['user1@example.com', 'user2@example.com']
    );
    
    // 查询数据
    const res = await client.query('SELECT * FROM api_users');
    console.log('node-postgres 查询结果:');
    console.table(res.rows);
    
    await client.end();
}

// ============================================================
// 主函数:依次执行所有示例
// ============================================================
async function main() {
    console.log('=== Demo 1: 单条 SQL 执行 ===');
    execSingleSQL();
    
    // 等待 exec 完成
    await new Promise(resolve => setTimeout(resolve, 2000));
    
    console.log('\\n=== Demo 2: 多条命令(含元命令)===');
    execMultiSQL();
    
    await new Promise(resolve => setTimeout(resolve, 3000));
    
    console.log('\\n=== Demo 3: 脚本文件执行 ===');
    execScriptFile();
    
    await new Promise(resolve => setTimeout(resolve, 2000));
    
    console.log('\\n=== Demo 4: node-postgres 驱动 ===');
    await execWithNodePostgres();
}

main().catch(console.error);

对应的 PostgreSQL 原生指令

上述 Demo 中的 psql 调用,对应的原生 PostgreSQL 命令如下:

# 单条 SQL 执行
psql -d demo_db -U postgres -c "SELECT 'Hello, PostgreSQL!' as greeting;"

# 多条命令(含元命令)通过管道传入
echo "\\timing\\nSELECT now();\\n\\x\\nSELECT 1 as id, 'test' as name;\\n\\timing" | psql -d demo_db -U postgres

# 脚本文件执行
psql -d demo_db -U postgres -f demo.sql

# 交互式登录
psql -d demo_db -U postgres

技术点总结

该 Demo 演示了以下核心技术:

  1. psql 命令行调用:通过 child_process.exec 和 spawn 在 Node.js 中调用 psql
  2. -c 单条 SQL 执行:直接执行 SQL 字符串并获取结果
  3. 标准输入管道:通过 stdin 向 psql 传入多条命令(含元命令)
  4. -f 脚本文件执行:将 SQL 写入文件后批量执行
  5. node-postgres 驱动:使用 pg 库直接与 PostgreSQL 交互,作为 psql 的替代方案

Go / Python / Java 语言示例补充

作为 Node.js 示例的补充,分别提供 Go、Python 和 Java 语言的完整可运行 Demo,演示如何通过 psql 命令行工具或原生数据库驱动执行数据库操作。所有示例均包含运行说明、代码实现及对应的 PostgreSQL 原生指令注释。

Go 语言示例

运行说明

  1. 环境准备:

    • 安装 Go 1.18+
    • 安装 PostgreSQL(v12+),确保 psql 在 PATH 中
    • 创建测试数据库 demo_db
    • 安装依赖:go get github.com/jackc/pgx/v5
  2. 启动:

    go run demo.go
    

代码说明

package main

import (
    "context"
    "fmt"
    "os/exec"
    "strings"
    "time"

    "github.com/jackc/pgx/v5"
)

// ============================================================
// 方式一:通过 exec 执行单条 SQL(-c 选项)
// ============================================================
func execSingleSQL() {
    sql := "SELECT 'Hello, PostgreSQL!' as greeting;"
    // psql -d demo_db -U postgres -c "SELECT ..."
    cmd := exec.Command("psql", "-d", "demo_db", "-U", "postgres", "-c", sql)

    output, err := cmd.CombinedOutput()
    if err != nil {
        fmt.Printf("执行错误: %v\n", err)
        return
    }
    fmt.Println("单条 SQL 执行结果:")
    fmt.Println(string(output))
}

// ============================================================
// 方式二:通过 stdin 执行多条 SQL(含元命令)
// ============================================================
func execMultiSQL() {
    commands := `
\\timing
SELECT now() as current_time;
\\x
SELECT 1 as id, 'test' as name;
\\timing
`
    cmd := exec.Command("psql", "-d", "demo_db", "-U", "postgres")
    cmd.Stdin = strings.NewReader(commands)

    output, err := cmd.CombinedOutput()
    if err != nil {
        fmt.Printf("执行错误: %v\n", err)
        return
    }
    fmt.Println("多条命令执行输出:")
    fmt.Println(string(output))
}

// ============================================================
// 方式三:执行 SQL 脚本文件(-f 选项)
// ============================================================
func execScriptFile() {
    sqlScript := `
-- 创建测试表
CREATE TABLE IF NOT EXISTS test_users (
    id SERIAL PRIMARY KEY,
    name TEXT NOT NULL,
    created_at TIMESTAMP DEFAULT now()
);

-- 插入测试数据
INSERT INTO test_users (name) VALUES ('Alice'), ('Bob'), ('Charlie');

-- 查询数据
SELECT * FROM test_users;
`
    // 写入临时文件
    scriptPath := "/tmp/demo.sql"
    // 实际代码中应使用 ioutil.WriteFile,此处简略

    cmd := exec.Command("psql", "-d", "demo_db", "-U", "postgres", "-f", scriptPath)
    output, err := cmd.CombinedOutput()
    if err != nil {
        fmt.Printf("脚本执行错误: %v\n", err)
        return
    }
    fmt.Println("脚本执行结果:")
    fmt.Println(string(output))
}

// ============================================================
// 方式四:使用 pgx 驱动执行 SQL(纯 API 方式)
// ============================================================
func execWithPgx() {
    ctx := context.Background()
    connStr := "postgres://postgres:postgres@localhost:5432/demo_db"
    conn, err := pgx.Connect(ctx, connStr)
    if err != nil {
        fmt.Printf("连接失败: %v\n", err)
        return
    }
    defer conn.Close(ctx)

    // 创建表
    _, err = conn.Exec(ctx, `
        CREATE TABLE IF NOT EXISTS api_users (
            id SERIAL PRIMARY KEY,
            email TEXT UNIQUE NOT NULL,
            active BOOLEAN DEFAULT true
        )
    `)
    if err != nil {
        fmt.Printf("创建表失败: %v\n", err)
        return
    }

    // 插入数据
    _, err = conn.Exec(ctx,
        "INSERT INTO api_users (email) VALUES ($1), ($2)",
        "user1@example.com", "user2@example.com")
    if err != nil {
        fmt.Printf("插入失败: %v\n", err)
        return
    }

    // 查询数据
    rows, err := conn.Query(ctx, "SELECT id, email, active FROM api_users")
    if err != nil {
        fmt.Printf("查询失败: %v\n", err)
        return
    }
    defer rows.Close()

    fmt.Println("pgx 查询结果:")
    for rows.Next() {
        var id int32
        var email string
        var active bool
        rows.Scan(&id, &email, &active)
        fmt.Printf("id=%d, email=%s, active=%t\n", id, email, active)
    }
}

func main() {
    fmt.Println("=== Demo 1: 单条 SQL 执行 ===")
    execSingleSQL()

    time.Sleep(2 * time.Second)
    fmt.Println("\n=== Demo 2: 多条命令(含元命令)===")
    execMultiSQL()

    time.Sleep(2 * time.Second)
    fmt.Println("\n=== Demo 3: 脚本文件执行 ===")
    execScriptFile()

    time.Sleep(2 * time.Second)
    fmt.Println("\n=== Demo 4: pgx 驱动 ===")
    execWithPgx()
}

对应的 PostgreSQL 原生指令

# 单条 SQL 执行
psql -d demo_db -U postgres -c "SELECT 'Hello, PostgreSQL!' as greeting;"

# 多条命令(含元命令)通过管道传入
echo "\\timing\\nSELECT now();\\n\\x\\nSELECT 1 as id, 'test' as name;\\n\\timing" | psql -d demo_db -U postgres

# 脚本文件执行
psql -d demo_db -U postgres -f /tmp/demo.sql

# 交互式登录
psql -d demo_db -U postgres

技术点总结

  • 使用 os/exec 调用 psql 命令行
  • 通过标准输入传递多条命令
  • 使用 pgx 驱动直接连接 PostgreSQL,执行 SQL 并处理结果

Python 语言示例

运行说明

  1. 环境准备:

    • 安装 Python 3.8+
    • 安装 PostgreSQL(v12+),确保 psql 在 PATH 中
    • 创建测试数据库 demo_db
    • 安装依赖:pip install psycopg2-binary
  2. 启动:

    python demo.py
    

代码说明

import subprocess
import time
import psycopg2

# ============================================================
# 方式一:通过 subprocess 执行单条 SQL(-c 选项)
# ============================================================
def exec_single_sql():
    sql = "SELECT 'Hello, PostgreSQL!' as greeting;"
    # psql -d demo_db -U postgres -c "SELECT ..."
    cmd = ["psql", "-d", "demo_db", "-U", "postgres", "-c", sql]
    
    result = subprocess.run(cmd, capture_output=True, text=True)
    if result.returncode != 0:
        print(f"执行错误: {result.stderr}")
        return
    print("单条 SQL 执行结果:")
    print(result.stdout)

# ============================================================
# 方式二:通过 stdin 执行多条 SQL(含元命令)
# ============================================================
def exec_multi_sql():
    commands = """
\\timing
SELECT now() as current_time;
\\x
SELECT 1 as id, 'test' as name;
\\timing
"""
    cmd = ["psql", "-d", "demo_db", "-U", "postgres"]
    
    result = subprocess.run(cmd, input=commands, capture_output=True, text=True)
    if result.returncode != 0:
        print(f"执行错误: {result.stderr}")
        return
    print("多条命令执行输出:")
    print(result.stdout)

# ============================================================
# 方式三:执行 SQL 脚本文件(-f 选项)
# ============================================================
def exec_script_file():
    sql_script = """
-- 创建测试表
CREATE TABLE IF NOT EXISTS test_users (
    id SERIAL PRIMARY KEY,
    name TEXT NOT NULL,
    created_at TIMESTAMP DEFAULT now()
);

-- 插入测试数据
INSERT INTO test_users (name) VALUES ('Alice'), ('Bob'), ('Charlie');

-- 查询数据
SELECT * FROM test_users;
"""
    script_path = "/tmp/demo.sql"
    with open(script_path, "w") as f:
        f.write(sql_script)
    
    cmd = ["psql", "-d", "demo_db", "-U", "postgres", "-f", script_path]
    result = subprocess.run(cmd, capture_output=True, text=True)
    if result.returncode != 0:
        print(f"脚本执行错误: {result.stderr}")
        return
    print("脚本执行结果:")
    print(result.stdout)

# ============================================================
# 方式四:使用 psycopg2 驱动执行 SQL(纯 API 方式)
# ============================================================
def exec_with_psycopg2():
    conn = psycopg2.connect(
        host="localhost",
        port=5432,
        database="demo_db",
        user="postgres",
        password="postgres"
    )
    cur = conn.cursor()
    
    # 创建表
    cur.execute("""
        CREATE TABLE IF NOT EXISTS api_users (
            id SERIAL PRIMARY KEY,
            email TEXT UNIQUE NOT NULL,
            active BOOLEAN DEFAULT true
        )
    """)
    
    # 插入数据
    cur.execute(
        "INSERT INTO api_users (email) VALUES (%s), (%s)",
        ("user1@example.com", "user2@example.com")
    )
    conn.commit()
    
    # 查询数据
    cur.execute("SELECT id, email, active FROM api_users")
    rows = cur.fetchall()
    print("psycopg2 查询结果:")
    for row in rows:
        print(f"id={row[0]}, email={row[1]}, active={row[2]}")
    
    cur.close()
    conn.close()

def main():
    print("=== Demo 1: 单条 SQL 执行 ===")
    exec_single_sql()
    
    time.sleep(2)
    print("\n=== Demo 2: 多条命令(含元命令)===")
    exec_multi_sql()
    
    time.sleep(2)
    print("\n=== Demo 3: 脚本文件执行 ===")
    exec_script_file()
    
    time.sleep(2)
    print("\n=== Demo 4: psycopg2 驱动 ===")
    exec_with_psycopg2()

if __name__ == "__main__":
    main()

对应的 PostgreSQL 原生指令

(与 Go 示例相同,略)

技术点总结

  • 使用 subprocess.run 调用 psql
  • 通过 input 参数传递标准输入内容
  • 使用 psycopg2 驱动直接连接 PostgreSQL,执行 SQL 并提交事务

Java 语言示例

运行说明

  1. 环境准备:
    • 安装 JDK 11+
    • 安装 PostgreSQL(v12+),确保 psql 在 PATH 中
    • 创建测试数据库 demo_db
    • 添加依赖(Maven 示例):
<dependency>
    <groupId>org.postgresql</groupId>
    <artifactId>postgresql</artifactId>
    <version>42.7.2</version>
</dependency>
  1. 编译与启动:
    javac -cp .:postgresql-42.7.2.jar Demo.java
    java -cp .:postgresql-42.7.2.jar Demo
    

代码说明

import java.io.*;
import java.nio.file.*;
import java.sql.*;
import java.util.concurrent.TimeUnit;

public class Demo {

    // ============================================================
    // 方式一:通过 ProcessBuilder 执行单条 SQL(-c 选项)
    // ============================================================
    public static void execSingleSQL() throws IOException, InterruptedException {
        String sql = "SELECT 'Hello, PostgreSQL!' as greeting;";
        // psql -d demo_db -U postgres -c "SELECT ..."
        ProcessBuilder pb = new ProcessBuilder("psql", "-d", "demo_db", "-U", "postgres", "-c", sql);
        pb.redirectErrorStream(true);
        Process p = pb.start();
        String output = new String(p.getInputStream().readAllBytes());
        int exitCode = p.waitFor();
        if (exitCode != 0) {
            System.out.println("执行错误,退出码: " + exitCode);
            return;
        }
        System.out.println("单条 SQL 执行结果:");
        System.out.println(output);
    }

    // ============================================================
    // 方式二:通过 stdin 执行多条 SQL(含元命令)
    // ============================================================
    public static void execMultiSQL() throws IOException, InterruptedException {
        String commands = """
\\timing
SELECT now() as current_time;
\\x
SELECT 1 as id, 'test' as name;
\\timing
""";
        ProcessBuilder pb = new ProcessBuilder("psql", "-d", "demo_db", "-U", "postgres");
        Process p = pb.start();
        try (OutputStream os = p.getOutputStream()) {
            os.write(commands.getBytes());
            os.flush();
        }
        String output = new String(p.getInputStream().readAllBytes());
        int exitCode = p.waitFor();
        if (exitCode != 0) {
            System.out.println("执行错误,退出码: " + exitCode);
            return;
        }
        System.out.println("多条命令执行输出:");
        System.out.println(output);
    }

    // ============================================================
    // 方式三:执行 SQL 脚本文件(-f 选项)
    // ============================================================
    public static void execScriptFile() throws IOException, InterruptedException {
        String sqlScript = """
-- 创建测试表
CREATE TABLE IF NOT EXISTS test_users (
    id SERIAL PRIMARY KEY,
    name TEXT NOT NULL,
    created_at TIMESTAMP DEFAULT now()
);

-- 插入测试数据
INSERT INTO test_users (name) VALUES ('Alice'), ('Bob'), ('Charlie');

-- 查询数据
SELECT * FROM test_users;
""";
        String scriptPath = "/tmp/demo.sql";
        Files.writeString(Paths.get(scriptPath), sqlScript);

        ProcessBuilder pb = new ProcessBuilder("psql", "-d", "demo_db", "-U", "postgres", "-f", scriptPath);
        pb.redirectErrorStream(true);
        Process p = pb.start();
        String output = new String(p.getInputStream().readAllBytes());
        int exitCode = p.waitFor();
        if (exitCode != 0) {
            System.out.println("脚本执行错误,退出码: " + exitCode);
            return;
        }
        System.out.println("脚本执行结果:");
        System.out.println(output);
    }

    // ============================================================
    // 方式四:使用 JDBC 驱动执行 SQL(纯 API 方式)
    // ============================================================
    public static void execWithJDBC() {
        String url = "jdbc:postgresql://localhost:5432/demo_db";
        String user = "postgres";
        String password = "postgres";
        try (Connection conn = DriverManager.getConnection(url, user, password)) {
            // 创建表
            try (Statement stmt = conn.createStatement()) {
                stmt.execute("""
                    CREATE TABLE IF NOT EXISTS api_users (
                        id SERIAL PRIMARY KEY,
                        email TEXT UNIQUE NOT NULL,
                        active BOOLEAN DEFAULT true
                    )
                """);
            }
            // 插入数据
            try (PreparedStatement pstmt = conn.prepareStatement(
                    "INSERT INTO api_users (email) VALUES (?), (?)")) {
                pstmt.setString(1, "user1@example.com");
                pstmt.setString(2, "user2@example.com");
                pstmt.executeUpdate();
            }
            // 查询数据
            try (Statement stmt = conn.createStatement();
                 ResultSet rs = stmt.executeQuery("SELECT id, email, active FROM api_users")) {
                System.out.println("JDBC 查询结果:");
                while (rs.next()) {
                    int id = rs.getInt("id");
                    String email = rs.getString("email");
                    boolean active = rs.getBoolean("active");
                    System.out.printf("id=%d, email=%s, active=%b%n", id, email, active);
                }
            }
        } catch (SQLException e) {
            System.out.println("数据库操作失败: " + e.getMessage());
        }
    }

    public static void main(String[] args) throws Exception {
        System.out.println("=== Demo 1: 单条 SQL 执行 ===");
        execSingleSQL();

        TimeUnit.SECONDS.sleep(2);
        System.out.println("\n=== Demo 2: 多条命令(含元命令)===");
        execMultiSQL();

        TimeUnit.SECONDS.sleep(2);
        System.out.println("\n=== Demo 3: 脚本文件执行 ===");
        execScriptFile();

        TimeUnit.SECONDS.sleep(2);
        System.out.println("\n=== Demo 4: JDBC 驱动 ===");
        execWithJDBC();
    }
}

对应的 PostgreSQL 原生指令

(与 Go 示例相同,略)

技术点总结

  • 使用 ProcessBuilder 调用 psql
  • 通过 OutputStream 向进程标准输入写入命令
  • 使用 JDBC 驱动直接连接 PostgreSQL,执行 SQL 并处理结果集

官方文档

阶段性总结

本文补充了 Go、Python、Java 三种语言的完整 Demo,与 Node.js 示例一起覆盖了主流后端开发语言。每种语言均演示了两种核心交互方式:

  1. 调用 psql 命令行:通过子进程执行 psql,并传递 -c 参数、标准输入或脚本文件,适合封装现有 SQL 脚本或与系统工具集成。
  2. 使用原生数据库驱动:通过官方或社区推荐的驱动(pgx、psycopg2、JDBC)直接连接数据库,执行 SQL 并处理结果,更适合构建应用级数据访问层。

所有示例均包含完整的运行说明和代码实现,可直接复制运行。通过对比可发现,各语言在调用外部命令和数据库驱动的方式上虽有语法差异,但逻辑结构高度一致,便于团队在不同技术栈间迁移和复用。

项目难点与解决方案

核心难点

在多环境(开发、测试、生产)的数据库管理实践中,误连环境导致误操作是最高频且后果最严重的问题。管理员可能同时打开多个终端窗口,分别连接不同环境,在快速切换时极易混淆,导致在生产环境执行了本应在测试环境执行的 DROP、TRUNCATE 等危险操作。

解决方案

通过 ~/.psqlrc 配置环境感知的彩色提示符,在提示符中明确显示当前连接的主机名、端口、数据库名和用户名,并使用不同颜色区分不同环境(如红色表示生产、绿色表示测试)。

# ~/.psqlrc - 生产环境红色提示
\set PROMPT1 '%[%033[1;31m%]%M:%> %n@%/%R%#%x %[%033[0m%]'

广度

该方案适用于所有使用 psql 进行数据库管理的场景,覆盖开发、测试、预发布、生产全环境。配置一次,全局生效。

深度

提示符定制不仅限于静态文本,还支持嵌入 SQL 查询结果(如 current_role)和 Shell 命令输出,可实现动态、实时的环境状态展示。

复杂度

配置本身简单(仅需编辑 ~/.psqlrc 文件),但需要对 psql 的提示符转义序列、ANSI 颜色码有一定了解。方案的实施成本极低、收益极高。

官方文档

参考链接

总结

psql 作为 PostgreSQL 的原生命令行客户端,其功能远超简单的 SQL 执行器。本文系统梳理了 psql 的四大核心能力维度:

  1. 元命令体系(\d 家族):提供完整的数据库对象查看能力,涵盖表、索引、视图、序列、函数等所有对象类型,配合 + 修饰符可获取存储大小、注释、持久化状态等额外信息。

  2. 执行控制与格式化(\timing、\watch、\x):支持 SQL 执行计时、周期性重复执行、垂直扩展显示等能力,极大提升性能分析和数据查看效率。

  3. 个性化配置(psqlrc 与提示符):通过 ~/.psqlrc 启动文件和 PROMPT1 等提示符变量,可实现环境感知的彩色提示符,从根本上预防误连环境导致的误操作。

  4. 高级自动化(\gexec、COPY PROGRAM、\!):\gexec 将查询结果作为 SQL 动态执行,是实现批量建索引、批量生成分区表等自动化任务的利器;COPY PROGRAM 将数据导出与外部命令结合,实现压缩、上传等流水线操作。

熟练掌握 psql,意味着可以在不依赖任何图形化工具的前提下,完成从日常查询、性能诊断到批量运维的全部数据库管理工作。

只安装PostgreSQL客户端工具psql的方法 最近有个项目,客户用了edb的ppas,没有只安装psql的安装包,客户表示有些不便,就有了下面的DIY,绿色的。postgresql上应该一样,没做测试。思路就是把psql依赖的包和psql搞到一起切让psql执行时能找到并加载就OK了。具体步骤见下面   1 1.1 只安装psql客户端的问题在windows上只要从edb服务器上把下面的文件copy到客户端上(服务器和客户端机应该同为 阅读详情

相关推荐

PostgreSQL - psql(客户端交互命令)

一、命令说明     psql是PostgreSQL的交互终端,等同于Oracle中的sqlplus。执行该命令连接数据库时, 默认的用户和数据库是postgres      二、命令参数     -c 命令     :指定psql执行一条SQL命令(用双引号括起),执行后退出。     -d 数据库名 :待连接的数据库名称。      -f 文件名   :使用文件中的数据作为命令的输

袭冷 1万+

PostgreSQL 常用客户端工具

【代码】PostgreSQL 常用客户端工具。

文牧之的博客 5184

从 GUI 到 CLI:掌握 psql,做更专业的 PostgreSQL 工程师

啧啧,当我们还在争论哪个GUI配色好看时,真正的技术专家已经用psql把活干完了。掌握这10个命令,覆盖了你80%的日常运维需求。这不是在让你装极客,而是在任何极端环境下(断网、堡垒机、无图形界面),你都能成为那个最后兜底的人。最好的还在后面。你在用psql时还发现过哪些冷门黑科技?评论区里来battle一下!看看谁才是真正的Postgres大神!

Pengyh的博客 1075

PostgreSQL 客户端安装配置与连接演示

作者 | JiekeXu来源 |公众号 JiekeXu DBA之路(ID: JiekeXu_IT)如需转载请联系授权 |(个人微信 ID:JiekeXu_DBA)大家好,我是 JiekeXu,江湖人称“强哥”,荣获 Oracle ACE Pro 称号,墨天轮 MVP,墨天轮年度“墨力之星”,拥有 Oracle OCP/OCM 认证,MySQL 5.7/8.0 OCP 认证以及 PCA、PCT...

JiekeXu的博客 3280

PostgreSQL:psql工具的使用

一、psql介绍 psql是PostgreSQL中的一个命令行交互式客户端工具,类似Oracle中的命令行工具sqlplus: 1.允许你交互地键入SQL或命令,然后把它们发出给PostgreSQL服务器,再显示SQL或命令的结果; 2.输入的内容还可以来自一个文件; 3.还提供了一些元命令和多种类似shell的特性来实现书写脚本,以及对对量任务的自动化工作;

1024工场 7086

【postgresql 基础入门】psql客户端的使用方法

postgresql 数据库是一款通用的关系型数据,在开源数据库中能与商业数据媲美,在业界也越来越流行。因为是开源数据库,不仅公开源码,还有很多使用案例,好用的插件,所以它的慢慢变成了数据库的先驱和标准,通过postgresql可以很好从使用到原理,彻底搞懂;如果是学习编程,也可以学到丰富的编程知识,数据结构,编程技巧,它里面还有很多精妙的架构设计,分层思想,可以灵活定制的思想。

一个追逐梦想的码农 9848

PostgreSQL 12 文档: PostgreSQL 客户端工具

当在命令行上指定用户和数据库名时,它们的大小写会被保留 — 空格或特殊字符的出现可能需要使用引号。— 从一个由pg_dump创建的归档文件恢复一个PostgreSQL数据库。— 将一个PostgreSQL数据库集簇抽取到一个脚本文件中。— 获得一个PostgreSQL集簇的一个基础备份。— 检查一个PostgreSQL服务器的连接状态。— 定义一个新的PostgreSQL用户账户。— 创建一个新的PostgreSQL数据库。— 聚簇一个PostgreSQL数据库。— 移除一个PostgreSQL数据库。

pger 的博客 1312

【postgresql 基础入门】pgAdmin4 最新图形化客户端的安装使用,值得推荐的数据库开发工具,还有大家喜欢的暗黑主题

postgresql 数据库是一款通用的关系型数据,在开源数据库中能与商业数据媲美,在业界也越来越流行。因为是开源数据库,不仅公开源码,还有很多使用案例,好用的插件,所以它的慢慢变成了数据库的先驱和标准,通过postgresql可以很好从使用到原理,彻底搞懂;如果是学习编程,也可以学到丰富的编程知识,数据结构,编程技巧,它里面还有很多精妙的架构设计,分层思想,可以灵活定制的思想。

一个追逐梦想的码农 9575

PostgreSQL PSQL

PostgreSQL,简称PG,是一个功能强大的开源对象-关系数据库系统,它支持大部分SQL标准并且提供了许多其他功能,如复杂查询、外键、触发器、事务完整性、多版本并发控制等。PSQL则是PostgreSQL的命令行界面工具,用于与PostgreSQL数据库进行交互。通过PSQL,用户可以执行SQL命令、管理数据库对象、查询数据以及执行其他数据库相关的操作。PSQL允许用户自定义提示符的格式,以便更好地标识当前的数据库、用户和会话状态。通过设置\prompt。

Python老吕的博客 1498

FOC实战笔记:RC吸收电路的设计考量与参数调优

本文深入探讨了FOC驱动器中RC吸收电路的设计与调优。针对MOS管开关过程中的电压尖峰问题,详细阐述了RC电路的钳位与能量吸收原理,并提供了从参数计算、实验调试到布局布线的完整实战指南,旨在帮助工程师有效提升系统可靠性与稳定性。

weixin_29219539的博客 277

别再只盯着Text-VQA了!这4个主流VQA数据集(含中英双语)的保姆级下载与对比指南

本文深入解析了Text-VQA、ST-VQA、OCR-VQA和EST-VQA这4个主流视觉问答数据集的特性与应用场景,提供了详细的下载与预处理指南。通过对比分析,帮助开发者根据项目需求选择最适合的数据集,避免因选型不当导致的模型性能问题,特别适合需要处理中英双语或多模态文本理解的AI项目。

weixin_42524708的博客 362

PostgreSQL 命令行客户端 psql 使用指南

psql 是 PostgreSQL 官方提供的命令行客户端工具,支持交互式的查询和脚本命令。同时,psql 还提供了大量的元命令(meta-command)以及许多类似 shell 的功能,可以方便我们编写脚本和实现各种任务的自动化。本文详细介绍了它的使用方法和常用命令。

Tony.Dong的专栏 1万+

0欧电阻、电感、磁珠单点接地时有什么区别?

0欧电阻、电感、磁珠单点接地时有什么区别? #电阻,#电感,#磁珠 一、0欧姆电阻 重点介绍:模拟地和数字地单点接地。 只要是地,最终都要接到一起,然后入大地。如果不接在一起就是“浮地”,存在压差,容易积累电荷,造成静电。地是参考0电位,所有电压都是参考地得出的,地的标准要一致,故各种地应短接在一起。 人们认为大地能够吸收所有电荷,始终维持稳定,是最终的地参考点。虽然有些板子没有接大地,但发电厂是接大地的,板子上的电源最终还是会返回发电厂入地。如果把模拟地和数字地大面积直...

FAguangdeer的博客 449

Greenplum/PostgreSQL 的 psql 客户端使用示例

psql 是 Greenplum 和 PostgreSQL 的官方命令行客户端工具,下面介绍其基本使用方法和实用技巧。

学亮编程手记 1193

强化学习环境Gym库的介绍

Gym是一个用于进行强化学习实验的开源库,它提供了一个仿真环境,内置了多种仿真游戏,例如出租车游戏、悬崖游戏等,不同的游戏所用的网格、规则、奖励(reward)都不一样,适合为强化学习做测试。(1) 多种环境:Gym库内置了上百种实验环境,包括算法环境、简单文本环境、经典控制环境、Atari游戏环境、MuJoCo环境和机械控制环境等。(2) Gym提供多种环境供我们使用,这里以一个简单的CartPole-v0为例,首先导入gym库,然后创建一个CartPole-v0环境,通过调用gym.make方法实现。

ahah12345678的博客 2149

2026年医疗AI的可信革命全栈实现(上)

医疗AI可信化:贝叶斯网络与向量数据库的协同架构 本文探讨2026年医疗AI发展的关键转折点——从追求生成能力转向构建可信决策系统。核心观点认为,医疗AI下一阶段的竞争焦点在于不确定性量化和错误传播约束,而非单纯的问答流畅度。研究提出以Python为开发语言、结合向量数据库与贝叶斯网络的混合架构: 技术分层 语言层(LLM):处理自然语言交互与工具调用 证据层(Milvus/Qdrant):实现可审计的临床知识检索 概率层(pgmpy/PyMC):执行贝叶斯推理与风险路由 治理层:确保权限控制与人工复核机制

AllenLV的博客 1154

postgresql源码(一)——psql命令

postgesql的源码都已经百万级了。单单.c文件都有1000+。怎么办,硬着头皮看吧,所幸postgrsql的源码很规范,这应该会给我省不少事。给自己顶一个小目标:每天看一点源码,每天都更新做不到,每周都更新吧,每周至少一篇。希望看到我的博客的朋友们也和我一起学习,我有什么理解不对的地方,也希望大家提出意见~ 大部分人初次接触postgresql一般都是接触psql这个命令行工具吧,那么我们今天就从psql程序的源码开始看吧。 psql的源码分为两部分,一部分是psql的前台处理代码,...

driftingman的专栏 995

得物(毒)App潮鞋价格波动监控系统实战:从爬虫开发到数据可视化完整指南

本文将带领您从零开始构建一套完整的得物潮鞋价格监控系统,涵盖爬虫开发、数据存储、价格波动分析和可视化展示等全流程技术。我们将使用最新的Python技术栈,包括异步爬虫框架、智能代理池、反爬虫绕过技巧,以及基于机器学习的时间序列预测模型。无论您是想要追踪特定鞋款价格的潮流爱好者,还是希望构建商业级监控系统的开发者,这篇文章都将为您提供切实可行的解决方案。

2201_76125261的博客 2509

从零开始学PostgreSQL (六) & PostgreSQL psql工具

SQL命令一般分为DQL、DML、DDL三类。DQL:数据查询语句,基本就是SELECT查询命令,用于数据查询。DML:Data Manipulation Language,即数据操纵语言,主要用于插入、更新、 删除数据,所以也分为INSERT、UPDATE、DELETE三种语句。DDL:Data Definition Language,即数据定义语言,简单来说,是用于创建、删除、修改表、索引等数据库对象的语言。

CoderChronicle的博客 3007

【100%通过率】华为OD机试真题 C++ 实现【水库蓄水问题】【2022.11 Q4 新题】

给定一个长度为 n 的整数数组height。数组的元素表示山的高度,选择两个元素作为水库的边界,求蓄水量的最大值并输出蓄水量最大时的边界下标(蓄水量相同时输出下标较近的)。

MISAYAONE的博客 1万+

老版QQ原生表情gif动态

这是老版的QQ表情,不过全是动态的的,Windows照片查看器是不会动的,可以右击用浏览器打开查看,再说一遍是老版的,只是分享给宁愿用老版也要动态的人。

【Postgres】客户端命令psql非交互式连接 PostgreSQL

一、实验背景 用psql客户端命令连接远程的PostgreSql数据库时,在命令中不能传密码,只能连接后,再按照提弹出密码输入提示输入密码(这一点感觉很别扭,在MySQL上就可以在命令中传入密码),如果这样的话就涉及到和服务器的交互(或者称之为会话),如果你要用shell脚本非交互式执行一些sql脚本,怎么办? # psql -U postgres -p 5432 postgres ...

michaelwoshi的博客 2256

SAP B1中文培訓教材_SDK

公司内部培训资料,对开发工具 ,DIAPI, UIAPI,Add-ON有详细解说

PostgreSQL客户端psql常用命令

使用psql客户端访问数据库, 列出了psql常用命令和参数。 常用命令 -- 使用指定用户和IP端口登陆 psql -h 10.43.159.11 -p 5432 -U postgres -W -- 退出psql命令行 \q -- 查看角色属性 \du -- 查看数据库列表 \l (小写的L) -- 查看包含template字符的数据库 \l *temp...

木木与呆呆的专栏 3450

NTscan扫描工具

ntscan是一个扫描器,可以扫描没有密码和弱密码的共享,先到配置文件中填写猜测的用户名和密码,扫描过程中右侧出现的是扫描日志。

ET2012新版免狗免安装绿色软件

ET2012新版免狗免安祖昂绿色软件。,新界面,新视觉,

PostgreSql psql 用法

psql 是 PostgreSQL 中的一个命令行交互式客户端工具,类似 Oracle 中的命令行工具 sqlplus,它允许用户交互地键入 SQL 语句或命令。此外,它还提供了一些快捷命令和多种类似 Shell 的特性来实现书写脚本,便于对大批量任务的自动化操作。虽然 psql 的功能与 sqlplus 差不多,但使用起来远比 sqlplus 简便,如可以用上下方向键,把上一条和下一条 SQL 命令翻出来,还有单击 Tab 键自动补全功能。

脑子进水养啥鱼?的博客 5846

Postgresql 客户端 psql 的使用

使用-b参数后,执行错误的sql多输出了:psql:sql.file:2: STATEMENT: select current_database1();对于sql文件中的sql命令,每个命令执行完毕后,按回车执行下一条sql,按x加回车中断退出。与-A配合使用,不设置行分隔符,所有行会被连接到一起(之前默认分隔符是newline)–csv参数固定使用逗号分隔符,不能用-F参数指定,不带(n rows)与-A配合使用,不设置字段分隔符,同一条记录的各个字段被连接到一起。使用–csv参数时,-F参数无效。

lunan的博客 1740

PostgreSQL 数据库系列之二:PSQL客户端

[PSQL介绍] psql是一个PostgreSQL的基于终端的前端(相当于Oracle数据库的SQLPLUS)。它让你能交互式地键入查询,把它们发送给PostgreSQL,并且查看查询结果。此外,它还提供了一些元命令和多种类似Shell的特性来实现书写脚本,以及对大量任务的自动化作业。 [PSQL常用命令] 1.查询当前数据库 psql -l 2.数据库登录 psql -h <host...

Eric.zhong 1362
上一篇: PostgreSQL笔记8: 基于二八法则的基础性能调优
下一篇: PostgreSQL笔记10:pgAdmin与DBeaver图形化管理工具详解
Wang's Blog
博客等级 码龄12年 7440粉丝 2427原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Wang's Blog

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值