go get go.mongodb.org/mongo-driver/mongo

module mongodb-demo

go 1.21

require go.mongodb.org/mongo-driver v1.13.1

package main

import (
    "context"
    "fmt"
    "log"
    "net/url"
    "time"

    "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"
    "go.mongodb.org/mongo-driver/mongo/readpref"
)

// User defines the user document structure.
type User struct {
    ID        primitive.ObjectID `bson:"_id,omitempty"`
    Username  string             `bson:"username"`
    Age       int                `bson:"age"`
    Email     string             `bson:"email"`
    CreatedAt time.Time          `bson:"created_at"`
}

func main() {
    // Connection URI (Replace with your actual connection information)
    // If the password contains special characters, use url.QueryEscape() to encode it.
    user := "mongouser"
    password := url.QueryEscape("thepasswordA1")
    host := "10.66.187.127:27017"
    uri := fmt.Sprintf("mongodb://%s:%s@%s/admin", user, password, host)

    // Replica set connection string (Recommended):
    // uri := fmt.Sprintf("mongodb://%s:%s@IP1:27017,IP2:27017,IP3:27017/admin?replicaSet=cmgo-xxxxxxxx_0", user, password)

    // Configure connection parameters
    clientOpts := options.Client().
        ApplyURI(uri).
        SetMaxPoolSize(50).                               // Maximum size of the connection pool
        SetMinPoolSize(5).                                 // Minimum size of the connection pool
        SetConnectTimeout(10 * time.Second).               // Connection timeout
        SetSocketTimeout(30 * time.Second).                // Socket timeout
        SetMaxConnIdleTime(60 * time.Second).              // Idle connection timeout
        SetRetryWrites(true).                              // Enable retryable writes
        SetRetryReads(true)                                // Enable retryable reads

    // Establish a connection.
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()

    client, err := mongo.Connect(ctx, clientOpts)
    if err != nil {
        log.Fatalf("Connection failure: %v", err)
    }
    defer func() {
        if err := client.Disconnect(context.Background()); err != nil {
            log.Printf("Disconnection failure: %v", err)
        }
        fmt.Println("Connection closed")
    }()

    // Verify the connection
    if err := client.Ping(ctx, readpref.Primary()); err != nil {
        log.Fatalf("Ping failure: %v", err)
    }
    fmt.Println("Connection successful")

    // Select a database and a collection.
    collection := client.Database("mydb").Collection("users")

    // ========== Insert a Document ==========
    user1 := User{
        Username:  "jack",
        Age:       31,
        Email:     "jack@example.com",
        CreatedAt: time.Now(),
    }
    insertResult, err := collection.InsertOne(context.Background(), user1)
    if err != nil {
        log.Fatalf("Insertion failure: %v", err)
    }
    fmt.Printf("Inserted document ID: %v\\n", insertResult.InsertedID)

    // Batch Insert
    users := []interface{}{
        User{Username: "alice", Age: 28, Email: "alice@example.com", CreatedAt: time.Now()},
        User{Username: "bob", Age: 35, Email: "bob@example.com", CreatedAt: time.Now()},
    }
    insertManyResult, err := collection.InsertMany(context.Background(), users)
    if err != nil {
        log.Fatalf("Batch insertion failure: %v", err)
    }
    fmt.Printf("Batch inserted %d documents\\n", len(insertManyResult.InsertedIDs))

    // ========== Query Documents ==========
    var foundUser User
    err = collection.FindOne(context.Background(), bson.M{"username": "jack"}).Decode(&foundUser)
    if err != nil {
        log.Fatalf("Query failure: %v", err)
    }
    fmt.Printf("Query a single document: %+v\\n", foundUser)

    // Conditional Query (Age greater than 30)
    cursor, err := collection.Find(context.Background(), bson.M{"age": bson.M{"$gt": 30}})
    if err != nil {
        log.Fatalf("Conditional query failure: %v", err)
    }
    defer cursor.Close(context.Background())

    fmt.Println("Users with age greater than 30:")
    for cursor.Next(context.Background()) {
        var u User
        if err := cursor.Decode(&u); err != nil {
            log.Printf("Decoding failure: %v", err)
            continue
        }
        fmt.Printf("  - %s, Age: %d\\n", u.Username, u.Age)
    }

    // ========== Update Documents ==========
    updateResult, err := collection.UpdateOne(
        context.Background(),
        bson.M{"username": "jack"},
        bson.M{"$set": bson.M{"age": 32}},
    )
    if err != nil {
        log.Fatalf("Update failure: %v", err)
    }
    fmt.Printf("Updated %d documents\\n", updateResult.ModifiedCount)

    // ========== Delete Documents ==========
    deleteResult, err := collection.DeleteMany(
        context.Background(),
        bson.M{"username": bson.M{"$in": bson.A{"jack", "alice", "bob"}}},
    )
    if err != nil {
        log.Fatalf("Deletion failure: %v", err)
    }
    fmt.Printf("Deleted %d documents\\n", deleteResult.DeletedCount)
}

Connection successful
Inserted document ID: ObjectID("6789abcdef1234567890abcd")
Batch Insert 2 Documents
Query a single document: {ID:ObjectID("6789abcdef1234567890abcd") Username:jack Age:31 Email:jack@example.com CreatedAt:2026-04-17 15:00:00 +0800 CST}
Users with age greater than 30:
  - jack, age: 31
  - bob, age: 35
Update 1 Document
Delete 3 Documents
The connection has been closed.

server selection error: context deadline exceeded, current topology: { Type: Unknown, Servers: [{ Addr: 10.66.187.127:27017, Type: Unknown, Last error: connection() error occurred during connection handshake: auth error: sasl conversation error: unable to authenticate using mechanism "SCRAM-SHA-1" }, ] }

context deadline exceeded

cannot find module providing package go.mongodb.org/mongo-driver/mongo

go mod init <module-name>

go get go.mongodb.org/mongo-driver/mongo