Golang uses Mongo driver operation - query (basic)

Regardless of any database , Checking is the most complicated operation .

The basic query , And it is resolved into a structure ：

//  The most basic query , One query condition is enough , Reference resources ：https://www.mongodb.com/docs/manual/tutorial/query-documents/
func Find(mongo *mongo.Database, ctx context.Context) {
    
	baseAdd := create.BaseAdd{
    }

	filter := bson.M{
    } //  Empty structure matches all 
	//  Query data , And parse it into a structure 
	err := mongo.Collection("test").FindOne(ctx, filter).Decode(&baseAdd)
	if err != nil {
    
		fmt.Println("err")
	}

	fmt.Println(baseAdd)
}

Match multiple values , And it is parsed into a structure array ：

//  use $in Keyword query has multiple values 
func FindIn(mongo *mongo.Database, ctx context.Context) {
    
	filter := bson.M{
    "int32": bson.M{
    "$in": bson.A{
    math.MaxInt32, math.MaxInt32 - 1}}}
	cur, err := mongo.Collection("test").Find(ctx, filter)
	if err != nil {
    
		fmt.Println("err")
	}
	//  Methods for parsing multiple document arrays 
	var baseAdd []create.BaseAdd
	err = cur.All(ctx, &baseAdd)
	fmt.Println(err)
	fmt.Println(baseAdd)
}

Matching queries greater than and equal to , And traverse the results ：

//  use gt and lt Keyword query greater than and less than , Add a e Is equal to 
func FindGteAndLte(mongo *mongo.Database, ctx context.Context) {
    
	//  Multiple conditions are implicit and Relationship , It means that all conditions must be met at the same time 
	filter := bson.M{
    "int32": bson.M{
    "$gte": math.MaxInt32 - 1, "$lt": math.MaxInt32}}
	cur, err := mongo.Collection("test").Find(ctx, filter)
	if err != nil {
    
		fmt.Println("err")
	}
	//  Traversal data 
	for cur.TryNext(ctx) {
    
		result, _ := cur.Current.Elements()
		fmt.Println(result)
	}
	cur.Close(ctx)
}

Usually our query conditions are implicit and Relationship , have access to or Keyword indicates that only one of several conditions needs to be satisfied ：

	// or The corresponding is an array , As long as any condition in the array is satisfied 
	filter := bson.M{
    "$or": bson.A{
    bson.M{
    "int32": bson.M{
    "$gte": math.MaxInt32 - 1}}, bson.M{
    "int32": bson.M{
    "$lt": math.MaxInt32}}}}

Query matching of nested fields :

filter := bson.M{
    "object.id": 2} //  Just connect directly with points , No difference 

In the previous queries, we returned all fields , You can also choose to query the specified fields :

	// 1 Means only query id Field , however , Primary key _id It will be queried by default 
	options := options.FindOptions{
    Projection: bson.M{
    "id": 1}}
	//  So we can add "_id": 0 Exclude primary key 
	options := options.FindOptions{
    Projection: bson.M{
    "id": 1, "_id": 0}} 

Contrary to the above , You can specify a field not to , Query remaining fields :

	//  exclude _id, All other fields will be found , Multiple... Can be excluded 
	options := options.FindOptions{
    Projection: bson.M{
    "_id": 0}}

The same is true for nested documents , And use LookupErr Ergodic time , Just get what you want key value :

//  The same is true for nested documents 
func FindChildField(mongo *mongo.Database, ctx context.Context) {
    
	filter := bson.M{
    } //  Empty structure matches all 
	//  The same is true for nested fields 
	options := options.FindOptions{
    Projection: bson.M{
    "object.id": 1, "_id": 0}}

	cur, err := mongo.Collection("test").Find(ctx, filter, &options)
	if err != nil {
    
		fmt.Println("err")
	}
	//  Traversal data 
	for cur.TryNext(ctx) {
    
		result, _ := cur.Current.LookupErr("object")
		fmt.Println(result)
	}
	cur.Close(ctx)
}