Go 中的資料庫互動：從 SQL 到 NoSQL

介紹

Go (Golang) 已成為建構健壯、高效能後端服務的熱門選擇。 Go 的主要優勢之一是它對資料庫操作的出色支持，無論您使用傳統 SQL 資料庫還是現代 NoSQL 解決方案。在本指南中，我們將探索如何在 Go 中與資料庫交互，涵蓋 SQL 和 NoSQL 方法。

目錄

1. SQL 資料庫交互
   • 使用database/sql套件
   • 使用 ORM：GORM
2. NoSQL 資料庫交互
   • MongoDB 與官方 Go 驅動程式
3. 最佳實務與常見陷阱
4. 結論

SQL 資料庫交互

使用database/sql包

Go 的標準函式庫提供了 database/sql 包，它提供了圍繞 SQL（或類似 SQL）資料庫的通用介面。該軟體包旨在與特定於資料庫的驅動程式結合使用。

讓我們從一個使用 SQLite 的簡單範例開始：

package main

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

func main() {
    // Open the database
    db, err := sql.Open("sqlite3", "./test.db")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    // Create table
    _, err = db.Exec(`CREATE TABLE IF NOT EXISTS users (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        name TEXT,
        age INTEGER
    )`)
    if err != nil {
        log.Fatal(err)
    }

    // Insert a user
    result, err := db.Exec("INSERT INTO users (name, age) VALUES (?, ?)", "Alice", 30)
    if err != nil {
        log.Fatal(err)
    }

    // Get the ID of the inserted user
    id, err := result.LastInsertId()
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Inserted user with ID: %d\n", id)

    // Query for the user
    var name string
    var age int
    err = db.QueryRow("SELECT name, age FROM users WHERE id = ?", id).Scan(&name, &age)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("User: %s, Age: %d\n", name, age)
}

此範例示範了在 Go 中使用 SQL 資料庫的基礎知識：

1. 開啟資料庫連線
2. 建立表格
3. 插入資料
4. 查詢資料

database/sql 套件提供了資料庫的低階接口，讓您可以很好地控制查詢和操作。

使用 ORM：GORM

雖然database/sql包很強大，但許多開發人員更喜歡使用物件關係映射（ORM）工具來更方便地進行資料庫操作。 GORM 是 Go 最受歡迎的 ORM 之一。

這是一個將 GORM 與 SQLite 結合的範例：

package main

import (
    "fmt"
    "log"

    "gorm.io/driver/sqlite"
    "gorm.io/gorm"
)

type User struct {
    ID   uint
    Name string
    Age  int
}

func main() {
    // Open the database
    db, err := gorm.Open(sqlite.Open("test.db"), &gorm.Config{})
    if err != nil {
        log.Fatal(err)
    }

    // Auto Migrate the schema
    db.AutoMigrate(&User{})

    // Create a user
    user := User{Name: "Bob", Age: 25}
    result := db.Create(&user)
    if result.Error != nil {
        log.Fatal(result.Error)
    }
    fmt.Printf("Inserted user with ID: %d\n", user.ID)

    // Query for the user
    var fetchedUser User
    db.First(&fetchedUser, user.ID)
    fmt.Printf("User: %s, Age: %d\n", fetchedUser.Name, fetchedUser.Age)

    // Update the user
    db.Model(&fetchedUser).Update("Age", 26)

    // Delete the user
    db.Delete(&fetchedUser)
}

GORM 提供了對資料庫操作的更高層級的抽象，讓您可以直接使用 Go 結構，而不是編寫原始 SQL 查詢。它還提供自動遷移、掛鉤和關聯等功能。

NoSQL 資料庫交互

MongoDB 與官方 Go 驅動程式

對於NoSQL資料庫，讓我們來看看如何使用官方Go驅動程式與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"
)

type User struct {
    Name string `bson:"name"`
    Age  int    `bson:"age"`
}

func main() {
    // Set client options
    clientOptions := options.Client().ApplyURI("mongodb://localhost:27017")

    // Connect to MongoDB
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()
    client, err := mongo.Connect(ctx, clientOptions)
    if err != nil {
        log.Fatal(err)
    }

    // Check the connection
    err = client.Ping(context.TODO(), nil)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println("Connected to MongoDB!")

    // Get a handle for your collection
    collection := client.Database("test").Collection("users")

    // Insert a user
    user := User{Name: "Charlie", Age: 35}
    insertResult, err := collection.InsertOne(context.TODO(), user)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Inserted user with ID: %v\n", insertResult.InsertedID)

    // Find a user
    var result User
    filter := bson.M{"name": "Charlie"}
    err = collection.FindOne(context.TODO(), filter).Decode(&result)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Found user: %+v\n", result)

    // Update a user
    update := bson.M{
        "$set": bson.M{
            "age": 36,
        },
    }
    updateResult, err := collection.UpdateOne(context.TODO(), filter, update)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Updated %v user(s)\n", updateResult.ModifiedCount)

    // Delete a user
    deleteResult, err := collection.DeleteOne(context.TODO(), filter)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Deleted %v user(s)\n", deleteResult.DeletedCount)

    // Disconnect
    err = client.Disconnect(context.TODO())
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("Connection to MongoDB closed.")
}

此範例示範了使用官方 Go 驅動程式對 MongoDB 進行基本的 CRUD（建立、讀取、更新、刪除）操作。

最佳實踐和常見陷阱

在 Go 中使用資料庫時，請記住以下最佳實踐：

1. 使用連線池：資料庫/sql和大多數NoSQL驅動程式都會實作連線池。確保重複使用資料庫連接，而不是為每個操作開啟新的連接。

2. 正確處理錯誤：請務必檢查資料庫操作傳回的錯誤並進行適當處理。

3. 使用prepared statements：對於SQL資料庫，使用prepared statements可以提高效能並防止SQL注入攻擊。

4. 關閉資源：使用完結果集、語句和資料庫連線後，請務必將其關閉。 defer 關鍵字對此很有用。

5. 必要時使用交易：對於需要多個步驟的操作，使用事務來確保資料的一致性。

6. 注意 N 1 查詢問題：使用 ORM 時，請注意 N 1 查詢問題，並在適當的時候使用急切加載。

7. 使用上下文進行超時：使用上下文設定資料庫操作的逾時，特別是對於長時間運行的查詢。

需要避免的常見陷阱：

1. 忽略 SQL 注入漏洞：一律使用參數化查詢或準備好的語句。
2. 不處理連線錯誤：檢查並處理連線錯誤，必要時實作重試邏輯。
3. 過度使用 GORM hooks：雖然方便，但過度使用 GORM hooks 可能會導致難以調試的問題。
4. 未正確建立索引：確保您的資料庫架構已針對您的查詢模式正確建立索引。
5. 以明文形式儲存敏感資料：在將敏感資料儲存到資料庫之前始終對其進行加密。

結論

Go 為 SQL 和 NoSQL 資料庫互動提供強大的支援。無論您喜歡資料庫/sql 的低階控制、像 GORM 這樣的 ORM 的便利性，還是使用像 MongoDB 這樣的 NoSQL 資料庫，Go 都能滿足您的需求。

以上是Go 中的資料庫互動：從 SQL 到 NoSQL的詳細內容。更多資訊請關注PHP中文網其他相關文章！