How to Run Atlas Search Queries Against Fields in Embedded Documents

1
using MongoDB.Bson;
2
using MongoDB.Bson.Serialization.Attributes;
3
using MongoDB.Bson.Serialization.Conventions;
4
using MongoDB.Driver;
5
using MongoDB.Driver.Search;
6
7
public class NestedArrayExample
8
{
9
    private const string MongoConnectionString = "<connection-string>";
10
11
    public static void Main(string[] args)
12
    {
13
        // allow automapping of the camelCase database fields to our SchoolDocument
14
        var camelCaseConvention = new ConventionPack { new CamelCaseElementNameConvention() };
15
        ConventionRegistry.Register("CamelCase", camelCaseConvention, type => true);
16
17
        // connect to your Atlas cluster
18
        var mongoClient = new MongoClient(MongoConnectionString);
19
        var districtSchoolsDatabase = mongoClient.GetDatabase("local_school_district");
20
        var schoolsCollection = districtSchoolsDatabase.GetCollection<SchoolDocument>("schools");
21
22
        // define variables for query 
23
        var compoundQuery = Builders<TeacherDocument>.Search.Compound()
24
            .Must(Builders<TeacherDocument>.Search.Text(teacher => teacher.First, "John"))
25
            .Should(Builders<TeacherDocument>.Search.Text(teacher => teacher.Last, "Smith"));
26
        var opts = new SearchHighlightOptions<SchoolDocument>(school => school.Teachers.Select(teacher => teacher.Last));;
27
28
        // define and run pipeline
29
        var results = schoolsCollection.Aggregate()
30
            .Search(Builders<SchoolDocument>.Search.EmbeddedDocument(
31
                school => school.Teachers, compoundQuery), opts,
32
                indexName: "embedded-documents-tutorial"
33
            )
34
            .Project<SchoolDocument>(Builders<SchoolDocument>.Projection
35
                .Include(school => school.Name)
36
                .Include(school => school.Mascot)
37
                .Include(school => school.Teachers)
38
                .MetaSearchScore(school => school.Score)
39
                .MetaSearchHighlights("highlights"))
40
            .ToList();
41
42
        // print results
43
        foreach (var school in results)
44
        {
45
            Console.WriteLine(school.ToJson());
46
        }
47
    }
48
}
49
50
[BsonIgnoreExtraElements]
51
public class SchoolDocument
52
{
53
    public int Id { get; set; }
54
    public string Name { get; set; }
55
    public string Mascot { get; set; }
56
    public TeacherDocument[] Teachers { get; set; }
57
    [BsonElement("highlights")]
58
    public List<SearchHighlight> Highlights { get; set; }
59
    public double Score { get; set; }
60
}
61
62
[BsonIgnoreExtraElements]
63
public class TeacherDocument
64
{
65
    public string First { get; set; }
66
    public string Last { get; set; }
67
    public ClassDocument[] Classes { get; set; }
68
}
69
70
[BsonIgnoreExtraElements]
71
public class ClassDocument
72
{
73
    public string Subject { get; set; }
74
    public string Grade { get; set; }
75
}

1
using MongoDB.Bson;
2
using MongoDB.Bson.Serialization.Attributes;
3
using MongoDB.Bson.Serialization.Conventions;
4
using MongoDB.Driver;
5
using MongoDB.Driver.Search;
6
using System;
7
using System.Collections.Generic;
8
using System.Reflection.Emit;
9
10
public class NestedArrayWithinObjectExample
11
{
12
    private const string MongoConnectionString = "<connection-string>";
13
14
    public static void Main(string[] args)
15
    {
16
        // allow automapping of the camelCase database fields to our SchoolDocument
17
        var camelCaseConvention = new ConventionPack { new CamelCaseElementNameConvention() };
18
        ConventionRegistry.Register("CamelCase", camelCaseConvention, type => true);
19
20
        // connect to your Atlas cluster
21
        var mongoClient = new MongoClient(MongoConnectionString);
22
        var districtSchoolsDatabase = mongoClient.GetDatabase("local_school_district");
23
        var schoolsCollection = districtSchoolsDatabase.GetCollection<SchoolDocument>("schools");
24
25
        // define variables for query 
26
        var queryStringQuery = Builders<ExtraCurricularDocument>.Search.QueryString(
27
            sport => sport.ClubName, "dodgeball OR frisbee"
28
        );
29
30
        // define and run pipeline
31
        var results = schoolsCollection.Aggregate()
32
            .Search(Builders<SchoolDocument>.Search.EmbeddedDocument(
33
                school => school.Clubs.Sports, queryStringQuery),
34
                indexName: "embedded-documents-tutorial"
35
            )
36
            .Project<SchoolDocument>(Builders<SchoolDocument>.Projection
37
                .Include(school => school.Clubs)
38
                .Include(school => school.Name)
39
                .Include(school => school.Id)
40
                .MetaSearchScore(school => school.Score))
41
            .ToList();
42
43
        // print results
44
        foreach (var school in results)
45
        {
46
            Console.WriteLine(school.ToJson());
47
        }
48
    }
49
}
50
51
[BsonIgnoreExtraElements]
52
public class SchoolDocument
53
{
54
    public int Id { get; set; }
55
    public string Name { get; set; }
56
    public ClubDocument Clubs { get; set; } 
57
    public double Score { get; set; }
58
}
59
60
[BsonIgnoreExtraElements]
61
public class ClubDocument
62
{
63
    public ExtraCurricularDocument[] Sports { get; set; }
64
}
65
66
[BsonIgnoreExtraElements]
67
public class ExtraCurricularDocument
68
{
69
    [BsonElement("club_name")]
70
    public string ClubName { get; set; }
71
    public string Description { get; set; }
72
}

1
using MongoDB.Bson;
2
using MongoDB.Bson.Serialization.Attributes;
3
using MongoDB.Bson.Serialization.Conventions;
4
using MongoDB.Driver;
5
using MongoDB.Driver.Search;
6
7
public class NestedArrayWithinArrayExample
8
{
9
    private const string MongoConnectionString = "<connection-string>";
10
11
    public static void Main(string[] args)
12
    {
13
        // allow automapping of the camelCase database fields to our SchoolDocument
14
        var camelCaseConvention = new ConventionPack { new CamelCaseElementNameConvention() };
15
        ConventionRegistry.Register("CamelCase", camelCaseConvention, type => true);
16
17
        // connect to your Atlas cluster
18
        var mongoClient = new MongoClient(MongoConnectionString);
19
        var districtSchoolsDatabase = mongoClient.GetDatabase("local_school_district");
20
        var schoolsCollection = districtSchoolsDatabase.GetCollection<SchoolDocument>("schools");
21
22
        // define variables for query 
23
        var mustQuery = Builders<ClassDocument>.Search.Compound()
24
            .Must(Builders<ClassDocument>.Search.Text(classes => classes.Grade, "12th"), Builders<ClassDocument>.Search.Text(classes => classes.Subject, "science"));
25
        var compoundQuery = Builders<TeacherDocument>.Search.Compound()
26
            .Must(Builders<TeacherDocument>.Search.EmbeddedDocument(teacher => teacher.Classes, mustQuery))
27
            .Should(Builders<TeacherDocument>.Search.Text(teacher => teacher.Last, "smith"));
28
        var opts = new SearchHighlightOptions<SchoolDocument>("teachers.classes.subject");
29
30
        // define and run pipeline
31
        var results = schoolsCollection.Aggregate()
32
            .Search(Builders<SchoolDocument>.Search.EmbeddedDocument(
33
                school => school.Teachers, compoundQuery), opts,
34
                indexName: "embedded-documents-tutorial"
35
            )
36
            .Project<SchoolDocument>(Builders<SchoolDocument>.Projection
37
                .Include(school => school.Teachers)
38
                .MetaSearchScore(school => school.Score)
39
                .MetaSearchHighlights("highlights"))
40
            .ToList();
41
42
        // print results
43
        foreach (var school in results)
44
        {
45
            Console.WriteLine(school.ToJson());
46
        }
47
    }
48
}
49
50
[BsonIgnoreExtraElements]
51
public class SchoolDocument
52
{
53
    public int Id { get; set; }
54
    public TeacherDocument[] Teachers { get; set; }
55
    [BsonElement("highlights")]
56
    public List<SearchHighlight> Highlights { get; set; }
57
    public double Score { get; set; }
58
}
59
60
[BsonIgnoreExtraElements]
61
public class TeacherDocument
62
{
63
    public string First { get; set; }
64
    public string Last { get; set; }
65
    public ClassDocument[] Classes { get; set; }
66
}
67
68
[BsonIgnoreExtraElements]
69
public class ClassDocument
70
{
71
    public string Subject { get; set; }
72
    public string Grade { get; set; }
73
}

1
package main
2
3
import (
4
	"context"
5
	"fmt"
6
7
	"go.mongodb.org/mongo-driver/v2/bson"
8
	"go.mongodb.org/mongo-driver/v2/mongo"
9
	"go.mongodb.org/mongo-driver/v2/mongo/options"
10
)
11
12
func main() {
13
	// Connects to your Atlas cluster
14
	client, err := mongo.Connect(options.Client().ApplyURI("<connection-string>"))
15
	if err != nil {
16
		panic(err)
17
	}
18
	defer client.Disconnect(context.TODO())
19
20
	// Sets the namespace
21
	collection := client.Database("local_school_district").Collection("schools")
22
23
	searchStage := bson.D{{Key: "$search", Value: bson.M{
24
		"index": "embedded-documents-tutorial",
25
		"embeddedDocument": bson.M{
26
			"path": "teachers", "operator": bson.M{
27
				"compound": bson.M{
28
					"must": bson.A{
29
						bson.M{
30
							"text": bson.D{
31
								{Key: "path", Value: "teachers.first"},
32
								{Key: "query", Value: "John"},
33
							},
34
						},
35
					},
36
					"should": bson.A{
37
						bson.M{
38
							"text": bson.D{
39
								{Key: "path", Value: "teachers.last"},
40
								{Key: "query", Value: "Smith"},
41
							},
42
						},
43
					},
44
				},
45
			},
46
		},
47
		"highlight": bson.D{{Key: "path", Value: "teachers.last"}},
48
	}}}
49
50
	projectStage := bson.D{
51
		{Key: "$project", Value: bson.D{
52
			{Key: "teachers", Value: 1},
53
			{Key: "score", Value: bson.D{{Key: "$meta", Value: "searchScore"}}},
54
			{Key: "highlights", Value: bson.D{{Key: "$meta", Value: "searchHighlights"}}},
55
		}},
56
	}
57
58
	// Runs the pipeline
59
	cursor, err := collection.Aggregate(context.TODO(), mongo.Pipeline{searchStage, projectStage})
60
	if err != nil {
61
		panic(err)
62
	}
63
64
	// Prints the results
65
	var results []bson.D
66
	if err = cursor.All(context.TODO(), &results); err != nil {
67
		panic(err)
68
	}
69
	for _, result := range results {
70
		fmt.Println(result)
71
	}
72
}