前言
- 最近被项目上的
华为高斯数据库Gauss适配快要搞疯了，版本分支太多，不同版本兼容的数据库协议还不一样，有postgres、mysql的，还有什么自定义协议、pgx的，头大的很；- 所以最终
整理了一份详细的Gauss数据库的版本划分+兼容协议的文档，从头开始整理梳理一遍，如果你项目中恰巧也用到了华为的高斯数据库Gauss，我相信这篇文档会为你带来一定的帮助，最起码能帮大家理清楚高斯数据库的版本划分（商用企业GaussDB 和 开源的openGauss），还有各自的兼容协议；- 如果你恰巧还是在
Golang的项目中使用Grom来操作华为高斯数据库的，那简单了，最下面的连接操作示例代码，可以直接使用。- 我个人认为这篇文章的输出内容质量还是不错的，前提是你能静下心来阅读哈！
吐槽一下
这篇文档为啥会出现呢？
1、网上相关的资源太少了，我找半天都找不到一个完整的，能为我理清思路的文档，只能去查官网自己弄；
2、Gauss数据库的适配之路让人疯狂...
- 我最早是使用 openGauss3.1.0版本的linux的x86 - docker镜像部署的(点击查看部署文档，之前我有写过)，适配没问题，但是最终客户的环境arm的，于是==》
- 我开始适配arm环境下的openGauss3.1.0的linux的arm - docker部署版本(点击查看部署文档，之前我有写过)，最终适配没问题，但是问题又来了， 运维装的是GaussDB的企业商用版本，于是 ==》
- 我开始适配GaussDB的企业商用版本的数据库，企业商用版本我还搞不到(
这个就没有部署文档了,只有项目合作才有资源)，只有最终对接官网后才能拿到，还好，最后也成功适配了。
1. 项目中实际连接的数据库分析
根据我的项目中的实际连接情况分析：
1.1 成功连接的 gaussArmCustomDB 配置
go
dsn1 := "host=192.168.0.1 port=8007 user=datas password='qien4UhkKD)edMnK33aq' dbname=LINKDOODTEST sslmode=disable TimeZone=Asia/Shanghai"
db, err := gorm.Open(gaussdb.Open(dsn1), &gorm.Config{})关键信息：
- 端口：8007（非标准的5432端口）
- 用户：datas（非默认的gaussdb用户）
- 数据库：LINKDOODTEST
- 支持SSL连接
- 兼容PostgreSQL协议
1.2 数据库版本识别
通过远程连接查看到的版本信息：
GaussDB Kernel 505.2.1 build 159cea95
compiled at 2024-12-27 09:22:44版本分析：
- 内核版本：505.2.1
- 构建版本：159cea95
- 编译时间：2024-12-27
- 版本系列：属于GaussDB 5.x系列，是企业级分布式数据库
2. 华为高斯数据库版本体系
2.1 产品系列划分
华为高斯数据库分为两大产品线：
🔹 openGauss（开源版本）
- 定位：开源社区版本
- 维护方：openGauss社区
- 协议兼容性：主要兼容PostgreSQL
- 部署方式：单机、主备、分布式
- 镜像维护地址 ：主要是这里在维护，点击查看即可
🔹 GaussDB（商业版本）
- 定位：华为云商业数据库服务
- 维护方：华为公司
- 协议兼容性：PostgreSQL、MySQL（部分产品）
- 部署方式：云原生分布式架构
- 镜像维护地址：我也没有，只能项目合作联系官方人员
2.2 版本编号规则
openGauss版本规则
格式：x.y.z
- x：主版本号（重大架构变更）
- y：次版本号（功能增强）
- z：修订版本号（Bug修复）GaussDB版本规则
格式：xyz.a.b
- xyz：内核版本号（如505）
- a：主要版本号
- b：次要版本号3. openGauss版本详细信息
基于 EnmoTech Docker镜像 的版本分析：
| 版本 | 发布时间 | 主要特性 | 协议兼容性 | 推荐用途 |
|---|---|---|---|---|
| 1.0.0 | 2020年6月 | 首个正式版本 | PostgreSQL 9.2+ | 基础功能验证 |
| 1.0.1 | 2020年9月 | 稳定性提升 | PostgreSQL 9.2+ | 生产环境试用 |
| 1.1.0 | 2021年3月 | 性能优化 | PostgreSQL 10+ | 中小型应用 |
| 2.0.0 | 2021年9月 | 架构重构 | PostgreSQL 11+ | 大型应用 |
| 2.0.1 | 2021年12月 | Bug修复 | PostgreSQL 11+ | 稳定生产环境 |
| 2.1.0 | 2022年3月 | 功能增强 | PostgreSQL 12+ | 企业级应用 |
| 3.0.0 | 2022年6月 | 分布式支持 | PostgreSQL 13+ | 分布式场景 |
| 3.0.3 | 2022年9月 | 稳定性修复 | PostgreSQL 13+ | 推荐生产版本 |
| 3.1.0 | 2023年3月 | AI增强 | PostgreSQL 14+ | AI/ML场景 |
| 3.1.1 | 2023年6月 | 安全增强 | PostgreSQL 14+ | 高安全场景 |
| 5.0.0 | 2023年12月 | 云原生架构 | PostgreSQL 15+ | 云原生应用 |
| 5.0.1 | 2024年3月 | 性能优化 | PostgreSQL 15+ | 高性能场景 |
3.1 版本跨越说明
注意：从3.1.1直接跳跃到5.0.0，中间跳过了4.x版本，这是华为为了与GaussDB商业版本号保持一致而做的调整。
4. 协议兼容性详解
4.1 PostgreSQL协议兼容性
🟢 完全兼容的功能
- SQL语法：支持标准SQL和大部分PostgreSQL扩展语法
- 数据类型：支持PostgreSQL所有基础数据类型
- 连接协议：完全兼容PostgreSQL wire protocol
- 认证方式：支持md5、scram-sha-256、trust等
- 客户端工具：可使用psql、pgAdmin等PostgreSQL工具
🟡 部分兼容的功能
- 扩展插件：不是所有PostgreSQL插件都支持
- 复制协议：支持流复制，但实现细节有差异
- PL/pgSQL：基本兼容，但某些高级特性可能不支持
🔴 不兼容的功能
- 某些系统表：内部系统表结构有差异
- 特定函数：某些PostgreSQL特有函数不支持
- 版本特性：不同版本对PostgreSQL特性支持程度不同
4.2 MySQL协议兼容性
GaussDB某些版本支持MySQL协议
- GaussDB(for MySQL)：完全兼容MySQL 5.7/8.0
- 连接方式：支持MySQL客户端直接连接
- 语法兼容：支持MySQL SQL语法
openGauss与MySQL兼容性
- 默认不支持：openGauss主要针对PostgreSQL协议
- 可通过插件：某些版本可通过第三方插件支持MySQL协议
5. 项目中的数据库版本分析
5.1 GaussDB 505.2.1 版本特点
根据连接的 GaussDB Kernel 505.2.1 版本分析：
版本归属
- 产品线：GaussDB企业版
- 系列：5.x系列
- 构建日期：2024-12-27（最新构建）
- 架构：分布式主备架构
协议支持
yaml
主要协议: PostgreSQL 14+
认证方式: SCRAM-SHA-256, MD5
连接加密: SSL/TLS
端口配置: 自定义端口8007
用户管理: 企业级用户权限体系高级特性
- ✅ 主备复制：支持同步/异步复制
- ✅ 分布式事务：支持ACID事务
- ✅ 负载均衡：支持读写分离
- ✅ 高可用：自动故障切换
- ✅ 数据加密：支持透明数据加密
5.2 为什么使用PostgreSQL驱动成功
项目使用以下驱动组合成功连接：
go
import (
"gorm.io/driver/gaussdb" // GaussDB专用GORM驱动
_ "gitee.com/opengauss/openGauss-connector-go-pq" // openGauss连接器
)成功原因：
- 协议兼容：GaussDB 505.2.1 完全兼容PostgreSQL wire protocol
- 专用驱动：使用了专门的GaussDB GORM驱动
- 连接器支持：openGauss连接器处理了认证和协议细节
- 密码处理：引号包围解决了特殊字符问题
6. 部署架构对比
6.1 Docker镜像部署（EnmoTech）
yaml
架构类型: 单机/容器化部署
适用场景: 开发测试环境
版本选择: openGauss 1.0.0-5.0.1
协议支持: PostgreSQL
端口: 5432（默认）
用户: gaussdb（默认）6.2 企业级主备部署（我的环境）
yaml
架构类型: 分布式主备架构
适用场景: 生产环境
版本: GaussDB 505.2.1
协议支持: PostgreSQL + 企业扩展
端口: 8007（自定义）
用户: datas（自定义）
特性: 高可用、负载均衡、数据加密7. 驱动选择指南
7.1 推荐驱动组合
对于openGauss（开源版）
go
// 方案1：使用openGauss专用驱动
import _ "gitee.com/opengauss/openGauss-connector-go-pq"
// DSN: postgresql://user:pass@host:port/db
// 方案2：使用PostgreSQL驱动
import _ "github.com/lib/pq"
// DSN: postgres://user:pass@host:port/db对于GaussDB（企业版）
go
// 推荐方案：GORM + GaussDB驱动
import "gorm.io/driver/gaussdb"
import _ "gitee.com/opengauss/openGauss-connector-go-pq"
// DSN: host=x port=x user=x password=x dbname=x7.2 连接字符串注意事项
密码特殊字符处理
go
// ❌ 错误方式
password=qien4UhkKD)edMnK33aq
// ✅ 正确方式
password='qien4UhkKD)edMnK33aq' // 单引号包围
password=qien4UhkKD%29edMnK33aq // URL编码端口配置
yaml
openGauss默认端口: 5432
GaussDB企业版: 通常自定义端口（如8007、54321等）8. 版本选择建议
8.1 场景化推荐
| 使用场景 | 推荐版本 | 原因 |
|---|---|---|
| 学习测试 | openGauss 3.1.1 | 功能完整、文档丰富 |
| 开发环境 | openGauss 5.0.1 | 最新特性、性能优化 |
| 生产环境 | GaussDB 505.x | 企业级支持、高可用 |
| 云原生 | GaussDB 云服务 | 托管服务、弹性扩缩 |
8.2 升级路径
openGauss 1.x openGauss 2.x openGauss 3.x openGauss 5.x GaussDB 企业版 测试环境 开发环境 预生产环境 生产环境
9. 版本与协议支持流程图
华为高斯数据库 openGauss开源版 GaussDB企业版 单机部署 主备部署 分布式部署 GaussDB for MySQL GaussDB for PostgreSQL GaussDB 分布式版 PostgreSQL协议 MySQL协议 PostgreSQL + 分布式扩展 端口5432
用户gaussdb 端口3306
用户root 自定义端口
企业用户体系
华为高斯数据库产品线 openGauss 开源版 GaussDB 企业版 openGauss 1.x系列
2020年6月-2020年12月 openGauss 2.x系列
2021年3月-2021年12月 openGauss 3.x系列
2022年3月-2023年6月 openGauss 5.x系列
2023年12月-至今 GaussDB for MySQL
兼容MySQL 5.7/8.0 GaussDB for PostgreSQL
兼容PostgreSQL 11+ GaussDB 505.x系列
企业分布式版本 PostgreSQL 9.2+协议 PostgreSQL 11+协议 PostgreSQL 13+协议 PostgreSQL 15+协议 MySQL 协议
端口3306 PostgreSQL 协议
端口5432 PostgreSQL + 企业扩展
自定义端口 我的环境
GaussDB 505.2.1 特征:
• 端口8007
• 用户datas
• 主备架构
• SSL支持 Go驱动选择 lib/pq
标准PostgreSQL驱动 openGauss-connector-go-pq
openGauss专用驱动 gorm.io/driver/gaussdb
GaussDB GORM驱动
驱动适配层 协议支持层次 华为高斯数据库版本演进 成功连接
dsn1方案 github.com/lib/pq
标准PostgreSQL驱动 gitee.com/opengauss/
openGauss-connector-go-pq
openGauss专用驱动 gorm.io/driver/gaussdb
GaussDB GORM驱动 github.com/go-sql-driver/mysql
MySQL驱动 基础PostgreSQL协议
• 连接认证
• SQL执行
• 事务管理 扩展PostgreSQL协议
• 流复制
• 发布订阅
• 扩展函数 企业级协议扩展
• 分布式事务
• 主备切换
• 负载均衡 MySQL协议兼容
• MySQL语法
• MySQL客户端
• MySQL工具 openGauss 1.0.0
2020年6月
PostgreSQL 9.2+ openGauss 1.0.1
2020年9月
稳定性提升 openGauss 1.1.0
2021年3月
PostgreSQL 10+ openGauss 2.0.0
2021年9月
PostgreSQL 11+ openGauss 2.0.1
2021年12月
生产稳定版 openGauss 2.1.0
2022年3月
PostgreSQL 12+ openGauss 3.0.0
2022年6月
PostgreSQL 13+ openGauss 3.0.3
2022年9月
推荐生产版 openGauss 3.1.0
2023年3月
PostgreSQL 14+ openGauss 3.1.1
2023年6月
安全增强 openGauss 5.0.0
2023年12月
PostgreSQL 15+ openGauss 5.0.1
2024年3月
性能优化 GaussDB 505.2.1
我的环境
2024年12月构建
10. 连接配置最佳实践
10.1 生产环境配置
go
// 推荐的生产环境配置
type GaussDBConfig struct {
Host string `yaml:"host"`
Port int `yaml:"port"`
User string `yaml:"user"`
Password string `yaml:"password"`
Database string `yaml:"database"`
SSLMode string `yaml:"sslmode"` // require/verify-full
TimeZone string `yaml:"timezone"`
// 连接池配置
MaxOpenConns int `yaml:"max_open_conns"`
MaxIdleConns int `yaml:"max_idle_conns"`
ConnMaxLifetime time.Duration `yaml:"conn_max_lifetime"`
}
func NewGaussDB(config *GaussDBConfig) (*gorm.DB, error) {
dsn := fmt.Sprintf(
"host=%s port=%d user=%s password='%s' dbname=%s sslmode=%s TimeZone=%s",
config.Host, config.Port, config.User,
config.Password, config.Database,
config.SSLMode, config.TimeZone,
)
db, err := gorm.Open(gaussdb.Open(dsn), &gorm.Config{
Logger: logger.Default.LogMode(logger.Info),
})
if err != nil {
return nil, err
}
sqlDB, err := db.DB()
if err != nil {
return nil, err
}
sqlDB.SetMaxOpenConns(config.MaxOpenConns)
sqlDB.SetMaxIdleConns(config.MaxIdleConns)
sqlDB.SetConnMaxLifetime(config.ConnMaxLifetime)
return db, nil
}10.2 错误处理和重试机制
go
func ConnectWithRetry(config *GaussDBConfig, maxRetries int) (*gorm.DB, error) {
for i := 0; i < maxRetries; i++ {
db, err := NewGaussDB(config)
if err == nil {
return db, nil
}
log.Printf("连接失败，第%d次重试，错误: %v", i+1, err)
time.Sleep(time.Second * time.Duration(i+1))
}
return nil, fmt.Errorf("连接失败，已重试%d次", maxRetries)
}11. 总结
11.1 我的环境特点
- 数据库版本：GaussDB 505.2.1（企业版最新构建）
- 架构模式：分布式主备架构
- 协议支持：PostgreSQL 14+ 兼容
- 连接特点：自定义端口、企业用户体系、SSL加密
11.2 关键技术要点
- 驱动选择：使用GaussDB专用GORM驱动
- 密码处理：特殊字符需要引号包围
- 协议兼容：完全兼容PostgreSQL wire protocol
- 企业特性：支持高可用、负载均衡、数据加密
11.3 后续建议
- 监控配置：建议添加数据库连接监控
- 性能优化：根据业务需求调整连接池参数
- 安全加固：启用SSL/TLS加密连接
- 备份策略：制定完整的数据备份和恢复方案
12. 最终在Golang项目中使用Gorm适配Gauss数据库的代码示例（openGauss和企业商用的Gauss）都有，demo为了省事，我就写一个文件了哈
go
package main
import (
"fmt"
"time"
"gorm.io/driver/mysql"
"gorm.io/driver/postgres"
"gorm.io/gorm"
// 添加GaussDB专用驱动
"gorm.io/driver/gaussdb"
// 添加OpenGauss连接器
_ "gitee.com/opengauss/openGauss-connector-go-pq"
)
type Test struct {
ID int
Name string
}
type DsConferConferinfo struct {
Id int64 `gorm:"column:ID;primaryKey" json:"id"` //主键
ConferId string `gorm:"column:CONFER_ID;size:255" json:"confer_id"` //会议ID
Elogo string `gorm:"column:ELOGO;size:255" json:"elogo"` //服务器logo
RoomId string `gorm:"column:ROOM_ID;size:255" json:"room_id"` //房间ID
Url string `gorm:"column:URL;size:255" json:"url"` //会议链接
Type string `gorm:"column:TYPE;size:255" json:"type"` //会议类型 即时会议、预约会议、直播会议
Status string `gorm:"column:STATUS;size:255" json:"status"` //会议状态 over、doing
Theme string `gorm:"column:THEME;size:255" json:"theme"` //主题 名称
FireDate int64 `gorm:"column:FIRE_DATE" json:"fire_date"` //会议开始时间
IsPublic int `gorm:"column:IS_PUBLIC" json:"is_public"` //是否公开
PopUiSwitch string `gorm:"column:POP_UI_SWITCH;size:255" json:"pop_ui_switch"` //弹窗开关
Model string `gorm:"column:MODEL;size:255" json:"model"` //会议模板 chat聊天、micro视频会议、语音会议
FirePerson string `gorm:"column:FIRE_PERSON;size:255" json:"fire_person"` //发起人ID
FirePersonName string `gorm:"column:FIRE_PERSON_NAME;size:255" json:"fire_person_name"` //发起人名称
PassWord string `gorm:"column:PASS_WORD;size:255" json:"pass_word"` //密码
RoomType string `gorm:"column:ROOM_TYPE;size:255" json:"room_type"` //房间类型 confer
Version string `gorm:"column:VERSION;size:255" json:"version"` //版本号
Platform string `gorm:"column:PLATFORM;size:255" json:"platform"` //平台
Provider string `gorm:"column:PROVIDER;size:255" json:"provider"` //服务商
Voucher string `gorm:"column:VOUCHER;size:255" json:"voucher"` //会议凭证
EndDate int64 `gorm:"column:END_DATE" json:"end_date"` //会议结束时间
GroupId string `gorm:"column:GROUP_ID;size:255" json:"group_id"` //群ID
IsPushTempMsg string `gorm:"column:ISPUSH_TEMPMSG;size:255" json:"ispush_tempmsg"` //是否推送临时消息
Degreeofsecrets string `gorm:"column:DEGREEOFSECRETS;size:255" json:"degreeofsecrets"` //保密等级
ConferTemplateStatus string `gorm:"column:CONFER_TEMPLATE_STATUS;size:255" json:"confer_template_status"` //会议模板状态
Mrid string `gorm:"column:MRID;size:255" json:"mrid"` //会议ID s
ExpectEndDate int `gorm:"column:EXPECT_END_DATE" json:"expect_end_date"` //预计结束时间 s
IpPort string `gorm:"column:IP_PORT;size:255" json:"ip_port"` //ip端口
Resolution string `gorm:"column:RESOLUTION;size:255" json:"resolution"` //分辨率
}
// TableName 指定表名
func (DsConferConferinfo) TableName() string {
return "ds_confer_conferinfo"
}
func main() {
fmt.Println("Hello, World!")
// mysql数据库连接测试
mysqldb, err := mysqlDB()
if err != nil {
fmt.Println("Error connecting to MySQL:", err)
return
}
mysqldb.AutoMigrate(&Test{})
mysqldb.Create(&Test{Name: "test"})
fmt.Println("Connected to MySQL successfully!")
fmt.Println("Created test record in MySQL")
fmt.Println("--------------------------------")
// postgres数据库连接测试
postgresdb, err := postgresDB()
if err != nil {
fmt.Println("Error connecting to Postgres:", err)
return
}
fmt.Println("Connected to Postgres successfully!")
postgresdb.AutoMigrate(&Test{})
postgresdb.Create(&Test{Name: "test"})
fmt.Println("Created test record in Postgres")
fmt.Println("--------------------------------")
// 高斯数据库-linux-x86-3.1.0连接测试
gaussLinuxdb, err := gaussLinuxDB()
if err != nil {
fmt.Println("Error connecting to GaussLinux:", err)
return
}
fmt.Println("Connected to GaussLinux successfully!")
gaussLinuxdb.AutoMigrate(&Test{})
gaussLinuxdb.Create(&Test{Name: "test"})
fmt.Println("Created test record in GaussLinux")
fmt.Println("--------------------------------")
// 高斯数据库-linux-arm-3.1.0连接测试
gaussArmdb, err := gaussArmDB()
if err != nil {
fmt.Println("Error connecting to GaussArm:", err)
return
}
fmt.Println("Connected to GaussArm successfully!")
gaussArmdb.AutoMigrate(&Test{})
gaussArmdb.Create(&Test{Name: "test"})
fmt.Println("Created test record in GaussArm")
fmt.Println("--------------------------------")
// 高斯数据库-企业商用-定制连接测试
gaussArmCustomdb, err := gaussArmCustomDB()
if err != nil {
fmt.Println("Error connecting to GaussArmCustom:", err)
return
}
fmt.Println("Connected to GaussArmCustom successfully!")
gaussArmCustomdb.AutoMigrate(&Test{})
gaussArmCustomdb.Create(&Test{Name: "test"})
fmt.Println("Created test record in GaussArmCustom")
fmt.Println("--------------------------------")
// 测试ds_confer_conferinfo表的增删改查
testConferInfo(gaussArmCustomdb)
}
// mysql数据库连接测试
func mysqlDB() (*gorm.DB, error) {
fmt.Println("Hello, mysql!")
dsn := "root:admin123456789@tcp(127.0.0.1:3306)/ceshi?charset=utf8mb4&parseTime=True&loc=Local"
db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
if err != nil {
fmt.Println("Error connecting to MySQL:", err)
return nil, err
}
fmt.Println("Connected to MySQL successfully!")
return db, err
}
// postgres数据库连接测试
func postgresDB() (*gorm.DB, error) {
fmt.Println("Hello, postgres!")
dsn := "host=192.168.0.1 user=vrvmees password=admin123456789 dbname=datas port=5432 sslmode=disable TimeZone=Asia/Shanghai"
db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{})
if err != nil {
fmt.Println("Error connecting to Postgres:", err)
return nil, err
}
fmt.Println("Connected to Postgres successfully!")
return db, err
}
// 高斯数据库-linux-x86-3.1.0
func gaussLinuxDB() (*gorm.DB, error) {
fmt.Println("Hello, gaussLinux!")
dsn := "host=192.168.0.1 port=54323 user=root password=Admin@123456789 dbname=datas sslmode=disable TimeZone=Asia/Shanghai"
db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{})
if err != nil {
fmt.Println("Error connecting to GaussLinux:", err)
return nil, err
}
fmt.Println("Connected to GaussLinux successfully!")
return db, err
}
// 高斯数据库-linux-arm-3.1.0
func gaussArmDB() (*gorm.DB, error) {
fmt.Println("Hello, gaussArm!")
dsn := "host=192.168.0.1 port=54321 user=gaussdb password=Gauss@123456789 dbname=datas sslmode=disable TimeZone=Asia/Shanghai"
db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{})
if err != nil {
fmt.Println("Error connecting to GaussArm:", err)
return nil, err
}
fmt.Println("Connected to GaussArm successfully!")
return db, err
}
// 高斯数据库-企业商用-定制
func gaussArmCustomDB() (*gorm.DB, error) {
fmt.Println("Hello, gaussArmCustom!")
// 方法1: 使用URL编码处理特殊字符
dsn1 := "host=192.168.0.1 port=8007 user=datas password='admin@1234556772' dbname=test sslmode=disable TimeZone=Asia/Shanghai"
fmt.Println("尝试方法1: 密码加引号")
db, err := gorm.Open(gaussdb.Open(dsn1), &gorm.Config{})
if err != nil {
fmt.Printf("方法1失败: %v\n", err)
// 方法2: URL编码密码
dsn2 := "host=192.168.0.1 port=8007 user=datas password=qien4UhkKD%29edMnK12asq dbname=LINKDOODTEST sslmode=disable TimeZone=Asia/Shanghai"
fmt.Println("尝试方法2: URL编码密码")
db, err = gorm.Open(gaussdb.Open(dsn2), &gorm.Config{})
if err != nil {
fmt.Printf("方法2失败: %v\n", err)
// 方法3: 移除options参数
dsn3 := "host=192.168.0.1 port=8007 user=datas password=qien4UhkKD)edMnK12asq dbname=LINKDOODTEST sslmode=disable"
fmt.Println("尝试方法3: 移除时区设置")
db, err = gorm.Open(gaussdb.Open(dsn3), &gorm.Config{})
if err != nil {
fmt.Printf("方法3失败: %v\n", err)
// 方法4: 使用postgresql://格式
dsn4 := "postgresql://datas:qien4UhkKD%29edMnK12asq@192.168.0.1:8007/LINKDOODTEST?sslmode=disable"
fmt.Println("尝试方法4: postgresql:// URL格式")
db, err = gorm.Open(gaussdb.Open(dsn4), &gorm.Config{})
if err != nil {
fmt.Printf("方法4失败: %v\n", err)
// 方法5: 尝试MySQL驱动 (GaussDB可能兼容MySQL协议)
fmt.Println("尝试方法5: MySQL驱动")
mysqlDSN := "datas:qien4UhkKD)edMnK12asq@tcp(192.168.0.1:8007)/LINKDOODTEST?charset=utf8mb4&parseTime=True&loc=Local"
db, err = gorm.Open(mysql.Open(mysqlDSN), &gorm.Config{})
if err != nil {
fmt.Printf("方法5失败: %v\n", err)
// 方法6: MySQL驱动，密码URL编码
fmt.Println("尝试方法6: MySQL驱动+URL编码")
mysqlDSN2 := "datas:qien4UhkKD%29edMnK12asq@tcp(192.168.0.1:8007)/LINKDOODTEST?charset=utf8mb4&parseTime=True&loc=Local"
db, err = gorm.Open(mysql.Open(mysqlDSN2), &gorm.Config{})
if err != nil {
fmt.Printf("方法6失败: %v\n", err)
return nil, err
}
}
}
}
}
}
fmt.Println("Connected to GaussArmCustom successfully!")
return db, nil
}
// 测试ds_confer_conferinfo表的增删改查功能--高斯数据库-企业商用-定制
func testConferInfo(db *gorm.DB) {
fmt.Println("=== 开始测试 ds_confer_conferinfo 表 ===")
// 1. 查看表结构 - 通过查询表是否存在
if !db.Migrator().HasTable(&DsConferConferinfo{}) {
fmt.Println("表 ds_confer_conferinfo 不存在，尝试创建...")
if err := db.AutoMigrate(&DsConferConferinfo{}); err != nil {
fmt.Printf("创建表失败: %v\n", err)
return
}
fmt.Println("表创建成功!")
} else {
fmt.Println("表 ds_confer_conferinfo 已存在")
}
// 2. 新增测试数据
fmt.Println("\n--- 测试新增 ---")
// 使用时间戳确保CONFER_ID唯一
timestamp := time.Now().Unix()
uniqueId := fmt.Sprintf("CONF_TEST_%d", timestamp)
conferInfo := DsConferConferinfo{
ConferId: uniqueId,
Elogo: "test_logo.png",
RoomId: fmt.Sprintf("ROOM_%d", timestamp),
Url: fmt.Sprintf("https://test.meeting.com/room/%d", timestamp),
Type: "即时会议",
Status: "doing",
Theme: "测试会议主题",
FireDate: 1737458400, // 2025-01-21 的时间戳
IsPublic: 1,
PopUiSwitch: "on",
Model: "micro",
FirePerson: fmt.Sprintf("USER_%d", timestamp),
FirePersonName: "测试用户",
PassWord: "123456",
RoomType: "confer",
Version: "v1.0.0",
Platform: "web",
Provider: "vrv",
Voucher: fmt.Sprintf("TEST_VOUCHER_%d", timestamp),
EndDate: 1737465600, // 结束时间
GroupId: fmt.Sprintf("GROUP_%d", timestamp),
IsPushTempMsg: "yes",
Degreeofsecrets: "internal",
ConferTemplateStatus: "active",
Mrid: fmt.Sprintf("MRID_%d", timestamp),
ExpectEndDate: 1737465600,
IpPort: "192.168.0.1:8080",
Resolution: "1920x1080",
}
result := db.Create(&conferInfo)
if result.Error != nil {
fmt.Printf("新增失败: %v\n", result.Error)
} else {
fmt.Printf("新增成功! ID: %d, 影响行数: %d\n", conferInfo.Id, result.RowsAffected)
}
// 3. 查询测试
fmt.Println("\n--- 测试查询 ---")
var queryConfer DsConferConferinfo
// 先通过ID查询刚插入的记录
if err := db.Where(`"ID" = ?`, conferInfo.Id).First(&queryConfer).Error; err != nil {
fmt.Printf("通过ID查询失败: %v\n", err)
} else {
fmt.Printf("通过ID查询成功: ID=%d, 会议主题=%s, 状态=%s\n", queryConfer.Id, queryConfer.Theme, queryConfer.Status)
}
// 再通过CONFER_ID查询
var queryConfer2 DsConferConferinfo
if err := db.Where(`"CONFER_ID" = ?`, uniqueId).First(&queryConfer2).Error; err != nil {
fmt.Printf("通过CONFER_ID查询失败: %v\n", err)
} else {
fmt.Printf("通过CONFER_ID查询成功: ID=%d, 会议主题=%s, 状态=%s\n", queryConfer2.Id, queryConfer2.Theme, queryConfer2.Status)
}
// 4. 更新测试 - 使用ID进行更新
fmt.Println("\n--- 测试更新 ---")
updateResult := db.Model(&queryConfer).Where(`"ID" = ?`, conferInfo.Id).Updates(DsConferConferinfo{
Theme: "更新后的会议主题",
Status: "over",
})
if updateResult.Error != nil {
fmt.Printf("更新失败: %v\n", updateResult.Error)
} else {
fmt.Printf("更新成功! 影响行数: %d\n", updateResult.RowsAffected)
}
// 5. 验证更新
fmt.Println("\n--- 验证更新结果 ---")
var updatedConfer DsConferConferinfo
if err := db.Where(`"ID" = ?`, conferInfo.Id).First(&updatedConfer).Error; err != nil {
fmt.Printf("验证查询失败: %v\n", err)
} else {
fmt.Printf("验证成功: 会议主题=%s, 状态=%s\n", updatedConfer.Theme, updatedConfer.Status)
}
// 6. 查询所有记录数量
fmt.Println("\n--- 查询表中总记录数 ---")
var count int64
if err := db.Model(&DsConferConferinfo{}).Count(&count).Error; err != nil {
fmt.Printf("统计失败: %v\n", err)
} else {
fmt.Printf("表中总记录数: %d\n", count)
}
// 7. 删除测试数据 - 使用ID进行删除
fmt.Println("\n--- 测试删除 ---")
deleteResult := db.Where(`"ID" = ?`, conferInfo.Id).Delete(&DsConferConferinfo{})
if deleteResult.Error != nil {
fmt.Printf("删除失败: %v\n", deleteResult.Error)
} else {
fmt.Printf("删除成功! 影响行数: %d\n", deleteResult.RowsAffected)
}
fmt.Println("\n=== ds_confer_conferinfo 表测试完成 ===")
}社区开源版本-arm环境openGauss3.1.0（docker）部署指南，点击这里去查看
社区开源版本-x86环境openGauss3.1.0（docker）部署指南，点击这里去查看
企业商用的，要自己找哦