6、golang程序开发

6.1、连接数据库

  1. package main
  3. import (
  4.     "fmt"
  5.     "time"
  7.     "github.com/jackc/pgx"
  8. )
  10. func main() {
  11.     var error_msg string
  13.     //连接数据库
  14.     conn, err := db_connect()
  15.     if err != nil {
  16.         error_msg = "连接数据库失败，详情：" + err.Error()
  17.         write_log("Error", error_msg)
  18.         return
  19.     }
  20.     //程序运行结束时关闭连接
  21.     defer conn.Close()
  22.     write_log("Log", "连接数据库成功")
  24. }
  26. /*
  27. 功能描述：写入日志处理
  29. 参数说明：
  30. log_level -- 日志级别，只能是是Error或Log
  31. error_msg -- 日志内容
  33. 返回值说明：无
  34. */
  36. func write_log(log_level string, error_msg string) {
  37.     //打印错误信息
  38.     fmt.Println("访问时间：", time.Now().Format("2006-01-02 15:04:05"))
  39.     fmt.Println("日志级别：", log_level)
  40.     fmt.Println("详细信息：", error_msg)
  41. }
  43. /*
  44. 功能描述：连接数据库
  46. 参数说明：无
  48. 返回值说明：
  49. conn *pgx.Conn -- 连接信息
  50. err error --错误信息
  52. */
  54. func db_connect() (conn *pgx.Conn, err error) {
  55.     var config pgx.ConnConfig
  56.     config.Host = "127.0.0.1"    //数据库主机host或ip
  57.     config.User = "tbase"         //连接用户
  58.     config.Password = "pgsql"    //用户密码
  59.     config.Database = "postgres" //连接数据库名
  60.     config.Port = 15432          //端口号
  61.     conn, err = pgx.Connect(config)
  62.     return conn, err
  63. }
  1. [root@VM_0_29_centos tbase]# go run conn.go 
  2. 访问时间： 2018-04-03 20:40:28
  3. 日志级别： Log
  4. 详细信息： 连接数据库成功

编译后运行

  1. [root@VM_0_29_centos tbase]# go build conn.go 
  2. [root@VM_0_29_centos tbase]# ./conn 
  3. 访问时间： 2018-04-03 20:40:48
  4. 日志级别： Log
  5. 详细信息： 连接数据库成功

6.2、创建数据表

  1. package main
  3. import (
  4.     "fmt"
  5.     "time"
  7.     "github.com/jackc/pgx"
  8. )
  10. func main() {
  11.     var error_msg string
  12.     var sql string
  14.     //连接数据库
  15.     conn, err := db_connect()
  16.     if err != nil {
  17.         error_msg = "连接数据库失败，详情：" + err.Error()
  18.         write_log("Error", error_msg)
  19.         return
  20.     }
  21.     //程序运行结束时关闭连接
  22.     defer conn.Close()
  23.     write_log("Log", "连接数据库成功")
  25.     //建立数据表
  26.     sql = "create table public.tbase(id varchar(20),nickname varchar(100)) distribute by shard(id) to group  default_group;"
  27.     _, err = conn.Exec(sql)
  28.     if err != nil {
  29.         error_msg = "创建数据表失败,详情：" + err.Error()
  30.         write_log("Error", error_msg)
  31.         return
  32.     } else {
  33.         write_log("Log", "创建数据表成功")
  34.     }
  35. }
  37. /*
  38. 功能描述：写入日志处理
  40. 参数说明：
  41. log_level -- 日志级别，只能是是Error或Log
  42. error_msg -- 日志内容
  44. 返回值说明：无
  45. */
  47. func write_log(log_level string, error_msg string) {
  48.     //打印错误信息
  49.     fmt.Println("访问时间：", time.Now().Format("2006-01-02 15:04:05"))
  50.     fmt.Println("日志级别：", log_level)
  51.     fmt.Println("详细信息：", error_msg)
  52. }
  54. /*
  55. 功能描述：连接数据库
  57. 参数说明：无
  59. 返回值说明：
  60. conn *pgx.Conn -- 连接信息
  61. err error --错误信息
  63. */
  65. func db_connect() (conn *pgx.Conn, err error) {
  66.     var config pgx.ConnConfig
  67.     config.Host = "127.0.0.1"    //数据库主机host或ip
  68.     config.User = "tbase"         //连接用户
  69.     config.Password = "pgsql"    //用户密码
  70.     config.Database = "postgres" //连接数据库名
  71.     config.Port = 15432          //端口号
  72.     conn, err = pgx.Connect(config)
  73.     return conn, err
  74. }
  1. [root@VM_0_29_centos tbase]# go run createtable.go 
  2. 访问时间： 2018-04-03 20:50:24
  3. 日志级别： Log
  4. 详细信息： 连接数据库成功
  5. 访问时间： 2018-04-03 20:50:24
  6. 日志级别： Log
  7. 详细信息： 创建数据表成功

6.3、插入数据

  1. package main
  3. import (
  4.     "fmt"
  5.     "strings"
  6.     "time"
  8.     "github.com/jackc/pgx"
  9. )
  11. func main() {
  12.     var error_msg string
  13.     var sql string
  14.     var nickname string
  16.     //连接数据库
  17.     conn, err := db_connect()
  18.     if err != nil {
  19.         error_msg = "连接数据库失败，详情：" + err.Error()
  20.         write_log("Error", error_msg)
  21.         return
  22.     }
  23.     //程序运行结束时关闭连接
  24.     defer conn.Close()
  25.     write_log("Log", "连接数据库成功")
  27.     //插入数据
  28.     sql = "insert into public.tbase values('1','tbase'),('2','pgxz');"
  29.     _, err = conn.Exec(sql)
  30.     if err != nil {
  31.         error_msg = "插入数据失败,详情：" + err.Error()
  32.         write_log("Error", error_msg)
  33.         return
  34.     } else {
  35.         write_log("Log", "插入数据成功")
  36.     }
  38.     //绑定变量插入数据,不需要做防注入处理
  39.     sql = "insert into public.tbase values($1,$2),($1,$3);"
  40.     _, err = conn.Exec(sql, "3", "postgresql", "postgres")
  41.     if err != nil {
  42.         error_msg = "插入数据失败,详情：" + err.Error()
  43.         write_log("Error", error_msg)
  44.         return
  45.     } else {
  46.         write_log("Log", "插入数据成功")
  47.     }
  49.     //拼接sql语句插入数据,需要做防注入处理
  50.     nickname = "TBase is ' good!"
  51.     sql = "insert into public.tbase values('1','" + sql_data_encode(nickname) + "')"
  52.     _, err = conn.Exec(sql)
  53.     if err != nil {
  54.         error_msg = "插入数据失败,详情：" + err.Error()
  55.         write_log("Error", error_msg)
  56.         return
  57.     } else {
  58.         write_log("Log", "插入数据成功")
  59.     }
  60. }
  62. /*
  63. 功能描述：sql查询拼接字符串编码
  65. 参数说明：
  66. str -- 要编码的字符串
  68. 返回值说明：
  69. 返回编码过的字符串
  71. */
  73. func sql_data_encode(str string) string {
  74.     return strings.Replace(str, "'", "''", -1)
  75. }
  77. /*
  78. 功能描述：写入日志处理
  80. 参数说明：
  81. log_level -- 日志级别，只能是是Error或Log
  82. error_msg -- 日志内容
  84. 返回值说明：无
  85. */
  87. func write_log(log_level string, error_msg string) {
  88.     //打印错误信息
  89.     fmt.Println("访问时间：", time.Now().Format("2006-01-02 15:04:05"))
  90.     fmt.Println("日志级别：", log_level)
  91.     fmt.Println("详细信息：", error_msg)
  92. }
  94. /*
  95. 功能描述：连接数据库
  97. 参数说明：无
  99. 返回值说明：
  100. conn *pgx.Conn -- 连接信息
  101. err error --错误信息
  103. */
  105. func db_connect() (conn *pgx.Conn, err error) {
  106.     var config pgx.ConnConfig
  107.     config.Host = "127.0.0.1"    //数据库主机host或ip
  108.     config.User = "tbase"         //连接用户
  109.     config.Password = "pgsql"    //用户密码
  110.     config.Database = "postgres" //连接数据库名
  111.     config.Port = 15432          //端口号
  112.     conn, err = pgx.Connect(config)
  113.     return conn, err
  114. }
  1. [root@VM_0_29_centos tbase]# go run insert.go 
  2. 访问时间： 2018-04-03 21:05:51
  3. 日志级别： Log
  4. 详细信息： 连接数据库成功
  5. 访问时间： 2018-04-03 21:05:51
  6. 日志级别： Log
  7. 详细信息： 插入数据成功
  8. 访问时间： 2018-04-03 21:05:51
  9. 日志级别： Log
  10. 详细信息： 插入数据成功
  11. 访问时间： 2018-04-03 21:05:51
  12. 日志级别： Log
  13. 详细信息： 插入数据成功

6.4、查询数据

  1. package main
  3. import (
  4.     "fmt"
  5.     "strings"
  6.     "time"
  8.     "github.com/jackc/pgx"
  9. )
  11. func main() {
  12.     var error_msg string
  13.     var sql string
  15.     //连接数据库
  16.     conn, err := db_connect()
  17.     if err != nil {
  18.         error_msg = "连接数据库失败，详情：" + err.Error()
  19.         write_log("Error", error_msg)
  20.         return
  21.     }
  22.     //程序运行结束时关闭连接
  23.     defer conn.Close()
  24.     write_log("Log", "连接数据库成功")
  26.     sql = "SELECT id,nickname FROM public.tbase LIMIT 2"
  27.     rows, err := conn.Query(sql)
  28.     if err != nil {
  29.         error_msg = "查询数据失败,详情：" + err.Error()
  30.         write_log("Error", error_msg)
  31.         return
  32.     } else {
  33.         write_log("Log", "查询数据成功")
  34.     }
  36.     var nickname string
  37.     var id string
  39.     for rows.Next() {
  40.         err = rows.Scan(&id, &nickname)
  41.         if err != nil {
  42.             error_msg = "执行查询失败，详情：" + err.Error()
  43.             write_log("Error", error_msg)
  44.             return
  45.         }
  46.         error_msg = fmt.Sprintf("id：%s nickname：%s", id, nickname)
  47.         write_log("Log", error_msg)
  48.     }
  49.     rows.Close()
  51.     nickname = "tbase"
  53.     sql = "SELECT id,nickname FROM public.tbase WHERE nickname ='" + sql_data_encode(nickname) + "' "
  54.     rows, err = conn.Query(sql)
  55.     if err != nil {
  56.         error_msg = "查询数据失败,详情：" + err.Error()
  57.         write_log("Error", error_msg)
  58.         return
  59.     } else {
  60.         write_log("Log", "查询数据成功")
  61.     }
  62.     defer rows.Close()
  64.     for rows.Next() {
  65.         err = rows.Scan(&id, &nickname)
  66.         if err != nil {
  67.             error_msg = "执行查询失败，详情：" + err.Error()
  68.             write_log("Error", error_msg)
  69.             return
  70.         }
  71.         error_msg = fmt.Sprintf("id：%s nickname：%s", id, nickname)
  72.         write_log("Log", error_msg)
  73.     }
  74. }
  76. /*
  77. 功能描述：sql查询拼接字符串编码
  79. 参数说明：
  80. str -- 要编码的字符串
  82. 返回值说明：
  83. 返回编码过的字符串
  85. */
  87. func sql_data_encode(str string) string {
  88.     return strings.Replace(str, "'", "''", -1)
  89. }
  91. /*
  92. 功能描述：写入日志处理
  94. 参数说明：
  95. log_level -- 日志级别，只能是是Error或Log
  96. error_msg -- 日志内容
  98. 返回值说明：无
  99. */
  101. func write_log(log_level string, error_msg string) {
  102.     //打印错误信息
  103.     fmt.Println("访问时间：", time.Now().Format("2006-01-02 15:04:05"))
  104.     fmt.Println("日志级别：", log_level)
  105.     fmt.Println("详细信息：", error_msg)
  106. }
  108. /*
  109. 功能描述：连接数据库
  111. 参数说明：无
  113. 返回值说明：
  114. conn *pgx.Conn -- 连接信息
  115. err error --错误信息
  117. */
  119. func db_connect() (conn *pgx.Conn, err error) {
  120.     var config pgx.ConnConfig
  121.     config.Host = "127.0.0.1"    //数据库主机host或ip
  122.     config.User = "tbase"         //连接用户
  123.     config.Password = "pgsql"    //用户密码
  124.     config.Database = "postgres" //连接数据库名
  125.     config.Port = 15432          //端口号
  126.     conn, err = pgx.Connect(config)
  127.     return conn, err
  128. }
  1. [root@VM_0_29_centos tbase]# go run select.go
  2. 访问时间： 2018-04-09 10:35:50
  3. 日志级别： Log
  4. 详细信息： 连接数据库成功
  5. 访问时间： 2018-04-09 10:35:50
  6. 日志级别： Log
  7. 详细信息： 查询数据成功
  8. 访问时间： 2018-04-09 10:35:50
  9. 日志级别： Log
  10. 详细信息： id：2 nickname：tbase
  11. 访问时间： 2018-04-09 10:35:50
  12. 日志级别： Log
  13. 详细信息： id：3 nickname：postgresql
  14. 访问时间： 2018-04-09 10:35:50
  15. 日志级别： Log
  16. 详细信息： 查询数据成功
  17. 访问时间： 2018-04-09 10:35:50
  18. 日志级别： Log
  19. 详细信息： id：1 nickname：tbase

6.5、流数据copy from入表

  1. package main
  3. import (
  4.     "fmt"
  5.     "math/rand"
  6.     "time"
  8.     "github.com/jackc/pgx"
  9. )
  11. func main() {
  12.     var error_msg string
  14.     //连接数据库
  15.     conn, err := db_connect()
  16.     if err != nil {
  17.         error_msg = "连接数据库失败，详情：" + err.Error()
  18.         write_log("Error", error_msg)
  19.         return
  20.     }
  21.     //程序运行结束时关闭连接
  22.     defer conn.Close()
  23.     write_log("Log", "连接数据库成功")
  25.     //构造5000行数据
  26.     inputRows := [][]interface{}{}
  27.     var id string
  28.     var nickname string
  29.     for i := 0; i < 5000; i++ {
  30.         id = fmt.Sprintf("%d", rand.Intn(10000))
  31.         nickname = fmt.Sprintf("%d", rand.Intn(10000))
  32.         inputRows = append(inputRows, []interface{}{id, nickname})
  33.     }
  34.     copyCount, err := conn.CopyFrom(pgx.Identifier{"tbase"}, []string{"id", "nickname"}, pgx.CopyFromRows(inputRows))
  35.     if err != nil {
  36.         error_msg = "执行copyFrom失败,详情：" + err.Error()
  37.         write_log("Error", error_msg)
  38.         return
  39.     }
  40.     if copyCount != len(inputRows) {
  41.         error_msg = fmt.Sprintf("执行copyFrom失败，copy行数：%d 返回行数为：%d", len(inputRows), copyCount)
  42.         write_log("Error", error_msg)
  43.         return
  44.     } else {
  45.         error_msg = "Copy 记录成功"
  46.         write_log("Log", error_msg)
  47.     }
  49. }
  51. /*
  52. 功能描述：写入日志处理
  54. 参数说明：
  55. log_level -- 日志级别，只能是是Error或Log
  56. error_msg -- 日志内容
  58. 返回值说明：无
  59. */
  61. func write_log(log_level string, error_msg string) {
  62.     //打印错误信息
  63.     fmt.Println("访问时间：", time.Now().Format("2006-01-02 15:04:05"))
  64.     fmt.Println("日志级别：", log_level)
  65.     fmt.Println("详细信息：", error_msg)
  66. }
  68. /*
  69. 功能描述：连接数据库
  71. 参数说明：无
  73. 返回值说明：
  74. conn *pgx.Conn -- 连接信息
  75. err error --错误信息
  77. */
  79. func db_connect() (conn *pgx.Conn, err error) {
  80.     var config pgx.ConnConfig
  81.     config.Host = "127.0.0.1"    //数据库主机host或ip
  82.     config.User = "tbase"         //连接用户
  83.     config.Password = "pgsql"    //用户密码
  84.     config.Database = "postgres" //连接数据库名
  85.     config.Port = 15432          //端口号
  86.     conn, err = pgx.Connect(config)
  87.     return conn, err
  88. }
  1. [root@VM_0_29_centos tbase]# go run copy_from.go 
  2. 访问时间： 2018-04-09 10:36:40
  3. 日志级别： Log
  4. 详细信息： 连接数据库成功
  5. 访问时间： 2018-04-09 10:36:40
  6. 日志级别： Log
  7. 详细信息： Copy 记录成功

6.6、golang相关资源包

需要git的资源包:https://github.com/jackc/pgxhttps://github.com/pkg/errors