GaussDB数据库应用程序开发指引
1.1 驱动概述
（一）驱动概念
数据库驱动是应用程序与数据库管理系统之间的桥梁，是数据库厂商为特定开发语言环境（如 Java、C、Python）开发的一组 API，封装了连接管理、SQL 执行、结果获取、错误处理等底层细节。GaussDB 支持 JDBC、ODBC、Psycopg 三种核心驱动接口，满足不同开发场景需求。
（二）客户端接入认证
远程连接 GaussDB 需先配置数据库服务器并完成认证，支持三种认证方式：
基于主机的认证：服务器根据客户端 IP、用户名、目标数据库查询配置文件判断是否通过；
口令认证：含远程连接的加密口令认证和本地连接的非加密口令认证；
SSL 加密：通过 OpenSSL 提供服务器端与客户端的安全连接环境。
服务器配置步骤
以集群安装用户登录 GaussDB 集群任意主机；
执行命令配置监听地址（英文逗号分隔多个 IP / 主机名）：plaintext gs_guc reload -Z coordinator -N NodeName -I all -c "listen_addresses='localhost,10.11.12.13'"
执行命令添加认证规则（示例允许用户 jack 从 10.11.12.13/32 网段以 sha256 加密方式访问所有数据库）：plaintext gs_guc reload -Z coordinator -N all -I all -h "host all jack 10.11.12.13/32 sha256"
1.2 JDBC 接口介绍
（一）JDBC 概述
定义：Java 数据库连接（JDBC）是 Java 标准，通过java.sql和javax.sql包提供连接关系型数据库的 API，JDBC 4.0 符合 SQL 2003 标准；
支持版本：兼容 JDBC 4.0，要求 JDK 8 及以上版本；
核心包功能：
java.sql：提供基本数据库编程服务（连接生成、SQL 执行、批处理、事务隔离等）；
javax.sql：提供高级操作接口（连接池、分布式事务、行集等）；
体系结构：分为 JDBC API（应用程序调用接口）、JDBC Driver Manager（驱动管理载入）、JDBC Driver（数据库连接驱动）三层。
（二）GaussDB JDBC 驱动
1. 驱动包类型及特性
|
驱动包名称 |
适用场景 |
连接 URL 前缀 |
核心特性 |
|
gsjdbc4.jar |
与 PostgreSQL 兼容，原 PG 应用可直接移植 |
jdbc:postgresql |
类名、结构与 PG 驱动一致 |
|
gsjdbc200.jar |
同一 JVM 需同时访问 PG 和 GaussDB |
jdbc:gaussdb |
避免类名冲突 |
|
opengaussjdbc.jar |
独立使用 GaussDB |
jdbc:opengauss |
主类名：com.huawei.opengauss.jdbc.Driver |
2. 驱动增强特性
支持 SHA256 加密登录；
兼容实现 slf4j 接口的第三方日志框架；
支持连接级分布式负载均衡；
支持容灾切换。
3. 支持的核心接口类
|
接口类 |
说明 |
|
|
|
java.sql.Connection |
数据库连接接口 |
|
|
|
java.sql.CallableStatement |
存储过程执行接口 |
|
|
|
java.sql.DatabaseMetaData |
数据库对象定义接口 |
|
|
|
java.sql.Driver |
数据库驱动接口 |
|
|
|
java.sql.PreparedStatement |
预处理语句接口（不支持 executeLargeUpdate） |
|
|
|
java.sql.ResultSet |
执行结果集接口 |
|
|
|
java.sql.Statement |
SQL 语句接口（LargeUpdate 相关方法需 JDBC4.2+） |
|
|
|
javax.sql.DataSource |
数据源接口 |
|
|
|
CopyManager |
批量导入数据的 API 接口类 |
|
|
|
PGReplicationConnection |
执行逻辑复制的 API 接口类 |
|
|
（三）JDBC 基本操作
1. 操作流程
加载驱动 → 连接数据库 → 执行 SQL 语句 → 处理结果集 → 关闭连接
2. 关键操作实现
（1）加载驱动与建立连接
方式 1：使用用户名 / 密码直接连接java 运行 public static Connection getConnect(String username, String passwd) {
String driver = "org.postgresql.Driver"; // gsjdbc4.jar驱动类
String sourceURL = "jdbc:postgresql://IP:PORT/database";
Connection conn = null;
try {
Class.forName(driver); // 加载驱动
conn = DriverManager.getConnection(sourceURL, username, passwd); // 建立连接
System.out.println("Connection succeed!");
} catch (Exception e) {
e.printStackTrace();
return null;
}
return conn;
}
方式 2：使用 Properties 对象配置连接（含 SSL）java 运行 public static Connection getConnect(String username, String passwd) {
String driver = "org.postgresql.Driver";
String sourceURL = "jdbc:postgresql://IP:PORT/database";
Properties info = new Properties();
Connection conn = null;
try {
Class.forName(driver);
info.setProperty("user", username);
info.setProperty("password", passwd);
info.setProperty("ssl", "true");
info.setProperty("sslmode", "verify-ca");
info.setProperty("sslcert", "client.crt");
info.setProperty("sslkey", "client.key.pk8");
info.setProperty("sslrootcert", "cacert.pem");
conn = DriverManager.getConnection(sourceURL, info);
} catch (Exception e) {
e.printStackTrace();
return null;
}
return conn;
}
（2）执行 SQL 语句
Statement（静态 SQL，无参数）java 运行 Statement stmt = conn.createStatement();
// 执行查询（返回ResultSet）
ResultSet rs = stmt.executeQuery("SELECT first_name FROM employees");
// 执行DML/DDL（返回影响行数）
int rowCount = stmt.executeUpdate("INSERT INTO test VALUES(1, 'test')");
PreparedStatement（预编译 SQL，支持参数绑定，性能更优）java 运行 PreparedStatement pstmt = conn.prepareStatement("UPDATE test SET name = ? WHERE id = 1");
pstmt.setShort(1, (short)2); // 绑定参数（索引从1开始）
int rowCount = pstmt.executeUpdate(); // 执行SQL
pstmt.close();
批处理（批量执行 SQL，提升效率）java 运行 conn.setAutoCommit(false); // 关闭自动提交
PreparedStatement ps = conn.prepareStatement("insert into t1 values(?,?)");
Timestamp ts = new Timestamp(System.currentTimeMillis());
for (int i = 0; i < 10000; i++) {
ps.setInt(1, i);
ps.setTimestamp(2, ts);
ps.addBatch(); // 添加到批处理
}
ps.executeBatch(); // 执行批处理
conn.commit(); // 手动提交事务
游标查询（避免大数据量内存溢出）java 运行 conn.setAutoCommit(false);
Statement st = conn.createStatement();
st.setFetchSize(50); // 开启游标，每次获取50行
ResultSet rs = st.executeQuery("SELECT * FROM t1");
while (rs.next()) {
System.out.println("a row was returned.");
}
st.setFetchSize(0); // 关闭游标
（3）处理结果集
ResultSet 游标定位方法：next()（向下移动）、previous()（向上移动）、first()（定位到第一行）、last()（定位到最后一行）等；
结果提取：通过getXXX()方法（如getString()、getInt()）根据列索引或列名提取数据；
元数据获取：通过ResultSetMetaData获取列数、列名、列类型等信息。
（4）关闭资源
需显式关闭 ResultSet、Statement/PreparedStatement、Connection，避免内存泄露：
java
运行
rs.close();
stmt.close();
conn.close();
3. DataSource 与 ORM 框架集成
DataSource 接口核心方法：getConnection()（建立连接）、setLoginTimeout()（设置连接超时）等；
Mybatis 集成示例（Spring 环境）：java 运行 @Configuration
@ComponentScan(basePackages="com")
@MapperScan(basePackages = "com.dao")
public class MybatisConfig {
@Autowired
private MybatisProperties mybatisProperties;
@Bean
public DataSource dataSource() {
DruidDataSource dataSource = new DruidDataSource();
dataSource.setDriverClassName(mybatisProperties.getDriver());
dataSource.setUrl(mybatisProperties.getUrl());
dataSource.setUsername(mybatisProperties.getUsername());
dataSource.setPassword(mybatisProperties.getPassword());
return dataSource;
}
@Bean
public SqlSessionFactoryBean sqlSessionFactoryBean(DataSource dataSource) throws IOException {
SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
sqlSessionFactoryBean.setDataSource(dataSource);
PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
Resource[] resources = resolver.getResources(mybatisProperties.getMapperLocations());
sqlSessionFactoryBean.setMapperLocations(resources);
sqlSessionFactoryBean.setTypeAliasesPackage(mybatisProperties.getTypeAliasesPackage());
return sqlSessionFactoryBean;
}
}
（四）JDBC 负载均衡配置
1. 配置格式
plaintext
jdbc:postgresql://host1:port1,host2:port2/database?autoBalance=[value]
autoBalance=false：默认值，不开启负载均衡；
支持三种负载均衡策略：轮询、优先级、随机。
2. 策略详情
|
策略类型 |
配置值 |
核心逻辑 |
示例 |
|
轮询 |
true/balance/roundrobin |
定期获取可用 CN 列表（默认 10 秒刷新），按顺序分配连接 |
jdbc:postgresql://host1:port1,host2:port2/db?autoBalance=true |
|
优先级 |
priorityn（n 为数字） |
优先使用 URL 中前 n 个可用 CN，全部不可用时随机分配至其他 CN |
jdbc:postgresql://host1:port1,host2:port2/db?autoBalance=priority2 |
|
随机 |
shuffle |
定期获取可用 CN 列表，随机分配连接 |
jdbc:postgresql://host1:port1,host2:port2/db?autoBalance=shuffle |
3. 读写分离与故障转移
配置格式：
plaintext
jdbc:postgresql://host1:port1,host2:port2/database?targetServerType=[value]
|
targetServerType 值 |
功能 |
|
|
|
master |
仅连接主节点（不可用时抛异常） |
|
|
|
slave |
仅连接备节点（不可用时抛异常） |
|
|
|
preferSlave |
优先连接备节点，不可用时连接主节点 |
|
|
|
any |
连接任意节点 |
|
|
节点状态刷新周期：默认 10 秒（通过hostRecheckSeconds参数配置）。
（五）JDBC 日志配置
1. 配置参数
日志功能通过 URL 参数启用，支持三个核心参数：
logger：日志框架类型（支持 Slf4JLogger、JdkLogger，默认 JdkLogger）；
loggerLevel：日志级别（OFF/INFO/DEBUG/TRACE，OFF 为关闭）；
loggerFile：日志输出路径（未指定则默认流输出）。
2. 配置示例
plaintext
jdbc:postgresql://host1:port1/database?logger=Slf4JLogger&loggerLevel=trace&loggerFile=jdbc.log
3. Slf4J 日志框架对接（log4j.properties 示例）
properties
log4j.appender.log_gsjdbc=org.apache.log4j.RollingFileAppender
log4j.appender.log_gsjdbc.Append=true
log4j.appender.log_gsjdbc.File=gsjdbc.log
log4j.appender.log_gsjdbc.Threshold=TRACE
log4j.appender.log_gsjdbc.MaxFileSize=10MB
log4j.appender.log_gsjdbc.MaxBackupIndex=5
log4j.appender.log_gsjdbc.layout=org.apache.log4j.PatternLayout
log4j.appender.log_gsjdbc.layout.ConversionPattern=%d %p %t %c - %m%n
log4j.appender.log_gsjdbc.File.Encoding=UTF-8
1.3 ODBC 接口介绍
（一）ODBC 概述
定义：开放数据库互连（ODBC）是基于 X/OPEN CLI 的应用程序编程接口，作为应用程序与数据库的中间件，支持 C/C++ 等语言访问数据库；
实现组件：
ODBC 驱动：如 psqlodbc（GaussDB 适配），是 ODBC API 的具体实现；
ODBC 驱动管理器：开源方案包括 unixODBC 和 iODBC，负责加载具体驱动；
C/C++ 应用程序：通过 ODBC API 访问数据库；
支持环境： | 操作系统 | 平台 | | --- | --- | | CentOS 6.4-6.9、7.0-7.4 | x86_64 位 | | CentOS 7.6 | ARM64 位 | | EulerOS 2.0 SP2/SP3 | x86_64 位 | | EulerOS 2.0 SP8 | ARM64 位 |
操作流程：申请句柄资源 → 设置环境属性 → 连接数据源 → 执行 SQL 语句 → 处理结果集 → 断开连接 → 释放句柄资源。
（二）ODBC 安装配置
1. 安装 ODBC 驱动管理器（unixODBC）
编译安装：bash 运行 tar zxvf unixODBC-2.3.7.tar.gz
cd unixODBC-2.3.7
vim configure # 修改LIB_VERSION为"1:0:0"，编译生成*.so.1动态库
./configure --enable-gui=no # ARM服务器需追加：--build=aarch64-unknown-linux-gnu
make
make install # 需root权限，默认安装到/usr/local目录
2. 配置 GaussDB ODBC 驱动
解压 GaussDB ODBC 驱动包（GaussDB-Kernel-VxxxRxxxCxx-EULER-64bit-Odbc.tar.gz）；
将 psqlodbc * 相关动态库拷贝至/usr/local/lib；
配置/usr/local/etc/odbcinst.ini（驱动定义）：ini [GaussDB]
Driver64=/usr/local/odbc/lib/psqlodbcw.so
setup=/usr/local/odbc/lib/psqlodbcw.so
配置/usr/local/etc/odbc.ini（数据源定义）：ini [gaussdb]
Driver=GaussMPP
Servername=10.145.130.26 # 数据库服务器IP
Database=postgres # 数据库名
Username=omm # 用户名
Password=xxx # 密码
Port=8000 # 监听端口
Sslmode=allow
3. 环境变量配置与验证
配置环境变量：bash 运行 export LD_LIBRARY_PATH=/usr/local/lib/:$LD_LIBRARY_PATH
export ODBCSYSINI=/usr/local/etc
export ODBCINI=/usr/local/etc/odbc.ini
验证配置：bash 运行 isql -v gaussdb
# 成功连接提示：Connected!
（三）ODBC 常用接口及操作
1. 核心 API 列表
|
API 名称 |
功能 |
|
|
|
SQLAllocHandle |
申请句柄资源（环境、连接、语句） |
|
|
|
SQLFreeHandle |
释放句柄资源 |
|
|
|
SQLBindCol |
绑定结果集列与数据缓冲区 |
|
|
|
SQLBindParameter |
绑定 SQL 语句参数与缓冲区 |
|
|
|
SQLConnect |
建立与数据源的连接 |
|
|
|
SQLDisconnect |
关闭数据库连接 |
|
|
|
SQLExecDirect |
直接执行 SQL 语句 |
|
|
|
SQLExecute |
执行预编译的 SQL 语句 |
|
|
|
SQLFetch |
从结果集获取下一行数据 |
|
|
|
SQLPrepare |
预编译 SQL 语句 |
|
|
|
SQLGetData |
获取结果集指定列数据 |
|
|
|
SQLGetDiagRec |
获取诊断记录信息 |
|
|
2. 关键接口使用
（1）句柄操作
申请句柄：c 运行 SQLRETURN SQL_API SQLAllocHandle(SQLSMALLINT HandleType, SQLHANDLE InputHandle, SQLHANDLE *OutputHandle)
// HandleType：SQL_HANDLE_ENV（环境）、SQL_HANDLE_DBC（连接）、SQL_HANDLE_STMT（语句）
释放句柄：c 运行 SQLRETURN SQL_API SQLFreeHandle(SQLSMALLINT HandleType, SQLHANDLE Handle)
（2）连接数据库
c
运行
SQLRETURN SQLConnect(SQLHDBC ConnectionHandle,
SQLCHAR *ServerName, SQLSMALLINT NameLength1,
SQLCHAR *UserName, SQLSMALLINT NameLength2,
SQLCHAR *Authentication, SQLSMALLINT NameLength3);
（3）参数绑定与 SQL 执行
c
运行
// 参数绑定
SQLRETURN SQLBindParameter(SQLHSTMT StatementHandle,
SQLUSMALLINT ParameterNumber, SQLSMALLINT InputOutputType,
SQLSMALLINT ValueType, SQLSMALLINT ParameterType,
SQLSMALLINT ColumnSize, SQLSMALLINT DecimalDigits,
SQLPOINTER ParameterValuePtr, SQLINTEGER BufferLength,
SQLINTEGER *StrLen_or_IndPtr);
// 执行预编译SQL
SQLRETURN SQLExecute(SQLHSTMT StatementHandle);
// 直接执行SQL
SQLRETURN SQLExecDirect(SQLHSTMT StatementHandle, SQLCHAR *StatementText, SQLINTEGER TextLength);
（4）结果集处理
c
运行
// 获取下一行数据
SQLRETURN SQLFetch(SQLHSTMT StatementHandle);
// 获取指定列数据
SQLRETURN SQLGetData(SQLHSTMT StatementHandle,
SQLUSMALLINT Col_or_Param_Num, SQLSMALLINT TargetType,
SQLPOINTER TargetValuePtr, SQLINTEGER BufferLength,
SQLINTEGER *StrLen_or_IndPtr);
3. 运行测试示例
（1）示例代码（test_odbc.c）
c
运行
#include <sql.h>
#include <sqlext.h>
#include <stdio.h>
#include <string.h>
int main() {
SQLHANDLE h_env, h_conn, h_stmt;
SQLCHAR *dsn = (SQLCHAR *)"gaussdb";
SQLCHAR *username = (SQLCHAR *)"omm";
SQLCHAR *password = (SQLCHAR *)"xxx";
SQLINTEGER ret;
SQLSMALLINT dsn_len = (SQLSMALLINT)strlen((const char *)dsn);
SQLSMALLINT username_len = (SQLSMALLINT)strlen((const char *)username);
SQLSMALLINT password_len = (SQLSMALLINT)strlen((const char *)password);
h_env = h_conn = h_stmt = NULL;
// 申请环境句柄
ret = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &h_env);
if ((ret != SQL_SUCCESS) && (ret != SQL_SUCCESS_WITH_INFO)) {
return SQL_ERROR;
}
// 设置环境属性（ODBC 3.0）
if (SQL_SUCCESS != SQLSetEnvAttr(h_env, SQL_ATTR_ODBC_VERSION, (void*)SQL_OV_ODBC3, 0)) {
SQLFreeHandle(SQL_HANDLE_ENV, h_env);
return SQL_ERROR;
}
// 申请连接句柄
if (SQL_SUCCESS != SQLAllocHandle(SQL_HANDLE_DBC, h_env, &h_conn)) {
SQLFreeHandle(SQL_HANDLE_ENV, h_env);
return SQL_ERROR;
}
// 设置自动提交
if (SQL_SUCCESS != SQLSetConnectAttr(h_conn, SQL_ATTR_AUTOCOMMIT, (void *)1, 0)) {
SQLFreeHandle(SQL_HANDLE_DBC, h_conn);
SQLFreeHandle(SQL_HANDLE_ENV, h_env);
return SQL_ERROR;
}
// 连接数据库
if (SQL_SUCCESS != SQLConnect(h_conn, dsn, dsn_len, username, username_len, password, password_len)) {
SQLFreeHandle(SQL_HANDLE_DBC, h_conn);
SQLFreeHandle(SQL_HANDLE_ENV, h_env);
return SQL_ERROR;
}
// 申请语句句柄
if (SQL_SUCCESS != SQLAllocHandle(SQL_HANDLE_STMT, h_conn, &h_stmt)) {
SQLFreeHandle(SQL_HANDLE_DBC, h_conn);
SQLFreeHandle(SQL_HANDLE_ENV, h_env);
return SQL_ERROR;
}
// 创建表并插入数据
SQLCHAR* create_sql = (SQLCHAR*)"create table test(col int)";
SQLExecDirect(h_stmt, create_sql, strlen((const char *)create_sql));
SQLCHAR* insert_sql = (SQLCHAR*)"insert into test (col) values(?)";
SQLPrepare(h_stmt, insert_sql, strlen((const char *)insert_sql));
int col_val = 1;
SQLBindParameter(h_stmt, 1, SQL_PARAM_INPUT, SQL_C_SSHORT, SQL_INTEGER, sizeof(int), 0, &col_val, 0, NULL);
SQLExecute(h_stmt);
printf("Connection succeed!\n");
// 释放资源
SQLDisconnect(h_conn);
SQLFreeHandle(SQL_HANDLE_STMT, h_stmt);
SQLFreeHandle(SQL_HANDLE_DBC, h_conn);
SQLFreeHandle(SQL_HANDLE_ENV, h_env);
return SQL_SUCCESS;
}
（2）编译运行
bash
运行
# 编译
gcc -lodbc -g test_odbc.c -o test
# 运行
./test
# 调试（可选）
gdb ./test
（四）开发问题总结
批量操作优化：关闭自动提交，事务结束后调用SQLEndTran提交，提升效率：c 运行 SQLSetConnectAttr(hdbc, SQL_ATTR_AUTOCOMMIT, (SQLPOINTER)SQL_AUTOCOMMIT_OFF, 0);
SQLExecute();
SQLEndTran(SQL_HANDLE_DBC, hdbc, SQL_COMMIT);
连续执行 SELECT 报错 “the cursor is open”：需执行SQLFetch或SQLCloseCursor重置游标；
绑定参数个数不匹配报错：检查 SQL 语句占位符（支持?或$1）与SQLBindParameter绑定参数个数是否一致；
“Function sequence error”：函数执行顺序错乱，按 “申请句柄→连接→执行 SQL→释放资源” 顺序调整。
1.4 Psycopg 接口介绍
（一）Psycopg 概述
定义：Psycopg 是 Python 语言的 SQL 执行 API，为 PostgreSQL、GaussDB 提供统一访问接口，Psycopg2 基于 C 语言封装（libpq），高效安全；
核心特性：支持客户端 / 服务器端游标、异步通信、通知、COPY TO/COPY FROM 批量操作，支持 SSL 连接；
支持平台：Kylin（x86_64 位、ARM64 位）。
（二）驱动配置
解压驱动包（GaussDB-Kernel-VxxxRxxxCxx - 操作系统版本号 - 64bit-Python.tar.gz）；
以 root 用户将 psycopg2 目录拷贝至 Python 安装目录的site-packages文件夹；
修改权限：chmod -R 755 psycopg2；
配置环境变量：bash 运行 export PYTHONPATH=$PYTHONPATH:/path/to/python/site-packages/psycopg2
# 非数据库用户需配置LD_LIBRARY_PATH
export LD_LIBRARY_PATH=/path/to/driver/lib:$LD_LIBRARY_PATH
（三）开发流程
加载驱动 → 连接数据库 → 执行 SQL 语句 → 处理结果集 → 关闭连接
（四）核心类与方法
1. Connection 类（数据库连接）
（1）连接方法：connect()
python
运行
conn = psycopg2.connect(
dbname="test", # 数据库名
user="postgres", # 用户名
password="secret", # 密码
host="127.0.0.1", # 服务器IP（默认UNIX socket）
port="8000" # 端口（默认8000）
)
SSL 连接示例：python 运行 conn = psycopg2.connect(
dbname="postgres",
user="user",
password="password",
host="localhost",
port=8000,
sslmode="verify-ca",
sslcert="client.crt",
sslkey="client.key",
sslrootcert="cacert.pem"
)
特性：线程安全，可作为上下文管理器（自动提交 / 回滚事务）。
2. Cursor 类（游标，执行 SQL）
（1）创建游标：conn.cursor()
python
运行
cur = conn.cursor(name=None, cursor_factory=None, scrollable=None, withhold=False)
（2）执行 SQL 方法
|
方法名 |
功能 |
示例 |
|
|
execute(query, vars_list) |
执行单条 SQL（支持参数绑定，占位符 % s） |
cur.execute("INSERT INTO student VALUES(%s,%s)", (1, 'test')) |
|
|
executemany(query, vars_list) |
执行多条 SQL（参数为序列列表） |
cur.executemany("INSERT INTO t VALUES(%s)", [(1,), (2,)]) |
|
|
fetchone() |
提取结果集下一行（返回元组，无数据返回 None） |
cur.fetchone() → (1, 'test') |
|
|
fetchall() |
提取所有剩余结果（返回元组列表） |
cur.fetchall() → [(1, 'test'), (2, 'demo')] |
|
|
copy_from(file, table, sep='\t', null='\N', columns=None) |
从文件导入数据到表 |
cur.copy_from(f, 'test', columns=('num', 'data')) |
|
|
copy_to(file, table, sep='\t', null='\N', columns=None) |
从表导出数据到文件 |
`cur.copy_to(sys.stdout, 'test', sep=" |
")` |
（五）常用操作示例
python
运行
import psycopg2
import sys
from io import StringIO
# 1. 建立连接
conn = psycopg2.connect(
database="postgres",
user="user",
password="password",
host="localhost",
port=8000
)
# 2. 创建游标
cur = conn.cursor()
# 3. 执行SQL（创建表）
cur.execute("CREATE TABLE student(id integer, name varchar, sex varchar)")
# 4. 插入数据（参数绑定）
cur.execute("INSERT INTO student(id,name,sex) VALUES(%s,%s,%s)", (1, 'Aspirin', 'M'))
cur.execute("INSERT INTO student(id,name,sex) VALUES(%s,%s,%s)", (2, 'Taxol', 'F'))
# 5. 批量插入（executemany）
data = [(3, 'Dixheral', 'M'), (4, 'Penicillin', 'F')]
cur.executemany("INSERT INTO student(id,name,sex) VALUES(%s,%s,%s)", data)
# 6. 批量导入（copy_from）
f = StringIO("5\tAmoxicillin\tM\n6\tCephalosporin\tF\n")
cur.copy_from(f, 'student', columns=('id', 'name', 'sex'), sep='\t')
# 7. 查询数据
cur.execute("SELECT * FROM student")
print("所有数据：", cur.fetchall()) # 提取所有结果
cur.execute("SELECT * FROM student WHERE id = %s", (3,))
print("单条数据：", cur.fetchone()) # 提取单条结果
# 8. 提交事务
conn.commit()
# 9. 关闭资源
cur.close()
conn.close()
1.5 缩略语说明
|
缩略语 |
英文全称 |
中文释义 |
|
|
API |
Application Programming Interface |
应用编程接口 |
|
|
JDBC |
Java Database Connectivity |
Java 数据库连接 |
|
|
ODBC |
Open Database Connectivity |
开放式数据库连接 |
|
|
SQL |
Structured Query Language |
结构化查询语言 |
|
- 点赞
- 收藏
- 关注作者
评论（0）