golang query mongo

Golang is a fast, concise, safe and efficient programming language that has received widespread attention and application. MongoDB is a schema-less, document-based database and is one of the preferred databases for modern applications. The combination of Golang and MongoDB can bring many benefits to developers. In this article, we will explore how to use Golang to query MongoDB.

First, we need to understand some basic knowledge of MongoDB. MongoDB's data storage method is a document, and a document is a collection of key-value pairs. Here is an example document:

{
   "_id": ObjectId("507f1f77bcf86cd799439011"),
   "name": "John",
   "age": 25,
   "city": "New York",
   "phone": {
       "office": "123-456-7890",
       "home": "987-654-3210"
   },
   "email": "john@example.com",
   "interests": ["swimming", "reading", "traveling"]
}

The document has a unique identifier "_id", and other key-value pairs. Values ​​can be simple types, such as strings, numeric values, Boolean values, etc., or complex data types, such as arrays, nested documents, etc. For more information about MongoDB, see MongoDB’s official documentation.

Next, we will learn how to use Golang to query MongoDB. We will use the official MongoDB Go driver (mongo-go-driver) for our examples. This driver provides a feature-rich set of tools to easily interact with MongoDB.

First, we need to install mongo-go-driver:

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

Then, we can use the following code to establish a connection to MongoDB:

package main

import (
    "context"
    "fmt"
    "go.mongodb.org/mongo-driver/mongo"
    "go.mongodb.org/mongo-driver/mongo/options"
)

func main() {
    // 设置客户端选项
    clientOptions := options.Client().ApplyURI("mongodb://localhost:27017")

    // 连接到MongoDB
    client, err := mongo.Connect(context.Background(), clientOptions)
    if err != nil {
        fmt.Println("连接到MongoDB时出错：", err)
    }

    // 断开与MongoDB的连接
    defer func() {
        if err = client.Disconnect(context.Background()); err != nil {
            panic(err)
        }
    }()
}

In the above code , we first create client options using the options.Client() method. Here we specify to connect to the local MongoDB service, the port is 27017. Then, we use the mongo.Connect() method to connect to MongoDB and check if there are any errors. Finally, we use the client.Disconnect() method to disconnect from MongoDB.

Now that we have established a connection to MongoDB, we will look at some common query operations.

1. Find all documents

We can use the Collection.Find() method to find all documents matching the given conditions. The following is an example:

collection := client.Database("myDatabase").Collection("myCollection")
cursor, err := collection.Find(context.Background(), bson.D{})
if err != nil {
    fmt.Println("查询文档时出错：", err)
}
defer cursor.Close(context.Background())

for cursor.Next(context.Background()) {
    var doc bson.M
    if err := cursor.Decode(&doc); err != nil {
        fmt.Println("解码文档时出错：", err)
    }
    fmt.Println(doc)
}

if err := cursor.Err(); err != nil {
    fmt.Println("游标错误：", err)
}

In the above code, we first obtain the collection (Collection) object and use the Find() method to find it. Cursors for all documents are returned. If an error occurs, error information is output to the console. We then decode each document using the cursor's Decode() method and print it to the console.

2. Limit the number of documents returned

We can use the Limit() function of the Find() method to limit the number of documents returned. Here is an example:

cursor, err := collection.Find(context.Background(), bson.D{}, options.Find().SetLimit(2))
if err != nil {
    fmt.Println("查询文档时出错：", err)
}

Here we specify that only two documents will be returned. You can change this number as needed.

3. Only return the specified fields

We can use the Find() method’s Project() function to only return the specified fields. Here is an example:

cursor, err := collection.Find(context.Background(), bson.D{}, options.Find().SetProjection(bson.D{{"name", 1}, {"age", 1}}))
if err != nil {
    fmt.Println("查询文档时出错：", err)
}

Here we specify that only the "name" and "age" fields are returned.

4. Query based on specific conditions

We can use the Filter() function of the Find() method to query based on specific conditions. The following is an example:

cursor, err := collection.Find(context.Background(), bson.D{{"age", bson.D{{"$gt", 20}}}})
if err != nil {
    fmt.Println("查询文档时出错：", err)
}

Here we specify to find all documents with "age" greater than 20.

5. Using regular expressions

We can use values ​​of type bson.RegEx to perform fuzzy queries using regular expressions. Here is an example:

cursor, err := collection.Find(context.Background(), bson.D{{"name", bson.Regex{Pattern: "jo", Options: ""}}})
if err != nil {
    fmt.Println("查询文档时出错：", err)
}

Here we specify to find all documents that contain "jo" in the "name" field.

6. Sorting query results

We can use the Sort() function of the Find() method to sort the query results according to specific conditions. Here is an example:

cursor, err := collection.Find(context.Background(), bson.D{}, options.Find().SetSort(bson.D{{"age", 1}}))
if err != nil {
    fmt.Println("查询文档时出错：", err)
}

Here we specify that the query results are sorted in ascending order (1) of the "age" field.

7. Using the aggregation pipeline

For more complex queries, we can use MongoDB's aggregation framework. The following is an example containing an aggregation pipeline:

pipeline := bson.A{
    bson.D{{"$match", bson.D{{"age", bson.D{{"$gt", 20}}}}}},
    bson.D{{"$group", bson.D{{"_id", "$city"}, {"count", bson.D{{"$sum", 1}}}}}},
    bson.D{{"$sort", bson.D{{"count", -1}}}},
}

cursor, err := collection.Aggregate(context.Background(), pipeline)
if err != nil {
    fmt.Println("聚合查询时出错：", err)
}

Here we specify the aggregation pipeline using the bson.A type, which contains three stages: $matchmatch,$groupGroup and $sortSort. The pipeline will find all documents with age greater than 20, group them by city, and count the number of documents for each group. Finally, the results are sorted in descending order of document count.

Proficient in these MongoDBGolang query operations can enable developers to process data in MongoDB more effectively and improve development efficiency. At the same time, you can also use other MongoDB functions, including indexing, updating, deleting, etc.

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