배열의 객체에 대해 Atlas Search 쿼리를 실행하는 방법

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
}