Interaksi Pangkalan Data dalam Go: Dari SQL ke NoSQL

Introduction

Go (Golang) has become a popular choice for building robust, high-performance backend services. One of the key strengths of Go is its excellent support for database operations, whether you're working with traditional SQL databases or modern NoSQL solutions. In this guide, we'll explore how to interact with databases in Go, covering both SQL and NoSQL approaches.

Table of Contents

1. SQL Database Interactions
   • Using the database/sql Package
   • Working with an ORM: GORM
2. NoSQL Database Interactions
   • MongoDB with the Official Go Driver
3. Best Practices and Common Pitfalls
4. Conclusion

SQL Database Interactions

Using the database/sql Package

Go's standard library provides the database/sql package, which offers a generic interface around SQL (or SQL-like) databases. This package is designed to be used in conjunction with database-specific drivers.

Let's start with a simple example using 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)
}

This example demonstrates the basics of working with SQL databases in Go:

1. Opening a database connection
2. Creating a table
3. Inserting data
4. Querying data

The database/sql package provides a low-level interface to the database, giving you fine control over your queries and operations.

Working with an ORM: GORM

While the database/sql package is powerful, many developers prefer using an Object-Relational Mapping (ORM) tool for more convenient database operations. GORM is one of the most popular ORMs for Go.

Here's an example of using GORM with 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 provides a higher-level abstraction over database operations, allowing you to work with Go structs directly instead of writing raw SQL queries. It also offers features like automatic migrations, hooks, and associations.

NoSQL Database Interactions

MongoDB with the Official Go Driver

For NoSQL databases, let's look at how to interact with MongoDB using the official Go driver:

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.")
}

This example demonstrates the basic CRUD (Create, Read, Update, Delete) operations with MongoDB using the official Go driver.

Best Practices and Common Pitfalls

When working with databases in Go, keep these best practices in mind:

1. Use connection pooling: Both database/sql and most NoSQL drivers implement connection pooling. Make sure to reuse database connections instead of opening new ones for each operation.

2. Handle errors properly: Always check for errors returned by database operations and handle them appropriately.

3. Use prepared statements: For SQL databases, use prepared statements to improve performance and prevent SQL injection attacks.

4. Close resources: Always close result sets, statements, and database connections when you're done with them. The defer keyword is useful for this.

5. Use transactions when necessary: For operations that require multiple steps, use transactions to ensure data consistency.

6. Be mindful of N+1 query problems: When using ORMs, be aware of the N+1 query problem and use eager loading when appropriate.

7. Use context for timeouts: Use context to set timeouts on database operations, especially for long-running queries.

Common pitfalls to avoid:

1. Ignoring SQL injection vulnerabilities: Always use parameterized queries or prepared statements.
2. Not handling connection errors: Check for and handle connection errors, implementing retry logic if necessary.
3. Overusing GORM hooks: While convenient, overusing GORM hooks can lead to hard-to-debug issues.
4. Not indexing properly: Ensure your database schema is properly indexed for your query patterns.
5. Storing sensitive data in plaintext: Always encrypt sensitive data before storing it in the database.

Conclusion

Go provides robust support for both SQL and NoSQL database interactions. Whether you prefer the low-level control of database/sql, the convenience of an ORM like GORM, or working with NoSQL databases like MongoDB, Go got it for you.

Atas ialah kandungan terperinci Interaksi Pangkalan Data dalam Go: Dari SQL ke NoSQL. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!