我是 PHP 程序员

package main

import (
    "context"
    "fmt"
    _ "github.com/go-sql-driver/mysql"
    "go.mongodb.org/mongo-driver/bson"
    "go.mongodb.org/mongo-driver/bson/primitive"
    "go.mongodb.org/mongo-driver/mongo"
    "go.mongodb.org/mongo-driver/mongo/options"
    "log"
)

// 定义一个结构体表示数据库中的数据
type User struct {
    ID    primitive.ObjectID `bson:"_id,omitempty"`
    Name  string
    Email string
}

func main() {
    // 设置 MongoDB 连接信息
    clientOptions := options.Client().ApplyURI("mongodb://192.168.1.100:27017")

    // 连接 MongoDB
    client, err := mongo.Connect(context.Background(), clientOptions)
    if err != nil {
       log.Fatal(err)
    }

    // 断开连接
    defer func() {
       if err = client.Disconnect(context.Background()); err != nil {
          log.Fatal(err)
       }
    }()

    // 获取数据库和集合
    database := client.Database("testdb")
    collection := database.Collection("users")

    // 创建一个用户
    user := User{
       Name:  "John Doe",
       Email: "john@example.com",
    }

    // 插入数据
    insertResult, err := collection.InsertOne(context.Background(), user)
    if err != nil {
       log.Fatal(err)
    }
    fmt.Println("Inserted a single document: ", insertResult.InsertedID)

    // 查询数据
    var result bson.M
    // 搜索条件，默认是等于。还可以 bson.M{"info.age": bson.M{"$gt": 25}}定义其他搜索方式
    // 如果要搜索嵌套对象中的字段，可以通过键路径访问，使用点符号 . 来访问嵌套字段，例如 nestedObject.fieldName。
    filter := bson.D{{"name", `John 12221`}}
    err = collection.FindOne(context.Background(), filter).Decode(&result)
    if err != nil {
       log.Fatal(err)
    }
    log.Println("result:", result)

    // 更新数据
    var existingUser User
    // 查询要更新的文档，用于输出
    err = collection.FindOne(context.Background(), filter).Decode(&existingUser)
    if err != nil {
       log.Fatal(err)
    }
    update := bson.D{
       {"$set", bson.D{
          {"name", "John 11111"},
       }},
    }
    updateResult, err := collection.UpdateOne(context.Background(), filter, update)
    if err != nil {
       log.Fatal(err)
    }
    if updateResult.ModifiedCount > 0 {
       if updateResult.UpsertedID != nil {
          fmt.Println("Updated document I1D:", updateResult.UpsertedID)
       } else {
          // 使用预先保存的文档数据
          fmt.Println("Updated document ID:", existingUser.ID.Hex())
       }
    }

    // 删除数据
    filter = bson.D{{"name", "john@newex1222ample.com"}}
    deleteResult, err := collection.DeleteOne(context.Background(), filter)
    if err != nil {
       log.Fatal(err)
    }
    fmt.Println("Deleted the document: ", deleteResult.DeletedCount)
}

package main

import (
    "context"
    "fmt"
    "log"

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

// 定义一个结构体表示数据库中的数据
type User struct {
    Name  string
    Email string
}

func main() {
    // 设置 MongoDB 连接信息
    clientOptions := options.Client().ApplyURI("mongodb://192.168.1.100:27017")

    // 连接 MongoDB
    client, err := mongo.Connect(context.Background(), clientOptions)
    if err != nil {
       log.Fatal(err)
    }

    // 断开连接
    defer func() {
       if err = client.Disconnect(context.Background()); err != nil {
          log.Fatal(err)
       }
    }()

    // 获取数据库和集合
    database := client.Database("testdb")
    collection := database.Collection("users")

    // 插入多个用户
    users := []interface{}{
       User{Name: "Alice", Email: "alice@example.com"},
       User{Name: "Bob", Email: "bob@example.com"},
       User{Name: "Charlie", Email: "charlie@example.com"},
    }

    insertManyResult, err := collection.InsertMany(context.Background(), users)
    if err != nil {
       log.Fatal(err)
    }
    fmt.Println("Inserted multiple documents: ", insertManyResult.InsertedIDs)

    // 查询多个数据
   // 搜索条件，默认是等于。还可以 bson.D{"info.age": bson.M{"$gt": 25}}定义其他搜索方式
  // 如果要搜索嵌套对象中的字段，可以通过键路径访问，使用点符号 . 来访问嵌套字段，例如 nestedObject.fieldName。
    findFilter := bson.D{{}}
    cursor, err := collection.Find(context.Background(), findFilter)
    if err != nil {
       log.Fatal(err)
    }
    defer cursor.Close(context.Background())

    var results []User
    if err = cursor.All(context.Background(), &results); err != nil {
       log.Fatal(err)
    }
    fmt.Println("Found multiple documents: ", results)

    //更新多个数据
    updateFilter := bson.D{{"name", "Alice"}}
    // 查询要更新的文档，用于输出
    cursor, err = collection.Find(context.Background(), updateFilter)
    if err != nil {
       log.Fatal(err)
    }
    update := bson.D{
       {"$set", bson.D{
          {"email", "122312@example.com"},
       }},
    }
    updateResult, err := collection.UpdateMany(context.Background(), updateFilter, update)
    if err != nil {
       log.Fatal(err)
    }

    if updateResult.ModifiedCount > 0 {
       if updateResult.UpsertedID != nil {
          fmt.Println("Updated document I1D:", updateResult.UpsertedID)
       } else {
          // 输出修改本次修改的文档ID
          for cursor.Next(context.Background()) {
             var result bson.M
             if err := cursor.Decode(&result); err != nil {
                log.Fatal(err)
             }
             // 获取文档的 _id 主键字段
             docID := result["_id"]
             fmt.Println("Document ID:", docID)
          }
          if err := cursor.Err(); err != nil {
             log.Fatal(err)
          }
       }
    }

    // 删除多个数据
    deleteFilter := bson.D{{"name", "Alice"}}
    deleteResult, err := collection.DeleteMany(context.Background(), deleteFilter)
    if err != nil {
       log.Fatal(err)
    }
    fmt.Println("Deleted documents: ", deleteResult.DeletedCount)
}