How to Run Atlas Search Queries Against Objects in Arrays

1
[
2
  {
3
    _id: 1,
4
    teachers: [
5
      {
6
        first: 'Jane',
7
        last: 'Earwhacker',
8
        classes: [
9
          { subject: 'art', grade: '9th' },
10
          { subject: 'science', grade: '12th' }
11
        ]
12
      },
13
      {
14
        first: 'John',
15
        last: 'Smith',
16
        classes: [
17
          { subject: 'math', grade: '12th' },
18
          { subject: 'art', grade: '10th' }
19
        ]
20
      }
21
    ],
22
    score: 0.7830756902694702,
23
    highlights: [
24
      {
25
        score: 1.4921371936798096,
26
        path: 'teachers.last',
27
        texts: [ { value: 'Smith', type: 'hit' } ]
28
      }
29
    ]
30
  },
31
  {
32
    _id: 2,
33
    teachers: [
34
      {
35
        first: 'Jane',
36
        last: 'Smith',
37
        classes: [
38
          { subject: 'science', grade: '9th' },
39
          { subject: 'math', grade: '12th' }
40
        ]
41
      },
42
      {
43
        first: 'John',
44
        last: 'Redman',
45
        classes: [ { subject: 'art', grade: '12th' } ]
46
      }
47
    ],
48
    score: 0.468008816242218,
49
    highlights: [
50
      {
51
        score: 1.4702850580215454,
52
        path: 'teachers.last',
53
        texts: [ { value: 'Smith', type: 'hit' } ]
54
      }
55
    ]
56
  }
57
]

1
[
2
  {
3
    _id: 2,
4
    name: 'Lincoln High',
5
    clubs: {
6
      sports: [
7
        {
8
          club_name: 'dodgeball',
9
          description: 'provides students an opportunity to play dodgeball by throwing balls to eliminate the members of the opposing team while avoiding being hit themselves.'
10
        },
11
        {
12
          club_name: 'martial arts',
13
          description: 'provides students an opportunity to learn self-defense or combat that utilize physical skill and coordination without weapons.'
14
        }
15
      ]
16
    },
17
    score: 0.633669912815094
18
  },
19
  {
20
    _id: 1,
21
    name: 'Evergreen High',
22
    clubs: {
23
      sports: [
24
        {
25
          club_name: 'archery',
26
          description: 'provides students an opportunity to practice and hone the skill of using a bow to shoot arrows in a fun and safe environment.'
27
        },
28
        {
29
          club_name: 'ultimate frisbee',
30
          description: 'provides students an opportunity to play frisbee and learn the basics of holding the disc and complete passes.'
31
        }
32
      ]
33
    },
34
    score: 0.481589138507843
35
  }
36
]

1
[
2
  {
3
    _id: 0,
4
    teachers: [
5
      {
6
        first: 'Jane',
7
        last: 'Smith',
8
        classes: [
9
          { subject: 'art of science', grade: '12th' },
10
          {
11
            subject: 'applied science and practical science',
12
            grade: '9th'
13
          },
14
          { subject: 'remedial math', grade: '12th' },
15
          { subject: 'science', grade: '10th' }
16
        ]
17
      },
18
      {
19
        first: 'Bob',
20
        last: 'Green',
21
        classes: [
22
          { subject: 'science of art', grade: '11th' },
23
          { subject: 'art art art', grade: '10th' }
24
        ]
25
      }
26
    ],
27
    score: 0.9415585994720459,
28
    highlights: [
29
      {
30
        score: 0.7354040145874023,
31
        path: 'teachers.classes.subject',
32
        texts: [
33
          { value: 'art of ', type: 'text' },
34
          { value: 'science', type: 'hit' }
35
        ]
36
      },
37
      {
38
        score: 0.7871346473693848,
39
        path: 'teachers.classes.subject',
40
        texts: [
41
          { value: 'applied ', type: 'text' },
42
          { value: 'science', type: 'hit' },
43
          { value: ' and practical ', type: 'text' },
44
          { value: 'science', type: 'hit' }
45
        ]
46
      },
47
      {
48
        score: 0.7581484317779541,
49
        path: 'teachers.classes.subject',
50
        texts: [ { value: 'science', type: 'hit' } ]
51
      },
52
      {
53
        score: 0.7189631462097168,
54
        path: 'teachers.classes.subject',
55
        texts: [
56
          { value: 'science', type: 'hit' },
57
          { value: ' of art', type: 'text' }
58
        ]
59
      }
60
    ]
61
  },
62
  {
63
    _id: 1,
64
    teachers: [
65
      {
66
        first: 'Jane',
67
        last: 'Earwhacker',
68
        classes: [
69
          { subject: 'art', grade: '9th' },
70
          { subject: 'science', grade: '12th' }
71
        ]
72
      },
73
      {
74
        first: 'John',
75
        last: 'Smith',
76
        classes: [
77
          { subject: 'math', grade: '12th' },
78
          { subject: 'art', grade: '10th' }
79
        ]
80
      }
81
    ],
82
    score: 0.7779859304428101,
83
    highlights: [
84
      {
85
        score: 1.502043604850769,
86
        path: 'teachers.classes.subject',
87
        texts: [ { value: 'science', type: 'hit' } ]
88
      }
89
    ]
90
  }
91
]

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