$rankFunction（集計）

1
db.embedded_movies.aggregate( [
2
   {
3
      $rankFusion: {
4
         input: {
5
            pipelines: {
6
               searchOne: [
7
                  {
8
                     "$vectorSearch": {
9
                        "index": "<INDEX_NAME>",
10
                        "path": "<FIELD_NAME>",
11
                        "queryVector": <QUERY_EMBEDDINGS>,
12
                        "numCandidates": 500,
13
                        "limit": 20
14
                     }
15
                  }
16
               ],
17
               searchTwo: [
18
                  {
19
                     "$search": {
20
                        "index": "<INDEX_NAME>",
21
                        "text": {
22
                           "query": "<QUERY_TERM>",
23
                           "path": "<FIELD_NAME>"
24
                        }
25
                     }
26
                  },
27
                  { "$limit": 20 }
28
               ],
29
            }
30
         }
31
      }
32
   },
33
   { $limit: 20 }
34
] )

public class Movie
{
    public ObjectId Id { get; set; }
    public int Runtime { get; set; }
    
    public string Title { get; set; }
    public string Rated { get; set; }
    public List<string> Genres { get; set; }
    public string Plot { get; set; }
    
    public ImdbData Imdb { get; set; }
    public int Year { get; set; }
    public int Index { get; set; }
    
    public string[] Comments { get; set; }
   
    [BsonElement("lastupdated")]
    public DateTime LastUpdated { get; set; }
}

var collection = client.GetDatabase("sample_mflix").GetCollection<Movie>("movies");
var index = new BsonDocument
{
    { "mappings", new BsonDocument
        {
            { "dynamic", true }
        }
    }
};
collection.SearchIndexes.CreateOne(index, "default");

var searchPipelines = new Dictionary<string, PipelineDefinition<Movie, Movie>>
{
    {
        "searchPlot",
        new EmptyPipelineDefinition<Movie>()
            .Search(
                Builders<Movie>.Search.Text(Builders<Movie>.SearchPath.Single(m => m.Plot), "space"))
    },
    {
        "searchGenre",
        new EmptyPipelineDefinition<Movie>()
            .Search(
                Builders<Movie>.Search.Text(Builders<Movie>.SearchPath.Single(m => m.Genres), "adventure"))
    }
};
var weights = new Dictionary<string, double>
{
    { "searchPlot", 0.4 },
    { "searchGenre", 0.6 }
};
var pipeline = new EmptyPipelineDefinition<Movie>()
    .RankFusion(searchPipelines, weights, new RankFusionOptions<Movie> { ScoreDetails = true });

const index = {
  name: "default",
  definition: {
    mappings: { dynamic: true }
  }
}
const result = collection.createSearchIndex(index);

const pipeline = [
  {
    $rankFusion: { 
      input: {
        pipelines: {
          searchPlot: [
            {
              $search: {
                index: "default",
                text: { query: "space", path: "plot"}
              }
            }
          ],
          searchGenre: [
            {
              $search: {
                index: "default",
                text: { query: "adventure", path: "genres" }
              }
            }
          ] 
        }
      },
      combination: { weights: {searchPlot: 0.6, searchGenre: 0.4} },
      scoreDetails: true                  
    }
  },
  { $addFields: { scoreDetails: { $meta: "searchScoreDetails" } } }
];
          
const cursor = collection.aggregate(pipeline);  
return cursor;