Go 操作 Oracle

创建并授权用户 user5

  1. # system 用户连接 Oracle 数据库
  2. su - oracle
  3. sqlplus system/root
  5. # 创建一个用户 user5
  6. grant connect, resource, unlimited tablespace to user5 identified by oracle;
  8. # 授予 user5 创建目录的权限
  9. grant create any directory to user5;

在 user5 上创建 emp 表并导入数据

  • 切换到 user5

    1. conn user5/oracle

  • 查看 user5 的表

    1. select table_name from user_tables;

    Go 语言操作数据库 - 图1

  • 创建并查看 emp 表

Go 语言操作数据库 - 图2

  • 导入数据到 emp 表中

    • 修改 info.ctl 文件

      1. su - oraclevim /home/oracle/data/info.ctl
      2. LOAD DATA
      3. infile '/home/oracle/data/info.csv'
      4. replace into table emp
      5. fields terminated by ','
      6. optionally enclosed by '"'
      7. (empno,ename)

    • 导入数据

      1. host sqlldr userid=user5/oracle control=/home/oracle/data/info.ctl log=/home/oracle/data/emp.log

      Go 语言操作数据库 - 图3

使用 Go 访问 Oracle 并配置环境

  • 创建项目目录

    1. mkdir -p ~/go_code/go_oracle
    2. mkdir -p ~/go_code/go_mysql

  • 生成 go.mod 文件

    1. cd ~/go_code/go_oracle/
    2. go mod init go_oraclels

    Go 语言操作数据库 - 图4

  • 编写访问数据库的文件

    1. vim dbquery.go
    2. package main
    3. import (
    4.   "database/sql"
    5.   "fmt"
    6.   "log"
    7.   _ "github.com/mattn/go-oci8"
    8. )
    9. func main() {
    10.   // 设置连接数据库的参数
    11.   db, _ := sql.Open("oci8", "user5:oracle@dbserver/it.test.com")
    12.   //获取所有数据
    13.   rows, _ := db.Query("select empno, ename from emp")
    14.   var empno, ename string
    15.   //循环显示所有的数据
    16.   for rows.Next() {
    17.       rows.Scan(&empno, &ename)
    18.       fmt.Printf("empno: %s\tename: %s\n", empno, ename)
    19.   }
    20.   //关闭数据库
    21.   defer db.Close()
    22.   //连接数据库
    23.   err := db.Ping()
    24.   if err != nil {
    25.       fmt.Println("数据库连接失败")
    26.       return
    27.   }
    28.   fmt.Println("hello")
    29. }

  • 设置代理

    1. go env -w GO111MODULE=on
    2. go env -w GOPROXY=https://goproxy.io,direct

  • 配置 oci8

    • 创建 pkg-config 目录

      1. mkdir -p /u01/app/oracle/product/oracle12c201/lib/pkg-config/

    • 创建 oci8.pc 文件
      ```bash cd /u01/app/oracle/product/oracle12c201/lib/pkg-config/

vim oci8.pc prefix=/oracle libdir=/u01/app/oracle/product/oracle12c201/lib includedir=/u01/app/oracle/product/oracle12c201/rdbms/public glib_genmarshal=glib-genmarshal gobject_query=gobject-query glib_mkenums=glib-mkenums Name: oci8 Description: oci8 library Libs: -L${libdir} -lclntsh Cflags: -I${includedir} Version: 12.2

  2.    - 配置环境变量
  3. ```bash
  4. vim ~/.bash_profile
  5. export PKG_CONFIG_PATH=/u01/app/oracle/product/oracle12c201/lib/pkg-config/

  • 切换到 root ，再切回 oracle 执行程序

    1. su -
    2. su - oraclecd ~/go_code/go_oracle/
    3. go run dbquery.go

    Go 语言操作数据库 - 图5

  • 查看 oci8 是否加载

    1. cat go.mod

    Go 语言操作数据库 - 图6

  • 注释 log

Go 语言操作数据库 - 图7

  • 执行程序，查看文件

Go 语言操作数据库 - 图8

  • 添加环境变量

    1. vim ~/.bash_profile
    2. export LD_LIBRARY_PATH=/u01/app/oracle/product/oracle12c201/lib

  • 切换到 root ，再切回 oracle 执行程序

    1. su -
    2. su - oraclecd ~/go_code/go_oracle/
    3. go run dbquery.go

    Go 语言操作数据库 - 图9

  • 新建项目测试环境

    1. mkdir -p ~/go_code/go_oracle_1
    2. cd ~/go_code/go_oracle_1/
    3. go mod init go_oracle_1
    4. cp ~/go_code/go_oracle/dbquery.go .
    5. go  run dbquery.go

    Go 语言操作数据库 - 图10

Go 代码实现增删改查

  • 添加表和数据

    • 编写 Go 代码

      1. cd ~/go_code/go_oraclecp dbquery.go dbtest.go
      2. vim dbtest.go
      3. package main
      4. import (
      5. "database/sql"
      6. "fmt"
      7. //    "log"
      8. _ "github.com/mattn/go-oci8"
      9. )
      10. func main() {
      11. // 设置连接数据库的参数
      12. db, _ := sql.Open("oci8", "user5:oracle@dbserver/it.test.com")
      13. err := db.Ping()
      14. if err != nil {
      15.    fmt.Println("数据库连接失败")
      16.    return
      17. } else {
      18. fmt.Println("成功连接到数据库")
      19. }
      20. db.Exec("create table book (bookid number(5), bookname varchar2(100) not null)")
      21. var insert_sql = fmt.Sprintf("insert into book (bookid, bookname) values (%d, '%s')" ,  1, "thinking in java")
      22. fmt.Println(insert_sql)
      23. db.Exec(insert_sql)
      24. //关闭数据库
      25. defer db.Close()
      26. }

    • 查看数据

Go 语言操作数据库 - 图11

  • 修改数据

    • Go 代码

      1. vim dbtest.go
      2. package main
      3. import (
      4. "database/sql"
      5. "fmt"
      6. //    "log"
      7. _ "github.com/mattn/go-oci8"
      8. )
      9. func main() {
      10. // 设置连接数据库的参数
      11. db, _ := sql.Open("oci8", "user5:oracle@dbserver/it.test.com")
      12. err := db.Ping()
      13. if err != nil {
      14.    fmt.Println("数据库连接失败")
      15.    return
      16. } else {
      17. fmt.Println("成功连接到数据库")
      18. }
      19. // 创建表
      20. //db.Exec("create table book (bookid number(5), bookname varchar2(100) not null)")
      21. // 插入数据
      22. //var insert_sql = fmt.Sprintf("insert into book (bookid, bookname) values (%d, '%s')" ,  1, "thinking in java")
      23. //fmt.Println(insert_sql)
      24. //db.Exec(insert_sql)
      25. // 修改数据
      26. update_sql := fmt.Sprintf("update book set bookname  = '%s' where bookid = %d", "thinking in python", 1)
      27. fmt.Println(update_sql)
      28. db.Exec(update_sql)    
      29. //关闭数据库
      30. defer db.Close()
      31. }

    • 查看数据

      1.    ![](https://cdn.nlark.com/yuque/0/2020/jpeg/335089/1602466727149-25809337-9c57-4b5e-bcf9-93d6e1b2d8dd.jpeg#align=left&display=inline&height=144&margin=%5Bobject%20Object%5D&originHeight=195&originWidth=347&size=0&status=done&style=none&width=257)

  • 删除数据

    • Go 代码

      1. package main
      2. import (
      3. "database/sql"
      4. "fmt"
      5. //    "log"
      6. _ "github.com/mattn/go-oci8"
      7. )
      8. func main() {
      9. // 设置连接数据库的参数
      10. db, _ := sql.Open("oci8", "user5:oracle@dbserver/it.test.com")
      11. err := db.Ping()
      12. if err != nil {
      13.    fmt.Println("数据库连接失败")
      14.    return
      15. } else {
      16. fmt.Println("成功连接到数据库")
      17. }
      18. // 创建表
      19. //db.Exec("create table book (bookid number(5), bookname varchar2(100) not null)")
      20. // 插入数据
      21. //var insert_sql = fmt.Sprintf("insert into book (bookid, bookname) values (%d, '%s')" ,  1, "thinking in java")
      22. //fmt.Println(insert_sql)
      23. //db.Exec(insert_sql)
      24. // 修改数据
      25. //update_sql := fmt.Sprintf("update book set bookname  = '%s' where bookid = %d", "thinking in python", 1)
      26. //fmt.Println(update_sql)
      27. //db.Exec(update_sql) 
      28. // 删除数据
      29. delete_sql := fmt.Sprintf("delete from book where bookid = %d", 1)
      30. db.Exec(delete_sql)   
      31. //关闭数据库
      32. defer db.Close()
      33. }

    • 查看数据

Go 语言操作数据库 - 图12

Go 操作 MongoDB

  • 创建用户并修改密码

Go 语言操作数据库 - 图13

  • 切换到 mongodb 用户

    1. su - mongodb

  • 修改环境变量

    1. vim ~/.bash_profile
    2. export MONGODB_HOME=/usr/local/mongodb
    3. export PATH=$MONGODB_HOME/bin:.:$PATH

  • 配置文件生效

    1. source ~/.bash_profile

  • 查看 mongodb 服务

    1. which mongod

    Go 语言操作数据库 - 图14

  • 创建 mongodb 目录 ```bash

    数据目录

    mkdir -p ~/mongodb/data

日志目录

mkdir -p ~/mongodb/log

  2. - 启动 mongodb<br />
  3. ```bash
  4. mongod --dbpath ~/mongodb/data --logpath ~/mongodb/log/mongo.log

  • 新建一个窗口，切换到 mongodb 用户，查看27017 端口监听状态

    1. netstat -anlp | grep 27017 | grep LISTEN

    Go 语言操作数据库 - 图15

  • 查看 mongod 版本（服务器端）

    1. mongod --version

    Go 语言操作数据库 - 图16

  • 连接数据库

    1. # 连接客户端
    2. mongo --host localhost --port 27017
    3. # 连接服务端
    4. mongo --host dbserver -p 27017

  • 启动服务器

    1. su - mongodb
    2. mongod --dbpath ~/mongodb/data --logpath ~/mongodb/log/mongo.log

  • 连接服务器

    1. su - mongodb
    2. mongo --host dbserver --port 27017

  • 使用 Go 连接 mongodb

    1. package main
    2. import (
    3. "context"
    4. "fmt"
    5. "log"
    6. "go.mongodb.org/mongo-driver/mongo"
    7. "go.mongodb.org/mongo-driver/mongo/options"
    8. )
    9. func main() {
    10. // 设置客户端连接配置
    11. clientOptions := options.Client().ApplyURI("mongodb://dbserver:27017")
    12. // 连接到MongoDB
    13. client, err := mongo.Connect(context.TODO(), clientOptions)
    14. if err != nil {
    15. log.Fatal(err)
    16. }
    17. // 检查连接
    18. err = client.Ping(context.TODO(), nil)
    19. if err != nil {
    20. log.Fatal(err)
    21. }
    22. fmt.Println("Connected to MongoDB!")
    23. }

    Go 语言操作数据库 - 图17

  • 关闭连接

    1. • package main
    2. import (
    3. "context"
    4. "fmt"
    5. "log"
    6. "go.mongodb.org/mongo-driver/mongo"
    7. "go.mongodb.org/mongo-driver/mongo/options"
    8. )
    9. func main() {
    10. // 设置客户端连接配置
    11. clientOptions := options.Client().ApplyURI("mongodb://dbserver:27017")
    12. // 连接到MongoDB
    13. client, err := mongo.Connect(context.TODO(), clientOptions)
    14. if err != nil {
    15. log.Fatal(err)
    16. return
    17. }
    18. fmt.Println("Connected to MongoDB!")
    19. err = client.Disconnect(context.TODO())
    20. if err != nil {
    21. log.Fatal(err)
    22. return
    23. }
    24. fmt.Println("Connection to MongoDB closed.")
    25. }