golang mongodb query

In recent years, the usage rate of Golang has become higher and higher, especially in big data scenarios, more and more developers have begun to use Golang to implement their applications. As a high-performance, document-oriented database, MongoDB is also liked and used by more and more people. This article will introduce how to use MongoDB for query in Golang.

First, we need to introduce the MongoDB driver package into Golang, as shown below:

import "go.mongodb.org/mongo-driver/mongo"
import "go.mongodb.org/mongo-driver/mongo/options"

Next, we need to establish a MongoDB connection. The following is sample code:

func ConnectMongo(uri string) (*mongo.Client, error) {
    client, err := mongo.NewClient(options.Client().ApplyURI(uri))
    if err != nil {
        return nil, err
    }
    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()
    err = client.Connect(ctx)
    if err != nil {
        return nil, err
    }
    return client, nil
}

where uri is the connection string for the MongoDB database. We establish a MongoDB connection in the ConnectMongo function and return an instance of mongo.Client.

Then you can perform query operations. The following is a simple query example. In this example, we query the users collection in the test database to find all users whose gender is male:

func FindMaleUsers(client *mongo.Client) ([]bson.M, error) {
    collection := client.Database("test").Collection("users")

    filter := bson.M{"sex": "male"}

    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()

    cursor, err := collection.Find(ctx, filter)
    if err != nil {
        return nil, err
    }

    var results []bson.M
    if err = cursor.All(ctx, &results); err != nil {
        return nil, err
    }
    return results, nil
}

In the above code, we first obtain the users collection in the test database, and then use the bson.M type structure to define the query conditions, that is, gender for men. Next, we use the ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second) function to create a context and suspend its cancellation function to limit the query operation time and allow for timely release of resources.

Then we use the collection.Find(ctx, filter) function to query the database, where ctx is the context created above, filter is the query condition and a cursor cursor is returned.

Finally, we convert this cursor into a bson.M array through the cursor.All(ctx, &results) function, where &results Indicates that the address of the result is passed to this function for operation.

In addition to the above query operations, there are some other query methods, such as:

1. Exact match

In MongoDB, we can use bson. D to represent the complete matching condition.

The following is a sample code:

func FindByCondition(client *mongo.Client) ([]bson.M, error) {
    collection := client.Database("test").Collection("users")

    filter := bson.D{
        {"cond1", value1},
        {"cond2", value2},
        ...
    }

    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()

    cursor, err := collection.Find(ctx, filter)
    if err != nil {
        return nil, err
    }

    var results []bson.M
    if err = cursor.All(ctx, &results); err != nil {
        return nil, err
    }
    return results, nil
}

In the above code, we use bson.D to fully match the query conditions, where {"cond1" , value1} and {“cond2”, value2} respectively represent key-value pairs in MongoDB.

2. Regular matching

In MongoDB, we can use regular expressions for query operations. The following is a sample code:

func FindByRegex(client *mongo.Client) ([]bson.M, error) {
    collection := client.Database("test").Collection("users")

    filter := bson.M{
        "field": bson.M{"$regex": "pattern"},
    }

    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()

    cursor, err := collection.Find(ctx, filter)
    if err != nil {
        return nil, err
    }

    var results []bson.M
    if err = cursor.All(ctx, &results); err != nil {
        return nil, err
    }
    return results, nil
}

In the above code, we use $regex to represent the regular expression, where "pattern" is the regular expression string .

Finally, after using MongoDB, we need to close the database connection to release related resources. The following is a sample code:

func CloseMongo(client *mongo.Client) error {
    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()
    return client.Disconnect(ctx)
}

Through the above code, we can easily use MongoDB in Golang for query operations. Whether it is exact matching or regular matching, we can easily achieve it through the MongoDB driver package. At the same time, after use, the database connection must be closed promptly to release resources.

The above is the detailed content of golang mongodb query. For more information, please follow other related articles on the PHP Chinese website!