mgo驱动在Go语言中处理MongoDB嵌套文档与字段映射的指南

package main

import (
    "fmt"
    "log"
    "time"

    "gopkg.in/mgo.v2"
    "gopkg.in/mgo.v2/bson"
)

// Address represents a nested address document
type Address struct {
    Street string `bson:"street"`
    City   string `bson:"city"`
    Zip    string `bson:"zip"`
}

// User represents the main document
type User struct {
    ID        bson.ObjectId `bson:"_id,omitempty"`
    Name      string        `bson:"name"`
    Email     string        `bson:"email"`
    Location  Address       `bson:"location"` // Nested document
    CreatedAt time.Time     `bson:"createdAt"`
}

func main() {
    session, err := mgo.Dial("mongodb://localhost:27017")
    if err != nil {
        log.Fatalf("Failed to connect to MongoDB: %v", err)
    }
    defer session.Close()

    c := session.DB("testdb").C("users")

    // Example: Inserting a document with a nested field
    user := User{
        ID:    bson.NewObjectId(),
        Name:  "Alice",
        Email: "alice@example.com",
        Location: Address{
            Street: "123 Main St",
            City:   "Anytown",
            Zip:    "12345",
        },
        CreatedAt: time.Now(),
    }
    err = c.Insert(&user)
    if err != nil {
        log.Fatalf("Failed to insert user: %v", err)
    }
    fmt.Printf("Inserted user: %s\n", user.Name)

    // Example: Finding a document with a nested field
    var foundUser User
    err = c.Find(bson.M{"name": "Alice"}).One(&foundUser)
    if err != nil {
        log.Fatalf("Failed to find user: %v", err)
    }
    fmt.Printf("Found user: %s, from %s\n", foundUser.Name, foundUser.Location.City)
}

// ... (previous setup code)

// Example: Updating a nested field using dot notation
// We want to update only the city in the location without fetching and re-saving the whole user object
selector := bson.M{"name": "Alice"}
update := bson.M{"$set": bson.M{"location.city": "Newtown"}} // Dot notation for nested field

err = c.Update(selector, update)
if err != nil {
    log.Fatalf("Failed to update nested field: %v", err)
}
fmt.Println("Updated Alice's city to Newtown")

// Verify the update
var updatedUser User
err = c.Find(selector).One(&updatedUser)
if err != nil {
    log.Fatalf("Failed to find updated user: %v", err)
}
fmt.Printf("Alice's new city: %s\n", updatedUser.Location.City)

// Example: Removing a nested field (e.g., zip code)
removeUpdate := bson.M{"$unset": bson.M{"location.zip": ""}}
err = c.Update(selector, removeUpdate)
if err != nil {
    log.Fatalf("Failed to unset nested field: %v", err)
}
fmt.Println("Unset Alice's zip code")

// Verify the removal (zip will be empty in the struct)
var userAfterUnset User
err = c.Find(selector).One(&userAfterUnset)
if err != nil {
    log.Fatalf("Failed to find user after unset: %v", err)
}
fmt.Printf("Alice's zip after unset: '%s' (should be empty)\n", userAfterUnset.Location.Zip)

// Example: Document with a field named "timer" in MongoDB, but "Timer" in Go
type SensorData struct {
    ID        bson.ObjectId `bson:"_id,omitempty"`
    Value     float64       `bson:"value"`
    Timestamp time.Time     `bson:"timestamp"`
    // Go field "Timer" maps to MongoDB field "timer"
    Timer     int           `bson:"timer"`
}

func main() {
    // ... (session and collection setup)

    // Insert data
    sensorDoc := SensorData{
        ID:        bson.NewObjectId(),
        Value:     10.5,
        Timestamp: time.Now(),
        Timer:     120, // This will be stored as 'timer' in MongoDB
    }
    err = c.Insert(&sensorDoc)
    if err != nil {
        log.Fatalf("Failed to insert sensor data: %v", err)
    }
    fmt.Printf("Inserted sensor data with timer: %d\n", sensorDoc.Timer)

    // Retrieve data
    var retrievedSensorData SensorData
    err = c.Find(bson.M{"_id": sensorDoc.ID}).One(&retrievedSensorData)
    if err != nil {
        log.Fatalf("Failed to retrieve sensor data: %v", err)
    }
    // The 'timer' field from MongoDB is correctly mapped to 'retrievedSensorData.Timer'
    fmt.Printf("Retrieved sensor data timer: %d\n", retrievedSensorData.Timer)
}

// ... (session and collection setup)

// Insert a document with a flexible structure
flexDoc := bson.M{
    "name":    "Bob",
    "age":     30,
    "details": bson.M{"hobby": "coding", "level": "advanced"},
    "tags":    []string{"developer", "go", "mongodb"},
}
err = c.Insert(flexDoc)
if err != nil {
    log.Fatalf("Failed to insert flexible document: %v", err)
}
fmt.Println("Inserted flexible document for Bob")

// Retrieve the document as a map[string]interface{}
var result map[string]interface{}
err = c.Find(bson.M{"name": "Bob"}).One(&result)
if err != nil {
    log.Fatalf("Failed to retrieve flexible document: %v", err)
}

fmt.Println("Retrieved flexible document:")
for key, value := range result {
    fmt.Printf("  %s: %v (%T)\n", key, value, value)
}

// Accessing nested fields and performing type assertions
if details, ok := result["details"].(map[string]interface{}); ok {
    if hobby, ok := details["hobby"].(string); ok {
        fmt.Printf("Bob's hobby: %s\n", hobby)
    }
}

if tags, ok := result["tags"].([]interface{}); ok {
    fmt.Print("Bob's tags: ")
    for _, tag := range tags {
        if s, ok := tag.(string); ok {
            fmt.Printf("%s ", s)
        }
    }
    fmt.Println()
}