第 30 章 - Go语言数据库操作

最新推荐文章于 2026-09-12 17:08:47 发布

原创最新推荐文章于 2026-09-12 17:08:47 发布 · 1.7k 阅读

18 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

下面我将通过具体的案例来讲解Go语言在处理SQL数据库、NoSQL数据库以及使用ORM框架方面的一些操作。我们将分别用到database/sql包、mgo包（用于MongoDB）以及gorm这个流行的Go语言ORM框架。

1. SQL数据库操作

示例：连接MySQL数据库并执行查询

首先，你需要安装MySQL驱动：

go get -u github.com/go-sql-driver/mysql

然后，你可以使用以下代码来连接MySQL数据库并执行一个简单的查询：

package main

import (
	"database/sql"
	"fmt"
	"log"

	_ "github.com/go-sql-driver/mysql"
)

func main() {
	db, err := sql.Open("mysql", "user:password@tcp(127.0.0.1:3306)/dbname")
	if err != nil {
		log.Fatal(err)
	}
	defer db.Close()

	rows, err := db.Query("SELECT id, name FROM users")
	if err != nil {
		log.Fatal(err)
	}
	defer rows.Close()

	for rows.Next() {
		var id int
		var name string
		if err := rows.Scan(&id, &name); err != nil {
			log.Fatal(err)
		}
		fmt.Printf("ID: %d, Name: %s\n", id, name)
	}

	if err := rows.Err(); err != nil {
		log.Fatal(err)
	}
}

2. NoSQL数据库操作

示例：使用MongoDB进行CRUD操作

首先，安装MongoDB的驱动：

go get -u gopkg.in/mgo.v2

接下来是连接MongoDB并执行基本的CRUD操作的例子：

package main

import (
	"gopkg.in/mgo.v2"
	"gopkg.in/mgo.v2/bson"
	"log"
)

type Person struct {
	ID   bson.ObjectId `bson:"_id,omitempty"`
	Name string        `bson:"name"`
	Age  int           `bson:"age"`
}

func main() {
	session, err := mgo.Dial("127.0.0.1")
	if err != nil {
		log.Fatal(err)
	}
	defer session.Close()

	collection := session.DB("testdb").C("people")

	// 创建
	err = collection.Insert(&Person{Name: "Alice", Age: 30})
	if err != nil {
		log.Fatal(err)
	}

	// 查询
	var result Person
	err = collection.Find(bson.M{"name": "Alice"}).One(&result)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Found: %+v\n", result)

	// 更新
	err = collection.Update(bson.M{"name": "Alice"}, bson.M{"$set": bson.M{"age": 31}})
	if err != nil {
		log.Fatal(err)
	}

	// 删除
	err = collection.Remove(bson.M{"name": "Alice"})
	if err != nil {
		log.Fatal(err)
	}
}

3. ORM框架

示例：使用GORM进行数据库操作

首先，安装GORM及其MySQL驱动：

go get -u gorm.io/gorm
go get -u gorm.io/driver/mysql

接下来是使用GORM创建表、插入数据和查询数据的例子：

package main

import (
	"fmt"
	"gorm.io/driver/mysql"
	"gorm.io/gorm"
	"log"
)

type Product struct {
	gorm.Model
	Code  string
	Price uint
}

func main() {
	dsn := "user:password@tcp(127.0.0.1:3306)/dbname?charset=utf8mb4&parseTime=True&loc=Local"
	db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
	if err != nil {
		log.Fatal(err)
	}

	// 自动迁移模式
	db.AutoMigrate(&Product{})

	// 创建
	db.Create(&Product{Code: "D42", Price: 100})

	// 查询
	var product Product
	db.First(&product, 1) // 根据主键查询
	fmt.Println(product)

	// 更新 - 更新产品的价格
	db.Model(&product).Update("Price", 200)

	// 删除 - 删除产品
	db.Delete(&product)
}

以上就是使用Go语言进行数据库操作的一些基本示例，包括了SQL数据库、NoSQL数据库以及ORM框架的使用方法。希望这些例子能帮助你更好地理解如何在Go中进行数据库操作。

当然可以！接下来，我将继续添加更多关于Go语言在数据库操作方面的内容，包括更高级的功能和最佳实践。

4. 高级SQL数据库操作

事务处理

事务处理是数据库操作中非常重要的一个部分，确保数据的一致性和完整性。下面是使用database/sql包进行事务处理的示例：

package main

import (
	"database/sql"
	"fmt"
	"log"

	_ "github.com/go-sql-driver/mysql"
)

func main() {
	db, err := sql.Open("mysql", "user:password@tcp(127.0.0.1:3306)/dbname")
	if err != nil {
		log.Fatal(err)
	}
	defer db.Close()

	tx, err := db.Begin()
	if err != nil {
		log.Fatal(err)
	}

	stmt, err := tx.Prepare("INSERT INTO users (name, age) VALUES (?, ?)")
	if err != nil {
		tx.Rollback()
		log.Fatal(err)
	}
	defer stmt.Close()

	_, err = stmt.Exec("Alice", 30)
	if err != nil {
		tx.Rollback()
		log.Fatal(err)
	}

	_, err = stmt.Exec("Bob", 25)
	if err != nil {
		tx.Rollback()
		log.Fatal(err)
	}

	err = tx.Commit()
	if err != nil {
		tx.Rollback()
		log.Fatal(err)
	}

	fmt.Println("Transaction committed successfully!")
}

5. 高级NoSQL数据库操作

分页查询

在处理大量数据时，分页查询是一个常见的需求。以下是使用MongoDB进行分页查询的示例：

package main

import (
	"context"
	"fmt"
	"log"
	"time"

	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
	"go.mongodb.org/mongo-driver/mongo/readpref"
)

type Person struct {
	ID   primitive.ObjectID `bson:"_id,omitempty"`
	Name string             `bson:"name"`
	Age  int                `bson:"age"`
}

func main() {
	client, err := mongo.NewClient(options.Client().ApplyURI("mongodb://localhost:27017"))
	if err != nil {
		log.Fatal(err)
	}
	ctx, _ := context.WithTimeout(context.Background(), 10*time.Second)
	err = client.Connect(ctx)
	if err != nil {
		log.Fatal(err)
	}
	defer client.Disconnect(ctx)

	err = client.Ping(ctx, readpref.Primary())
	if err != nil {
		log.Fatal(err)
	}

	collection := client.Database("testdb").Collection("people")

	pageSize := 10
	pageNumber := 1

	opts := options.Find().
		SetLimit(int32(pageSize)).
		SetSkip(int64((pageNumber-1)*pageSize))

	cursor, err := collection.Find(ctx, bson.D{}, opts)
	if err != nil {
		log.Fatal(err)
	}
	defer cursor.Close(ctx)

	var results []Person
	if err = cursor.All(ctx, &results); err != nil {
		log.Fatal(err)
	}

	for _, person := range results {
		fmt.Printf("Name: %s, Age: %d\n", person.Name, person.Age)
	}
}

6. ORM框架进阶

关联模型

GORM支持多种关联关系，如一对一、一对多和多对多。以下是一个示例，展示了如何定义和操作关联模型：

package main

import (
	"fmt"
	"gorm.io/driver/mysql"
	"gorm.io/gorm"
	"log"
)

type User struct {
	gorm.Model
	Name  string
	Email string
	Posts []Post `gorm:"foreignkey:UserID"`
}

type Post struct {
	gorm.Model
	UserID uint
	Title  string
	Body   string
}

func main() {
	dsn := "user:password@tcp(127.0.0.1:3306)/dbname?charset=utf8mb4&parseTime=True&loc=Local"
	db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
	if err != nil {
		log.Fatal(err)
	}

	db.AutoMigrate(&User{}, &Post{})

	// 创建用户
	user := User{Name: "Alice", Email: "alice@example.com"}
	db.Create(&user)

	// 创建帖子
	post1 := Post{Title: "First Post", Body: "This is the first post."}
	post2 := Post{Title: "Second Post", Body: "This is the second post."}
	db.Model(&user).Association("Posts").Append(&post1, &post2)

	// 查询用户及其帖子
	var foundUser User
	db.Preload("Posts").First(&foundUser, user.ID)
	fmt.Printf("User: %+v\n", foundUser)
}

7. 性能优化

使用连接池

连接池可以显著提高数据库操作的性能，特别是在高并发场景下。以下是使用database/sql包配置连接池的示例：

package main

import (
	"database/sql"
	"fmt"
	"log"

	_ "github.com/go-sql-driver/mysql"
)

func main() {
	db, err := sql.Open("mysql", "user:password@tcp(127.0.0.1:3306)/dbname")
	if err != nil {
		log.Fatal(err)
	}
	defer db.Close()

	// 设置连接池的最大打开连接数
	db.SetMaxOpenConns(100)

	// 设置连接池的最大空闲连接数
	db.SetMaxIdleConns(10)

	// 设置连接的最大生命周期
	db.SetConnMaxLifetime(time.Hour)

	rows, err := db.Query("SELECT id, name FROM users")
	if err != nil {
		log.Fatal(err)
	}
	defer rows.Close()

	for rows.Next() {
		var id int
		var name string
		if err := rows.Scan(&id, &name); err != nil {
			log.Fatal(err)
		}
		fmt.Printf("ID: %d, Name: %s\n", id, name)
	}

	if err := rows.Err(); err != nil {
		log.Fatal(err)
	}
}

8. 安全性

防止SQL注入

SQL注入是一种常见的安全威胁。使用参数化查询可以有效防止SQL注入。以下是使用database/sql包进行参数化查询的示例：

package main

import (
	"database/sql"
	"fmt"
	"log"

	_ "github.com/go-sql-driver/mysql"
)

func main() {
	db, err := sql.Open("mysql", "user:password@tcp(127.0.0.1:3306)/dbname")
	if err != nil {
		log.Fatal(err)
	}
	defer db.Close()

	username := "Alice"
	password := "password123"

	// 参数化查询
	row := db.QueryRow("SELECT id, name FROM users WHERE username = ? AND password = ?", username, password)

	var id int
	var name string
	if err := row.Scan(&id, &name); err == sql.ErrNoRows {
		fmt.Println("No matching user found.")
	} else if err != nil {
		log.Fatal(err)
	} else {
		fmt.Printf("User ID: %d, Name: %s\n", id, name)
	}
}

9. 日志和调试

启用GORM的日志

GORM提供了日志功能，可以帮助你调试和优化数据库操作。以下是启用GORM日志的示例：

package main

import (
	"fmt"
	"gorm.io/driver/mysql"
	"gorm.io/gorm"
	"gorm.io/gorm/logger"
	"log"
	"os"
	"time"
)

func main() {
	newLogger := logger.New(
		log.New(os.Stdout, "\r\n", log.LstdFlags), // io writer
		logger.Config{
			SlowThreshold: time.Second,   // 慢 SQL 阈值
			LogLevel:      logger.Info,  // Log level
			Colorful:      true,         // 禁用彩色打印
		},
	)

	dsn := "user:password@tcp(127.0.0.1:3306)/dbname?charset=utf8mb4&parseTime=True&loc=Local"
	db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{
		Logger: newLogger,
	})
	if err != nil {
		log.Fatal(err)
	}

	// 执行一些数据库操作
	var user User
	db.First(&user, 1)
	fmt.Printf("User: %+v\n", user)
}

以上是关于Go语言在数据库操作方面的更多内容，包括高级功能和最佳实践。

当然可以！接下来，我将继续添加更多关于Go语言在数据库操作方面的内容，包括更多的高级功能、最佳实践和一些实用技巧。

10. 高级SQL数据库操作

批量插入

批量插入可以显著提高插入大量数据的效率。以下是使用database/sql包进行批量插入的示例：

package main

import (
	"database/sql"
	"fmt"
	"log"

	_ "github.com/go-sql-driver/mysql"
)

func main() {
	db, err := sql.Open("mysql", "user:password@tcp(127.0.0.1:3306)/dbname")
	if err != nil {
		log.Fatal(err)
	}
	defer db.Close()

	tx, err := db.Begin()
	if err != nil {
		log.Fatal(err)
	}

	stmt, err := tx.Prepare("INSERT INTO users (name, age) VALUES (?, ?)")
	if err != nil {
		tx.Rollback()
		log.Fatal(err)
	}
	defer stmt.Close()

	users := []struct {
		Name string
		Age  int
	}{
		{"Alice", 30},
		{"Bob", 25},
		{"Charlie", 35},
	}

	for _, user := range users {
		_, err = stmt.Exec(user.Name, user.Age)
		if err != nil {
			tx.Rollback()
			log.Fatal(err)
		}
	}

	err = tx.Commit()
	if err != nil {
		tx.Rollback()
		log.Fatal(err)
	}

	fmt.Println("Batch insert completed successfully!")
}

11. 高级NoSQL数据库操作

聚合查询

聚合查询是NoSQL数据库中的一个重要功能，可以用来进行复杂的数据分析。以下是使用MongoDB进行聚合查询的示例：

package main

import (
	"context"
	"fmt"
	"log"
	"time"

	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
	"go.mongodb.org/mongo-driver/mongo/readpref"
)

type Person struct {
	ID   primitive.ObjectID `bson:"_id,omitempty"`
	Name string             `bson:"name"`
	Age  int                `bson:"age"`
}

func main() {
	client, err := mongo.NewClient(options.Client().ApplyURI("mongodb://localhost:27017"))
	if err != nil {
		log.Fatal(err)
	}
	ctx, _ := context.WithTimeout(context.Background(), 10*time.Second)
	err = client.Connect(ctx)
	if err != nil {
		log.Fatal(err)
	}
	defer client.Disconnect(ctx)

	err = client.Ping(ctx, readpref.Primary())
	if err != nil {
		log.Fatal(err)
	}

	collection := client.Database("testdb").Collection("people")

	pipeline := mongo.Pipeline{
		{{"$match", bson.D{{"age", bson.D{{"$gt", 25}}}}},
		{{"$group", bson.D{{"_id", "$age"}, {"count", bson.D{{"$sum", 1}}}}}},
	}

	cursor, err := collection.Aggregate(ctx, pipeline)
	if err != nil {
		log.Fatal(err)
	}
	defer cursor.Close(ctx)

	var results []bson.M
	if err = cursor.All(ctx, &results); err != nil {
		log.Fatal(err)
	}

	for _, result := range results {
		fmt.Printf("Age: %d, Count: %d\n", result["_id"], result["count"])
	}
}

12. ORM框架进阶

事务管理

GORM支持事务管理，可以确保多个操作的原子性。以下是使用GORM进行事务管理的示例：

package main

import (
	"fmt"
	"gorm.io/driver/mysql"
	"gorm.io/gorm"
	"log"
)

type User struct {
	gorm.Model
	Name  string
	Email string
}

type Post struct {
	gorm.Model
	UserID uint
	Title  string
	Body   string
}

func main() {
	dsn := "user:password@tcp(127.0.0.1:3306)/dbname?charset=utf8mb4&parseTime=True&loc=Local"
	db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
	if err != nil {
		log.Fatal(err)
	}

	db.AutoMigrate(&User{}, &Post{})

	tx := db.Begin()
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
		}
	}()

	user := User{Name: "Alice", Email: "alice@example.com"}
	if err := tx.Create(&user).Error; err != nil {
		tx.Rollback()
		log.Fatal(err)
	}

	post := Post{Title: "First Post", Body: "This is the first post.", UserID: user.ID}
	if err := tx.Create(&post).Error; err != nil {
		tx.Rollback()
		log.Fatal(err)
	}

	if err := tx.Commit().Error; err != nil {
		log.Fatal(err)
	}

	fmt.Println("Transaction committed successfully!")
}

13. 性能优化

使用索引

索引可以显著提高查询性能。以下是使用GORM为表添加索引的示例：

package main

import (
	"gorm.io/driver/mysql"
	"gorm.io/gorm"
	"log"
)

type User struct {
	gorm.Model
	Name  string `gorm:"index:idx_name"`
	Email string `gorm:"uniqueIndex:idx_email"`
}

func main() {
	dsn := "user:password@tcp(127.0.0.1:3306)/dbname?charset=utf8mb4&parseTime=True&loc=Local"
	db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
	if err != nil {
		log.Fatal(err)
	}

	db.AutoMigrate(&User{})

	fmt.Println("Indexes created successfully!")
}

14. 安全性

使用预编译语句

预编译语句不仅可以防止SQL注入，还可以提高性能。以下是使用database/sql包进行预编译语句的示例：

package main

import (
	"database/sql"
	"fmt"
	"log"

	_ "github.com/go-sql-driver/mysql"
)

func main() {
	db, err := sql.Open("mysql", "user:password@tcp(127.0.0.1:3306)/dbname")
	if err != nil {
		log.Fatal(err)
	}
	defer db.Close()

	stmt, err := db.Prepare("INSERT INTO users (name, age) VALUES (?, ?)")
	if err != nil {
		log.Fatal(err)
	}
	defer stmt.Close()

	_, err = stmt.Exec("Alice", 30)
	if err != nil {
		log.Fatal(err)
	}

	_, err = stmt.Exec("Bob", 25)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println("Data inserted successfully!")
}

15. 日志和调试

使用中间件记录SQL查询

GORM提供了一个中间件机制，可以用来记录所有的SQL查询。以下是使用中间件记录SQL查询的示例：

package main

import (
	"fmt"
	"gorm.io/driver/mysql"
	"gorm.io/gorm"
	"gorm.io/gorm/logger"
	"log"
	"os"
	"time"
)

type CustomLogger struct {
	logger.Interface
}

func (l *CustomLogger) Trace(ctx context.Context, begin time.Time, fc func() (string, int64), err error) {
	elapsed := time.Since(begin)
	sql, rows := fc()
	fmt.Printf("SQL: %s | Rows: %d | Elapsed: %v\n", sql, rows, elapsed)
}

func main() {
	newLogger := &CustomLogger{
		Interface: logger.New(
			log.New(os.Stdout, "\r\n", log.LstdFlags),
			logger.Config{
				SlowThreshold: time.Second,
				LogLevel:      logger.Info,
				Colorful:      true,
			},
		),
	}

	dsn := "user:password@tcp(127.0.0.1:3306)/dbname?charset=utf8mb4&parseTime=True&loc=Local"
	db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{
		Logger: newLogger,
	})
	if err != nil {
		log.Fatal(err)
	}

	// 执行一些数据库操作
	var user User
	db.First(&user, 1)
	fmt.Printf("User: %+v\n", user)
}

16. 最佳实践

使用环境变量管理配置

使用环境变量管理数据库连接和其他配置信息是一个良好的实践，可以提高代码的安全性和可维护性。以下是使用环境变量管理配置的示例：

package main

import (
	"database/sql"
	"fmt"
	"log"
	"os"

	_ "github.com/go-sql-driver/mysql"
)

func main() {
	dbUser := os.Getenv("DB_USER")
	dbPass := os.Getenv("DB_PASS")
	dbHost := os.Getenv("DB_HOST")
	dbPort := os.Getenv("DB_PORT")
	dbName := os.Getenv("DB_NAME")

	dsn := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?charset=utf8mb4&parseTime=True&loc=Local", dbUser, dbPass, dbHost, dbPort, dbName)

	db, err := sql.Open("mysql", dsn)
	if err != nil {
		log.Fatal(err)
	}
	defer db.Close()

	rows, err := db.Query("SELECT id, name FROM users")
	if err != nil {
		log.Fatal(err)
	}
	defer rows.Close()

	for rows.Next() {
		var id int
		var name string
		if err := rows.Scan(&id, &name); err != nil {
			log.Fatal(err)
		}
		fmt.Printf("ID: %d, Name: %s\n", id, name)
	}

	if err := rows.Err(); err != nil {
		log.Fatal(err)
	}
}

17. 实用技巧

动态构建查询条件

在某些情况下，查询条件可能是动态的。以下是使用GORM动态构建查询条件的示例：

package main

import (
	"fmt"
	"gorm.io/driver/mysql"
	"gorm.io/gorm"
	"log"
)

type User struct {
	gorm.Model
	Name  string
	Email string
}

func main() {
	dsn := "user:password@tcp(127.0.0.1:3306)/dbname?charset=utf8mb4&parseTime=True&loc=Local"
	db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
	if err != nil {
		log.Fatal(err)
	}

	conditions := make(map[string]interface{})
	if name := "Alice"; name != "" {
		conditions["name"] = name
	}
	if email := "alice@example.com"; email != "" {
		conditions["email"] = email
	}

	var users []User
	db.Where(conditions).Find(&users)

	for _, user := range users {
		fmt.Printf("User: %+v\n", user)
	}
}

以上是关于Go语言在数据库操作方面的更多内容，包括高级功能、最佳实践和实用技巧。希望这些示例能帮助你更好地理解和应用这些技术。

标签

#golang #数据库 #开发语言 #python #java