Docs Menu
Docs Home
/
MongoDB Atlas
/
Atlas Search
/
Tutorials

How to Run Atlas Search Compound Queries with Weighted Fields

On this page

  • Create the Atlas Search Index With Dynamic Mapping
  • Run Compound Queries
  • Run a Compound Query to Boost Results
  • Run a Compound Query to Bury Results
  • Continue Learning

This tutorial demonstrates how to add weights to your search fields to boost or bury the documents in the results or a category of results. It demonstrates how to assign one or more values to a field to return results with a higher or lower score.

Specifically, the tutorial shows how to create an index with dynamic mapping on the sample_mflix.movies collection. It shows how to run compound queries and alter the score using constant, function, and boost. It takes you through the following steps:

  1. Set up an Atlas Search index with dynamic mapping for the sample_mflix.movies collection.

  2. Run the following Atlas Search queries:

    • Query the year field and alter the score using specific a word in the title field to boost the document in the results.

    • Query the title and plot fields and alter the score based on a specific genre in the genres field to bury results in that genre.

Before you begin, ensure that your Atlas cluster meets the requirements described in the Prerequisites.

To create an Atlas Search index, you must have Project Data Access Admin or higher access to the project.

Create the Atlas Search Index With Dynamic Mapping

In this section, you will create an Atlas Search index that uses dynamic mapping to index the fields in the sample_mflix.movies collection.

1

In Atlas, go to the Clusters page for your project.

  1. If it's not already displayed, select the organization that contains your desired project from the Organizations menu in the navigation bar.

  2. If it's not already displayed, select your desired project from the Projects menu in the navigation bar.

  3. If it's not already displayed, click Clusters in the sidebar.

    The Clusters page displays.

2

Go to the Atlas Search page for your cluster.

You can go the Atlas Search page from the sidebar, the Data Explorer, or your cluster details page.

  1. In the sidebar, click Atlas Search under the Services heading.

  2. From the Select data source dropdown, select your cluster and click Go to Atlas Search.

    The Atlas Search page displays.

  1. Click the Browse Collections button for your cluster.

  2. Expand the database and select the collection.

  3. Click the Search Indexes tab for the collection.

    The Atlas Search page displays.

  1. Click the cluster's name.

  2. Click the Atlas Search tab.

    The Atlas Search page displays.

3

Click Create Search Index.

4

Select an Atlas Search Configuration Method and click Next.

  • For a guided experience, select the Atlas Search Visual Editor.

  • To edit the raw index definition, select the Atlas Search JSON Editor.

5

Enter the Index Name, and set the Database and Collection.

  1. In the Index Name field, enter compound-query-custom-score-tutorial.

    If you name your index default, you don't need to specify an index parameter in the $search pipeline stage. If you give a custom name to your index, you must specify this name in the index parameter.

  2. In the Database and Collection section, find the sample_mflix database, and select the movies collection.

6

Specify an index definition.

You can create an Atlas Search index that uses dynamic mappings or static mappings. To learn more about dynamic and static mappings, see Static and Dynamic Mappings.

The following index definition dynamically indexes the fields of supported types in the movies collection. You can use the Atlas Search Visual Editor or the Atlas Search JSON Editor in the Atlas user interface to create the index.

Visual Editor

  1. Click Next.

  2. Review the "default" index definition for the movies collection.

JSON Editor

  1. Click Next.

  2. Review the index definition.

    Your index definition should look similar to the following:

    {
      "mappings": {
        "dynamic": true
      }
    }

    The above index definition dynamically indexes the fields of supported types in each document in the movies collection.

  3. Click Next.

7

Click Create Search Index.

8

Close the You're All Set! Modal Window.

A modal window appears to let you know your index is building. Click the Close button.

9

Wait for the index to finish building.

The index should take about one minute to build. While it is building, the Status column reads Build in Progress. When it is finished building, the Status column reads Active.

Run Compound Queries

You use the compound operator to combine two or more operators into a single query. Atlas Search assigns a score based on relevance, in order from highest score to lowest, to every document that it returns for your query. The queries demonstrate how to boost or bury the documents in the results.

➤ Use the Select your language drop-down menu to set the language of the examples in this section.

Tip

Atlas Search provides a sample compound query template with guidance. To learn more, see View Query Guidance Template.

Run a Compound Query to Boost Results

In this section, you connect to your Atlas cluster and run the sample queries using the compound operator against the title and year fields in the sample_mflix.movies collection. The sample queries use custom scoring to alter the relevance score returned by Atlas Search for movie titles that contain the term snow.

1

In Atlas, go to the Clusters page for your project.

  1. If it's not already displayed, select the organization that contains your desired project from the Organizations menu in the navigation bar.

  2. If it's not already displayed, select your desired project from the Projects menu in the navigation bar.

  3. If it's not already displayed, click Clusters in the sidebar.

    The Clusters page displays.

2

Go to the Atlas Search page for your cluster.

You can go the Atlas Search page from the sidebar, the Data Explorer, or your cluster details page.

  1. In the sidebar, click Atlas Search under the Services heading.

  2. From the Select data source dropdown, select your cluster and click Go to Atlas Search.

    The Atlas Search page displays.

  1. Click the Browse Collections button for your cluster.

  2. Expand the database and select the collection.

  3. Click the Search Indexes tab for the collection.

    The Atlas Search page displays.

  1. Click the cluster's name.

  2. Click the Atlas Search tab.

    The Atlas Search page displays.

3

Go to the Search Tester.

Click the Query button to the right of the index to query.

4

View and edit the query syntax.

Click Edit Query to view a default query syntax sample in JSON format.

5

Run the following Atlas Search queries with the compound operator on the movies collection.

Copy and paste the following query into the Query Editor, and then click the Search button in the Query Editor.

The following examples use the compound operator with subqueries to search for movies between the years 2013 to 2015 with the term snow in the title field.

The following query:

  • Uses the following compound operator clauses:

    • filter clause with the range operator to search for movies between the years 2013 to 2015.

    • should clause with the text operator to query for the term snow in the title field and alter the score with the constant option. The constant option replaces all score results for the search term with 5.

  • Specifies the highlight option to return snippets of text from the title field that match the query. The snippets contain matching text specified with type: 'hit', and adjacent text specified with type: 'text'.

[
  {
    $search: {
      index: "compound-query-custom-score-tutorial",
      compound: {
        filter: [{
          range: {
            path: "year",
            gte: 2013,
            lte: 2015
          }
        }],
        should: [{
          text: {
            query: "snow",
            path: "title",
            score: {constant: {value: 5}}
          }
        }]
      },
      highlight:{
        path: "title"
      }
    }
  }
]
SCORE: 5  _id:  "573a13d7f29313caabda38ad"
  Snow in Paradise
  Matching fields: title
SCORE: 5  _id:  "573a13e2f29313caabdbeded"
  Dead Snow 2: red vs.
  Matching fields: title
SCORE: 5  _id:  "573a13e6f29313caabdc66c4"
  The Snow White Murder Case
  Matching fields: title
SCORE: 5  _id:  "573a13edf29313caabdd37bd"
  Snow on the Blades
  Matching fields: title
SCORE: 0  _id:  "573a13acf29313caabd29366"
  No highlights found.
  Matching fields: unknown
SCORE: 0  _id:  "573a13adf29313caabd2b765"
  No highlights found.
  Matching fields: unknown
SCORE: 0  _id:  "573a13b0f29313caabd333e7"
  No highlights found.
  Matching fields: unknown
SCORE: 0  _id:  "573a13b0f29313caabd3486a"
  No highlights found.
  Matching fields: unknown
SCORE: 0  _id:  "573a13b1f29313caabd3719d"
  No highlights found.
  Matching fields: unknown
SCORE: 0  _id:  "573a13b2f29313caabd3abb9"
  No highlights found.
  Matching fields: unknown

The first four documents in the results have a higher score because the should clause in the query specifies a preference for documents with snow in the title. The should clause also alters the score for the query term snow using the constant option.

The following query:

  • Uses the following compound operator clauses:

    • must clause with the range operator to search for movies between the years 2013 to 2015.

    • should clause with the text operator to query for the term snow in the title field and alter the score with the boost option. The boost option multiplies the base score in the results for the search term by 2.

  • Specifies the highlight option to return snippets of text from the title field that match the query. The snippets contain matching text specified with type: 'hit', and adjacent text specified with type: 'text'.

[
  {
    $search: {
      index: "compound-query-custom-score-tutorial",
      compound: {
        must: [{
          range: {
            path: "year",
            gte: 2013,
            lte: 2015
          }
        }],
        should: [{
          text: {
            query: "snow",
            path: "title",
            score: {boost: {value: 2}}
          }
        }]
      },
      highlight:{
        path: "title"
      }
    }
  }
]
SCORE: 6.7722930908203125  _id:  "573a13d7f29313caabda38ad"
  Snow in Paradise
  Matching fields: title
SCORE: 6.063445568084717  _id:  "573a13edf29313caabdd37bd"
  Snow on the Blades
  Matching fields: title
SCORE: 5.509652137756348  _id:  "573a13e6f29313caabdc66c4"
  The Snow White Murder Case
  Matching fields: title
SCORE: 5.065053939819336  _id:  "573a13e2f29313caabdbeded"
  Dead Snow 2: Red vs.
  Matching fields: title
SCORE: 1  _id:  "573a13acf29313caabd29366"
  No highlights found.
  Matching fields: unknown
SCORE: 1  _id:  "573a13adf29313caabd2b765"
  No highlights found.
  Matching fields: unknown
SCORE: 1  _id:  "573a13b0f29313caabd333e7"
  No highlights found.
  Matching fields: unknown
SCORE: 1  _id:  "573a13b0f29313caabd3486a"
  No highlights found.
  Matching fields: unknown
SCORE: 1  _id:  "573a13b1f29313caabd3719d"
  No highlights found.
  Matching fields: unknown
SCORE: 1  _id:  "573a13b2f29313caabd3abb9"
  No highlights found.
  Matching fields: unknown

The first four documents in the results have a higher score because the should clause in the query specifies a preference for documents with snow in the title. The should clause also alters the score for the query term snow using the boost option.

The following query:

  • Uses the following compound operator clauses with the boost option to prioritize some fields more than other fields:

    • must clause with the text operator to prioritize the genre comedy the most, followed by the term snow in the title field. The boost option applies weights to the fields.

    • should clause with the range operator to search for movies between the years 2013 to 2015.

    Note

    The boost option applies different weights to the fields to prioritize the fields.

[
  {
    $search: {
      index: "compound-query-custom-score-tutorial",
      compound: {
        must: [{
          text: {
            query: "comedy",
            path: "genres",
            score: {boost: {value: 9}}
          }
        },
        {
          text: {
            query: "snow",
            path: "title",
            score: {boost: {value: 5}}
          }
        }],
        should: [{
          range: {
            path: "year",
            gte: 2013,
            lte: 2015,
            score: {boost: {value: 3}}
          }
        }]
      }
    }
  }
]
SCORE: 21.872983932495117  _id:  "573a13c2f29313caabd6874c"
  plot: "A ski vacation turns horrific for a group of medical students, as they…"
  genres: Array
  runtime: 91
SCORE: 21.043487548828125  _id:  "573a139ff29313caabcffff8"
  fullplot: "When an entire town in upstate New York is closed down by an unexpecte…"
  imdb: Object
  year: 2000
SCORE: 21.043487548828125  _id:  "573a13a6f29313caabd16b02"
  plot: "When a Miami dentist inherits a team of sled dogs, he's got to learn t…"
  genres: Array
  runtime: 99
SCORE: 19.523927688598633  _id:  "573a13a1f29313caabd06765"
  fullplot: "Our two young lovers meet on a series of snowy days in high school. Ye…"
  imdb: Object
  runtime: 1999
SCORE: 17.426334381103516  _id:  "573a13e2f29313caabdbeded"
  plot: "Still on the run from a group of Nazi zombies, a man seeks the aid of …"
  genres: Array
  runtime: 100
SCORE: 16.367326736450195  _id:  "573a13c2f29313caabd6688e"
  countries: Array
  genres: Array
  runtime: 108
SCORE: 15.537829399108887  _id:  "573a13b1f29313caabd36d7d"
  plot: "A love-struck Italian poet is stuck in Iraq at the onset of an America…"
  genres: Array
  runtime: 110
SCORE: 14.4263334274292  _id:  "573a1395f29313caabce1925"
  plot: "An ice-skating Snow White finds refuge from the Wicked Queen with the …"
  genres: Array
  runtime: 107

The following query:

  • Uses the following compound operator clauses:

    • must clause with the range operator to search for movies between the years 2013 to 2015.

    • should clause with the text operator to query for the term snow in the title field and alter the score with the function option. The function option adds the following using an arithmetic expression:

      • The relevance score of the query for the search term

      • The value of the numeric field named imdb.rating or the number 2 for those documents that do not have the imdb.rating field.

  • Specifies the highlight option to return snippets of text from the title field that match the query. The snippets contain matching text specified with type: 'hit', and adjacent text specified with type: 'text'.

[
  {
    $search: {
      index: "compound-query-custom-score-tutorial",
      compound: {
        must: [{
          range: {
            path: "year",
            gte: 2013,
            lte: 2015,
          }
        }],
        should: [{
          text: {
            query: "snow",
            path: "title",
            score: {
              function: {
                add: [{
                  path: {
                    value: "imdb.rating",
                    undefined: 2
                  }
                },
                {
                  score: "relevance"
                }]
              }
            }
          }
        }]
      },
      highlight: {
        path: "title"
      }
    }
  }
]
SCORE: 10.454826354980469  _id:  "573a13e6f29313caabdc66c4"
  The Snow White Murder Case
  Matching fields: title
SCORE: 10.3317232131958  _id:  "573a13edf29313caabdd37bd"
  Snow on the Blades
  Matching fields: title
SCORE: 10.032526969909668  _id:  "573a13e2f29313caabdbeded"
  Dead Snow 2: Red vs.
  Matching fields: title
SCORE: 8.386146545410156  _id:  "573a13d7f29313caabda38ad"
  Snow in Paradise
  Matching fields: title
SCORE: 1  _id:  "573a13acf29313caabd29366"
  No highlights found.
  Matching fields: unknown
SCORE: 1  _id:  "573a13adf29313caabd2b765"
  No highlights found.
  Matching fields: unknown
SCORE: 1  _id:  "573a13b0f29313caabd333e7"
  No highlights found.
  Matching fields: unknown
SCORE: 1  _id:  "573a13b0f29313caabd3486a"
  No highlights found.
  Matching fields: unknown
SCORE: 1  _id:  "573a13b1f29313caabd3719d"
  No highlights found.
  Matching fields: unknown
SCORE: 1  _id:  "573a13b2f29313caabd3abb9"
  No highlights found.
  Matching fields: unknown

The first four documents in the results have a higher score because the should clause in the query specifies a preference for documents with snow in the title. The should clause also alters the score for the query term snow using the function option.

6

Expand your query results.

The Search Tester might not display all the fields in the documents it returns. To view all the fields, including the field that you specify in the query path, expand the document in the results.

1

Connect to your cluster in mongosh.

Open mongosh in a terminal window and connect to your cluster. For detailed instructions on connecting, see Connect via mongosh.

2

Use the sample_mflix database.

Run the following command at mongosh prompt:

use sample_mflix
3

Run the following Atlas Search queries with the compound operator on the movies collection.

The following examples use the compound operator with subqueries to search for movies between the years 2013 to 2015 with the term snow in the title field.

This query uses the following pipeline stages:

  • $search to query the collection. The query:

    • Uses the following compound operator clauses:

      • filter clause with the range operator to search for movies between the years 2013 to 2015.

      • should clause with the text operator to query for the term snow in the title field and alter the score with the constant option. The constant option replaces all score results for the search term with 5.

    • Specifies the highlight option to return snippets of text from the title field that match the query. The snippets contain matching text specified with type: 'hit', and adjacent text specified with type: 'text'.

  • $limit stage to limit the output to 10 results.

  • $project stage to:

    • Exclude all fields except title and year

    • Add a score field

db.movies.aggregate([
  {
    "$search": {
      "index": "compound-query-custom-score-tutorial",
      "compound": {
        "filter": [{
          "range": {
            "path": "year",
            "gte": 2013,
            "lte": 2015
          }
        }],
        "should": [{
          "text": {
            "query": "snow",
            "path": "title",
            "score": {"constant": {"value": 5}}
          }
        }]
      },
      "highlight": {
        "path": "title"
      }
    }
  },
  {
    "$limit": 10
  },
  {
    "$project": {
      "_id": 0,
      "title": 1,
      "year": 1,
      "score": { "$meta": "searchScore" },
      "highlights": { "$meta": "searchHighlights" }
    }
  }
])

Atlas Search returns the following results for constant:

 [
  {
    title: 'Snow in Paradise',
    year: 2014,
    score: 5,
    highlights: [
      {
        score: 1.382846713066101,
        path: 'title',
        texts: [
          { value: 'Snow', type: 'hit' },
          { value: ' in Paradise', type: 'text' }
        ]
      }
    ]
  },
  {
    title: 'Dead Snow 2: Red vs. Dead',
    year: 2014,
    score: 5,
    highlights: [
      {
        score: 1.3924485445022583,
        path: 'title',
        texts: [
          { value: 'Dead ', type: 'text' },
          { value: 'Snow', type: 'hit' },
          { value: ' 2: Red vs. ', type: 'text' }
        ]
      }
    ]
  },
  {
    title: 'The Snow White Murder Case',
    year: 2014,
    score: 5,
    highlights: [
      {
        score: 1.3525336980819702,
        path: 'title',
        texts: [
          { value: 'The ', type: 'text' },
          { value: 'Snow', type: 'hit' },
          { value: ' White Murder Case', type: 'text' }
        ]
      }
    ]
  },
  {
    title: 'Snow on the Blades',
    year: 2014,
    score: 5,
    highlights: [
      {
        score: 1.3766303062438965,
        path: 'title',
        texts: [
          { value: 'Snow', type: 'hit' },
          { value: ' on the Blades', type: 'text' }
        ]
      }
    ]
  },
  { year: 2013, title: 'The Secret Life of Walter Mitty', score: 0, highlights: [] },
  { title: 'Jurassic World', year: 2015, score: 0, highlights: [] },
  { title: 'Action Jackson', year: 2014, score: 0, highlights: [] },
  { year: 2013, title: 'In Secret', score: 0, highlights: [] },
  { title: 'The Stanford Prison Experiment', year: 2015, score: 0, highlights: [] },
  { year: 2014, title: 'The Giver', score: 0, highlights: [] }
]

The first four documents in the results have a higher score because the should clause in the query specifies a preference for documents with snow in the title. The should clause also alters the score for the query term snow using the constant option.

This query uses the following pipeline stages:

  • $search to query the collection. The query:

    • Uses the following compound operator clauses:

      • must clause with the range operator to search for movies between the years 2013 to 2015.

      • should clause with the text operator to query for the term snow in the title field and alter the score with the boost option. The boost option multiplies the base score in the results for the search term by 2.

    • Specifies the highlight option to return snippets of text from the title field that match the query. The snippets contain matching text specified with type: 'hit', and adjacent text specified with type: 'text'.

  • $limit stage to limit the output to 10 results.

  • $project stage to:

    • Exclude all fields except title and year

    • Add a score field

db.movies.aggregate([
  {
    "$search": {
      "index": "compound-query-custom-score-tutorial",
      "compound": {
        "must": [{
          "range": {
            "path": "year",
            "gte": 2013,
            "lte": 2015
          }
        }],
        "should": [{
          "text": {
            "query": "snow",
            "path": "title",
            "score": {"boost": {"value": 2}}
          }
        }]
      },
      "highlight": {
        "path": "title"
      }
    }
  },
  {
    "$limit": 10
  },
  {
    "$project": {
      "_id": 0,
      "title": 1,
      "year": 1,
      "score": { "$meta": "searchScore" },
      "highlights": { "$meta": "searchHighlights" }
    }
  }
])

Atlas Search returns the following results for boost:

[
  {
    title: 'Snow in Paradise',
    year: 2014,
    score: 6.7722930908203125,
    highlights: [
     {
       score: 1.382846713066101,
       path: 'title',
       texts: [
         { value: 'Snow', type: 'hit' },
         { value: ' in Paradise', type: 'text' }
       ]
     }
    ]
  },
  {
    title: 'Snow on the Blades',
    year: 2014,
    score: 6.063445568084717,
    highlights: [
      {
        score: 1.3766303062438965,
        path: 'title',
        texts: [
          { value: 'Snow', type: 'hit' },
          { value: ' on the Blades', type: 'text' }
        ]
      }
    ]
  },
  {
    title: 'The Snow White Murder Case',
    year: 2014,
    score: 5.509652137756348,
    highlights: [
      {
        score: 1.3525336980819702,
        path: 'title',
        texts: [
          { value: 'The ', type: 'text' },
          { value: 'Snow', type: 'hit' },
          { value: ' White Murder Case', type: 'text' }
        ]
      }
    ]
  },
  {
    title: 'Dead Snow 2: Red vs. Dead',
    year: 2014,
    score: 5.065053939819336,
    highlights: [
      {
        score: 1.3924485445022583,
        path: 'title',
        texts: [
          { value: 'Dead ', type: 'text' },
          { value: 'Snow', type: 'hit' },
          { value: ' 2: Red vs. ', type: 'text' }
        ]
      }
    ]
  },
  { year: 2013, title: 'The Secret Life of Walter Mitty', score: 1, highlights: [] },
  { title: 'Jurassic World', year: 2015, score: 1, highlights: [] },
  { title: 'Action Jackson', year: 2014, score: 1, highlights: [] },
  { year: 2013, title: 'In Secret', score: 1, highlights: [] },
  { title: 'The Stanford Prison Experiment', year: 2015, score: 1,  highlights: [] },
  { year: 2014, title: 'The Giver', score: 1, highlights: [] }
]

The first four documents in the results have a higher score because the should clause in the query specifies a preference for documents with snow in the title. The should clause also alters the score for the query term snow using the boost option.

This query uses the following pipeline stages:

  • $search to query the collection. The query uses the following compound operator clauses with the boost option to prioritize some fields more than other fields:

    • must clause with the text operator to prioritize the genre comedy the most, followed by the term snow in the title field. The boost option applies weights to the fields.

    • should clause with the range operator to search for movies between the years 2013 to 2015.

    Note

    The boost option applies different weights to the fields to prioritize the fields.

  • $limit stage to limit the output to 10 results.

  • $project stage to:

    • Exclude all fields except title, year, and genres

    • Add a score field

db.movies.aggregate([
    {
      "$search": {
        "index": "compound-query-custom-score-tutorial",
        "compound": {
          "must": [{
            "text": {
              "path": "genres",
              "query": "comedy",
              "score": {"boost": {"value": 9}}
            }
          },
          {
            "text": {
              "path": "title",
              "query": "snow",
              "score": {"boost": {"value": 5}}
            }
          }],
          "should": [{
            "range": {
              "path": "year",
              "gte": 2013,
              "lte": 2015,
              "score": {"boost": {"value": 3}}
            }
          }]
        }
      }
    },
    {
      "$limit": 10
    },
    {
      "$project": {
        "_id": 0,
        "title": 1,
        "year": 1,
        "genres": 1,
        "score": { "$meta": "searchScore" }
      }
    }
])
  [
    {
      genres: [ 'Comedy', 'Horror' ],
      title: 'Dead Snow',
      year: 2009,
      score: 21.872983932495117
    },
    {
      year: 2000,
      genres: [ 'Adventure', 'Comedy', 'Family' ],
      title: 'Snow Day',
      score: 21.043487548828125
    },
    {
      genres: [ 'Adventure', 'Comedy', 'Family' ],
      title: 'Snow Dogs',
      year: 2002,
      score: 21.043487548828125
    },
    {
      year: 1999,
      genres: [ 'Comedy', 'Romance' ],
      title: 'Let It Snow',
      score: 19.523927688598633
    },
    {
      genres: [ 'Action', 'Comedy', 'Horror' ],
      title: 'Dead Snow 2: Red vs. Dead',
      year: 2014,
      score: 17.426334381103516
    },
    {
      genres: [ 'Comedy', 'Drama' ],
      title: 'Snow White and Russian Red',
      year: 2009,
      score: 16.367326736450195
    },
    {
      genres: [ 'Comedy', 'Drama', 'Romance' ],
      title: 'The Tiger and the Snow',
      year: 2005,
      score: 15.537829399108887
    },
    {
      genres: [ 'Adventure', 'Comedy', 'Family' ],
      title: 'Snow White and the Three Stooges',
      year: 1961,
      score: 14.4263334274292
    }
  ]

This query uses the following pipeline stages:

  • $search to query the collection. The query:

    • Uses the following compound operator clauses:

      • must clause with the range operator to search for movies between the years 2013 to 2015.

      • should clause with the text operator to query for the term snow in the title field and alter the score with the function option. The function option adds the following using an arithmetic expression:

        • The relevance score of the query for the search term

        • The value of the numeric field named imdb.rating or the number 2 for those documents that do not have the imdb.rating field.

    • Specifies the highlight option to return snippets of text from the title field that match the query. The snippets contain matching text specified with type: 'hit', and adjacent text specified with type: 'text'.

  • $limit stage to limit the output to 10 results.

  • $project stage to:

    • Exclude all fields except title and year

    • Add a score field

db.movies.aggregate([
  {
    "$search": {
      "index": "compound-query-custom-score-tutorial",
      "compound": {
        "must": [{
          "range": {
            "path": "year",
            "gte": 2013,
            "lte": 2015
          }
        }],
        "should": [{
          "text": {
            "query": "snow",
            "path": "title",
            "score": {
              "function": {
                "add": [{
                  "path": {
                    "value": "imdb.rating",
                    "undefined": 2
                  }
                },
                {
                  "score": "relevance"
                }]
              }
            }
          }
        }]
      },
      "highlight": {
        "path": "title"
      }
    }
  },
  {
    "$limit": 10
  },
  {
    "$project": {
      "_id": 0,
      "title": 1,
      "year": 1,
      "score": { "$meta": "searchScore" },
      "highlights": { "$meta": "searchHighlights" }
    }
  }
])

Atlas Search returns the following results for function:

 [
  {
    title: 'The Snow White Murder Case',
    year: 2014,
    score: 10.454826354980469,
    highlights: [
      {
        score: 1.3525336980819702,
        path: 'title',
        texts: [
          { value: 'The ', type: 'text' },
          { value: 'Snow', type: 'hit' },
          { value: ' White Murder Case', type: 'text' }
        ]
      }
    ]
  },
  {
    title: 'Snow on the Blades',
    year: 2014,
    score: 10.3317232131958,
    highlights: [
      {
        score: 1.3766303062438965,
        path: 'title',
        texts: [
          { value: 'Snow', type: 'hit' },
          { value: ' on the Blades', type: 'text' }
        ]
      }
    ]
  },
  {
    title: 'Dead Snow 2: Red vs. Dead',
    year: 2014,
    score: 10.032526969909668,
    highlights: [
      {
        score: 1.3924485445022583,
        path: 'title',
        texts: [
          { value: 'Dead ', type: 'text' },
          { value: 'Snow', type: 'hit' },
          { value: ' 2: Red vs. ', type: 'text' }
        ]
      }
    ]
  },
  {
    title: 'Snow in Paradise',
    year: 2014,
    score: 8.386146545410156,
    highlights: [
      {
        score: 1.382846713066101,
        path: 'title',
        texts: [
          { value: 'Snow', type: 'hit' },
          { value: ' in Paradise', type: 'text' }
        ]
      }
    ]
  },
  { year: 2013, title: 'The Secret Life of Walter Mitty', score: 1, highlights: [] },
  { title: 'Jurassic World', year: 2015, score: 1, highlights: [] },
  { title: 'Action Jackson', year: 2014, score: 1, highlights: [] },
  { year: 2013, title: 'In Secret', score: 1, highlights: [] },
  { title: 'The Stanford Prison Experiment', year: 2015, score: 1, highlights: [] },
  { year: 2014, title: 'The Giver', score: 1, highlights: [] }
]

The first four documents in the results have a higher score because the should clause in the query specifies a preference for documents with snow in the title. The should clause also alters the score for the query term snow using the function option.

1

Connect to your cluster in MongoDB Compass.

Open MongoDB Compass and connect to your cluster. For detailed instructions on connecting, see Connect via Compass.

2

Use the movies collection in the sample_mflix database.

On the Database screen, click the sample_mflix database, then click the movies collection.

3

Run an Atlas Search compound query that alters the score using the constant option.

The query performs the following tasks:

  • Uses the following compound operator clauses:

    • filter clause with the range operator to search for movies between the years 2013 to 2015.

    • should clause with the text operator to query for the term snow in the title field and alter the score with the constant option. The constant option replaces all score results for the search term with 5.

  • Specifies the highlight option to return snippets of text from the title field that match the query. The snippets contain matching text specified with type: 'hit', and adjacent text specified with type: 'text'.

  • Uses the following pipeline stages:

    • $limit stage to limit the output to 10 results

    • $project stage to:

      • Exclude all fields except title and year

      • Add two fields named score and highlights

To run this query in MongoDB Compass:

  1. Click the Aggregations tab.

  2. Click Select..., then configure each of the following pipeline stages by selecting the stage from the dropdown and adding the query for that stage. Click Add Stage to add additional stages.

    Pipeline Stage
    Query
    $search
    {
      "index": "compound-query-custom-score-tutorial",
      "compound": {
        "filter": [{
          "range": {
            "path": "year",
            "gte": 2013,
            "lte": 2015
          }
        }],
        "should": [{
          "text": {
            "query": "snow",
            "path": "title",
            "score": {"constant": {"value": 5}}
          }
        }]
      },
      "highlight": { "path": "title" }
    }
    $limit
    10
    $project
    {
      "_id": 0,
      "title": 1,
      "year": 1,
      "score": { "$meta": "searchScore" },
      "highlights": { "$meta": "searchHighlights" }
    }

    If you enabled Auto Preview, MongoDB Compass displays the following documents next to the $project pipeline stage:

    {
      title: 'Snow in Paradise',
      year: 2014,
      score: 5,
      highlights: [{
        score: 1.382846713066101,
        path: 'title',
        texts: [
          { value: 'Snow', type: 'hit' },
          { value: ' in Paradise', type: 'text' }
        ]
      }]
    },
    {
      title: 'Dead Snow 2: Red vs. Dead',
      year: 2014,
      score: 5,
      highlights: [{
        score: 1.3924485445022583,
        path: 'title',
        texts: [
          { value: 'Dead ', type: 'text' },
          { value: 'Snow', type: 'hit' },
          { value: ' 2: Red vs. ', type: 'text' }
        ]
      }]
    },
    {
      title: 'The Snow White Murder Case',
      year: 2014,
      score: 5,
      highlights: [{
        score: 1.3525336980819702,
        path: 'title',
        texts: [
          { value: 'The ', type: 'text' },
          { value: 'Snow', type: 'hit' },
          { value: ' White Murder Case', type: 'text' }
        ]
      }]
    },
    {
      title: 'Snow on the Blades',
      year: 2014,
      score: 5,
      highlights: [{
        score: 1.3766303062438965,
        path: 'title',
        texts: [
          { value: 'Snow', type: 'hit' },
          { value: ' on the Blades', type: 'text' }
        ]
      }]
    },
    { year: 2013, title: 'The Secret Life of Walter Mitty', score: 0, highlights: [] },
    { title: 'Jurassic World', year: 2015, score: 0, highlights: [] },
    { title: 'Action Jackson', year: 2014, score: 0, highlights: [] },
    { year: 2013, title: 'In Secret', score: 0, highlights: [] },
    { title: 'The Stanford Prison Experiment', year: 2015, score: 0, highlights: [] },
    { year: 2014, title: 'The Giver', score: 0, highlights: [] }

    The first four documents in the results have a higher score because the should clause in the query specifies a preference for documents with snow in the title. The should clause also alters the score for the query term snow using the constant option.

4

Run Atlas Search compound queries that alter the score using the boost option.

  1. Click the Aggregations tab.

  2. Click Select..., then configure each of the following pipeline stages by selecting the stage from the dropdown and adding the query for that stage. Click Add Stage to add additional stages.

    The query uses the following pipeline stages:

    • $search to perform the following tasks:

      • Queries using the following compound operator clauses:

        • must clause with the range operator to search for movies between the years 2013 to 2015.

        • should clause with the text operator to query for the term snow in the title field and alter the score with the boost option. The boost option multiplies the base score in the results for the search term by 2.

      • Specifies the highlight option to return snippets of text from the title field that match the query. The snippets contain matching text specified with type: 'hit', and adjacent text specified with type: 'text'.

    • $limit stage to limit the output to 10 results

    • $project stage to:

      • Exclude all fields except title and year

      • Add two fields named score and highlights

    Pipeline Stage
    Query
    $search
    {
      "index": "compound-query-custom-score-tutorial",
      "compound": {
        "must": [{
          "range": {
            "path": "year",
            "gte": 2013,
            "lte": 2015
          }
        }],
        "should": [{
          "text": {
            "query": "snow",
            "path": "title",
            "score": {"boost": {"value": 2}}
          }
        }]
      },
      "highlight": { "path": "title" }
    }
    $limit
    10
    $project
    {
      "_id": 0,
      "title": 1,
      "year": 1,
      "score": { "$meta": "searchScore" },
      "highlights": { "$meta": "searchHighlights" }
    }

    This query uses the following pipeline stages:

    • $search to perform the following tasks:

      • Queries using the compound operator clauses with the boost option to prioritize some fields more than other fields:

        • must clause with the text operator to prioritize the genre comedy the most, followed by the term snow in the title field. The boost option applies weights to the fields.

        • should clause with the range operator to search for movies between the years 2013 to 2015.

        Note

        The boost option applies different weights to the fields to prioritize the fields.

    • $limit stage to limit the output to 10 results

    • $project stage to:

      • Exclude all fields except title and year

      • Add two fields named score and highlights

    • must clause with the text operator to prioritize the genre comedy the most, followed by the term snow in the title field. The boost option applies weights to the fields.

    • should clause with the range operator to search for movies between the years 2013 to 2015.

    Note

    The boost option applies different weights to the fields to prioritize the fields.

    Pipeline Stage
    Query
    $search
    {
      "index": "compound-query-custom-score-tutorial",
      "compound": {
        "must": [{
          "text": {
            "path": "genres",
            "query": "comedy",
            "score": {"boost": {"value": 9}}
          }
        },
        {
          "text": {
            "path": "title",
            "query": "snow",
            "score": {"boost": {"value": 5}}
          }
        }],
        "should": [{
          "range": {
            "path": "year",
            "gte": 2013,
            "lte": 2015,
            "score": {"boost": {"value": 3}}
          }
        }]
      }
    }
    $limit
    10
    $project
    {
      "_id": 0,
      "title": 1,
      "year": 1,
      "genres": 1,
      "score": { "$meta": "searchScore" }
    }

    If you enabled Auto Preview, MongoDB Compass displays the following documents next to the $project pipeline stage:

    {
      title: 'Snow in Paradise',
      year: 2014,
      score: 6.7722930908203125,
      highlights: [{
        score: 1.382846713066101,
        path: 'title',
        texts: [
          { value: 'Snow', type: 'hit' },
          { value: ' in Paradise', type: 'text' }
        ]
      }]
    },
    {
      title: 'Snow on the Blades',
      year: 2014,
      score: 6.063445568084717,
      highlights: [{
        score: 1.3766303062438965,
        path: 'title',
        texts: [
          { value: 'Snow', type: 'hit' },
          { value: ' on the Blades', type: 'text' }
        ]
      }]
    },
    {
      title: 'The Snow White Murder Case',
      year: 2014,
      score: 5.509652137756348,
      highlights: [{
        score: 1.3525336980819702,
        path: 'title',
        texts: [
          { value: 'The ', type: 'text' },
          { value: 'Snow', type: 'hit' },
          { value: ' White Murder Case', type: 'text' }
        ]
      }]
    },
    {
      title: 'Dead Snow 2: Red vs. Dead',
      year: 2014,
      score: 5.065053939819336,
      highlights: [{
        score: 1.3924485445022583,
        path: 'title',
        texts: [
          { value: 'Dead ', type: 'text' },
          { value: 'Snow', type: 'hit' },
          { value: ' 2: Red vs. ', type: 'text' }
        ]
      }]
    },
    { year: 2013, title: 'The Secret Life of Walter Mitty',score: 1, highlights: [] },
    { title: 'Jurassic World', year: 2015, score: 1, highlights: [] },
    { title: 'Action Jackson', year: 2014, score: 1, highlights: [] },
    { year: 2013, title: 'In Secret', score: 1, highlights: [] },
    { title: 'The Stanford Prison Experiment', year: 2015, score: 1,  highlights: [] },
    { year: 2014, title: 'The Giver', score: 1, highlights: [] }

    The first four documents in the results have a higher score because the should clause in the query specifies a preference for documents with snow in the title. The should clause also alters the score for the query term snow using the boost option.

      [
        {
          genres: [ 'Comedy', 'Horror' ],
          title: 'Dead Snow',
          year: 2009,
          score: 21.872983932495117
        },
        {
          year: 2000,
          genres: [ 'Adventure', 'Comedy', 'Family' ],
          title: 'Snow Day',
          score: 21.043487548828125
        },
        {
          genres: [ 'Adventure', 'Comedy', 'Family' ],
          title: 'Snow Dogs',
          year: 2002,
          score: 21.043487548828125
        },
        {
          year: 1999,
          genres: [ 'Comedy', 'Romance' ],
          title: 'Let It Snow',
          score: 19.523927688598633
        },
        {
          genres: [ 'Action', 'Comedy', 'Horror' ],
          title: 'Dead Snow 2: Red vs. Dead',
          year: 2014,
          score: 17.426334381103516
        },
        {
          genres: [ 'Comedy', 'Drama' ],
          title: 'Snow White and Russian Red',
          year: 2009,
          score: 16.367326736450195
        },
        {
          genres: [ 'Comedy', 'Drama', 'Romance' ],
          title: 'The Tiger and the Snow',
          year: 2005,
          score: 15.537829399108887
        },
        {
          genres: [ 'Adventure', 'Comedy', 'Family' ],
          title: 'Snow White and the Three Stooges',
          year: 1961,
          score: 14.4263334274292
        }
      ]
5

Run an Atlas Search compound query that alters the score using the function option.

The query uses the following pipeline stages:

  • $search stage to perform the following tasks:

    • Queries using the following compound operator clauses:

      • must clause with the range operator to search for movies between the years 2013 to 2015.

      • should clause with the text operator to query for the term snow in the title field and alter the score with the function option. The function option adds the following using an arithmetic expression:

        • The relevance score of the query for the search term

        • The value of the numeric field named imdb.rating or the number 2 for those documents that do not have the imdb.rating field.

    • Specifies the highlight option to return snippets of text from the title field that match the query. The snippets contain matching text specified with type: 'hit', and adjacent text specified with type: 'text'.

  • $limit stage to limit the output to 10 results

  • $project stage to:

    • Exclude all fields except title and year

    • Add two fields named score and highlights

To run this query in MongoDB Compass:

  1. Click the Aggregations tab.

  2. Click Select..., then configure each of the following pipeline stages by selecting the stage from the dropdown and adding the query for that stage. Click Add Stage to add additional stages.

    Pipeline Stage
    Query
    $search
    {
      "index": "compound-query-custom-score-tutorial",
      "compound": {
      "must": [{
        "range": {
          "path": "year",
          "gte": 2013,
          "lte": 2015
        }
      }],
      "should": [{
        "text": {
          "query": "snow",
          "path": "title",
          "score": {
            "function": {
              "add": [{
                "path": {
                  "value": "imdb.rating",
                  "undefined": 2
                }
              },
              {
                "score": "relevance"
              }]
            }
          }
        }
      }]},
      "highlight":{ "path": "title" }
    }
    $limit
    10
    $project
    {
      "_id": 0,
      "title": 1,
      "year": 1,
      "score": { "$meta": "searchScore" },
      "highlights": { "$meta": "searchHighlights" }
    }

    If you enabled Auto Preview, MongoDB Compass displays the following documents next to the $project pipeline stage:

    {
      title: 'The Snow White Murder Case',
      year: 2014,
      score: 10.454826354980469,
      highlights: [{
          score: 1.3525336980819702,
          path: 'title',
          texts: [
            { value: 'The ', type: 'text' },
            { value: 'Snow', type: 'hit' },
            { value: ' White Murder Case', type: 'text' }
          ]
      }]
    },
    {
      title: 'Snow on the Blades',
      year: 2014,
      score: 10.3317232131958,
      highlights: [{
        score: 1.3766303062438965,
        path: 'title',
        texts: [
          { value: 'Snow', type: 'hit' },
          { value: ' on the Blades', type: 'text' }
        ]
      }]
    },
    {
      title: 'Dead Snow 2: Red vs. Dead',
      year: 2014,
      score: 10.032526969909668,
      highlights: [{
        score: 1.3924485445022583,
        path: 'title',
        texts: [
          { value: 'Dead ', type: 'text' },
          { value: 'Snow', type: 'hit' },
          { value: ' 2: Red vs. ', type: 'text' }
        ]
      }]
    },
    {
      title: 'Snow in Paradise',
      year: 2014,
      score: 8.386146545410156,
      highlights: [{
        score: 1.382846713066101,
        path: 'title',
        texts: [
          { value: 'Snow', type: 'hit' },
          { value: ' in Paradise', type: 'text' }
        ]
      }]
    },
    { year: 2013, title: 'The Secret Life of Walter Mitty', score: 1, highlights: [] },
    { title: 'Jurassic World', year: 2015, score: 1, highlights: [] },
    { title: 'Action Jackson', year: 2014, score: 1, highlights: [] },
    { year: 2013, title: 'In Secret', score: 1, highlights: [] },
    { title: 'The Stanford Prison Experiment', year: 2015, score: 1, highlights: [] },
    { year: 2014, title: 'The Giver', score: 1, highlights: [] }

    The first four documents in the results have a higher score because the should clause in the query specifies a preference for documents with snow in the title. The should clause also alters the score for the query term snow using the function option.

1

Run an Atlas Search compound query that alters the score using the constant option.

  1. Create a new directory called compound-constant-example and initialize your project with the dotnet new command.

    mkdir compound-constant-example
    cd compound-constant-example
    dotnet new console

  2. Add the .NET/C# Driver to your project as a dependency.

    dotnet add package MongoDB.Driver

  3. Replace the contents of the Program.cs file with the following code.

    The code example performs the following tasks:

    • Imports mongodb packages and dependencies.

    • Establishes a connection to your Atlas cluster.

    • Uses the following compound clauses to query the collection:

      • filter clause with the range operator to search for movies between the years 2013 to 2015.

      • should clause with the text operator to query for the term snow in the title field and alter the score with the constant option. The constant option replaces all score results for the search term with 5.

    • Specifies the highlight option to return snippets of text from the title field that match the query. The snippets contain matching text specified with type: 'hit', and adjacent text specified with type: 'text'.

    • Uses the following pipeline stages:

      • $limit stage to limit the output to 10 results

      • $project stage to:

        • Exclude all fields except title and year

        • Add two fields named score and highlights

    • Iterates over the cursor to print the documents that match the query.

    1using MongoDB.Bson;
    2using MongoDB.Bson.Serialization.Attributes;
    3using MongoDB.Bson.Serialization.Conventions;
    4using MongoDB.Driver;
    5using MongoDB.Driver.Search;
    6
    7public class CompoundConstantExample
    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 MovieDocument
    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 mflixDatabase = mongoClient.GetDatabase("sample_mflix");
    20        var moviesCollection = mflixDatabase.GetCollection<MovieDocument>("movies");
    21
    22        // define and run pipeline
    23        var results = moviesCollection.Aggregate()
    24            .Search(Builders<MovieDocument>.Search.Compound()
    25                .Filter(Builders<MovieDocument>.Search.Range(movie => movie.Year, SearchRangeBuilder.Gte(2013).Lte(2015)))
    26                .Should(Builders<MovieDocument>.Search.Text(movie => movie.Title, "snow", score: new SearchScoreDefinitionBuilder<MovieDocument>().Constant(5))), 
    27                new SearchHighlightOptions<MovieDocument>(movie => movie.Title),
    28                indexName: "compound-query-custom-score-tutorial")
    29            .Project<MovieDocument>(Builders<MovieDocument>.Projection
    30                .Include(movie => movie.Title)
    31                .Include(movie => movie.Year)
    32                .Exclude(movie => movie.Id)
    33                .MetaSearchScore(movie => movie.Score)
    34                .MetaSearchHighlights("highlights"))
    35            .Limit(10)
    36            .ToList();
    37
    38        // print results
    39        foreach (var movie in results)
    40        {
    41            Console.WriteLine(movie.ToJson());
    42        }
    43    }
    44}
    45
    46[BsonIgnoreExtraElements]
    47public class MovieDocument
    48{
    49    [BsonIgnoreIfDefault]
    50    public ObjectId Id { get; set; }
    51    public string Title { get; set; }
    52    public int Year { get; set; }
    53    [BsonElement("highlights")]
    54    public List<SearchHighlight> Highlights { get; set; }
    55    public double Score { get; set; }
    56}

  4. Before you run the sample, replace <connection-string> with your Atlas connection string. Ensure that your connection string includes your database user's credentials. To learn more, see Connect via Drivers.

  5. Compile and run the Program.cs file.

    dotnet run compound-constant-example.csproj
    {
      "title" : "Snow in Paradise",
      "year" : 2014,
      "highlights" : [{
        "path" : "title",
        "score" : 1.3828467130661011,
        "texts" : [{ "type" : "Hit", "value" : "Snow" }, { "type" : "Text", "value" : " in Paradise" }]
      }],
      "score" : 5.0
    }
    {
      "title" : "Dead Snow 2: Red vs. Dead",
      "year" : 2014,
      "highlights" : [{
        "path" : "title",
        "score" : 1.3924485445022583,
        "texts" : [{ "type" : "Text", "value" : "Dead " }, { "type" : "Hit", "value" : "Snow" }, { "type" : "Text", "value" : " 2: Red vs. " }]
      }],
      "score" : 5.0
    }
    {
      "title" : "The Snow White Murder Case",
      "year" : 2014,
      "highlights" : [{
        "path" : "title",
        "score" : 1.3525336980819702,
        "texts" : [{ "type" : "Text", "value" : "The " }, { "type" : "Hit", "value" : "Snow" }, { "type" : "Text", "value" : " White Murder Case" }]
      }],
      "score" : 5.0
    }
    {
      "title" : "Snow on the Blades",
      "year" : 2014,
      "highlights" : [{
        "path" : "title",
        "score" : 1.3766303062438965,
        "texts" : [{ "type" : "Hit", "value" : "Snow" }, { "type" : "Text", "value" : " on the Blades" }]
      }],
      "score" : 5.0
    }
    { "title" : "The Secret Life of Walter Mitty", "year" : 2013, "highlights" : [], "score" : 0.0 }
    { "title" : "Jurassic World", "year" : 2015, "highlights" : [], "score" : 0.0 }
    { "title" : "Action Jackson", "year" : 2014, "highlights" : [], "score" : 0.0 }
    { "title" : "In Secret", "year" : 2013, "highlights" : [], "score" : 0.0 }
    { "title" : "The Stanford Prison Experiment", "year" : 2015, "highlights" : [], "score" : 0.0 }
    { "title" : "The Giver", "year" : 2014, "highlights" : [], "score" : 0.0 }

    The first four documents in the results have a higher score because the should clause in the query specifies a preference for documents with snow in the title. The should clause also alters the score for the query term snow using the constant option.

2

Run Atlas Search compound queries that alter the score using the boost option.

  1. Create a new directory called compound-boost-example and initialize your project with the dotnet new command.

    mkdir compound-boost-example
    cd compound-boost-example
    dotnet new console

  2. Add the .NET/C# Driver to your project as a dependency.

    dotnet add package MongoDB.Driver

  3. Replace the contents of the Program.cs file with the following code.

    The code example performs the following tasks:

    • Imports mongodb packages and dependencies.

    • Establishes a connection to your Atlas cluster.

    • Iterates over the cursor to print the documents that match the query.

    The query uses the following pipeline stages:

    • $search stage to query the collection. The query:

      • Uses the following compound operator clauses:

        • must clause with the range operator to search for movies between the years 2013 to 2015.

        • should clause with the text operator to query for the term snow in the title field and alter the score with the boost option. The boost option multiplies the base score in the results for the search term by 2.

      Specifies the highlight option to return snippets of text from the title field that match the query. The snippets contain matching text specified with type: 'hit', and adjacent text specified with type: 'text'.

    • $limit stage to limit the output to 10 results

    • $project stage to:

      • Exclude all fields except title and year

      • Add two fields named score and highlights

    1using MongoDB.Bson;
    2using MongoDB.Bson.Serialization.Attributes;
    3using MongoDB.Bson.Serialization.Conventions;
    4using MongoDB.Driver;
    5using MongoDB.Driver.Search;
    6
    7public class CompoundBoostSingleExample
    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 MovieDocument
    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 mflixDatabase = mongoClient.GetDatabase("sample_mflix");
    20        var moviesCollection = mflixDatabase.GetCollection<MovieDocument>("movies");
    21
    22        // define and run pipeline
    23        var results = moviesCollection.Aggregate()
    24            .Search(Builders<MovieDocument>.Search.Compound()
    25                .Must(Builders<MovieDocument>.Search.Range(movie => movie.Year, SearchRangeBuilder.Gte(2013).Lte(2015)))
    26                .Should(Builders<MovieDocument>.Search.Text(movie => movie.Title, "snow", score: new SearchScoreDefinitionBuilder<MovieDocument>().Boost(2))), 
    27                new SearchHighlightOptions<MovieDocument>(movie => movie.Title),
    28                indexName: "compound-query-custom-score-tutorial")
    29            .Project<MovieDocument>(Builders<MovieDocument>.Projection
    30                .Include(movie => movie.Title)
    31                .Include(movie => movie.Year)
    32                .Exclude(movie => movie.Id)
    33                .MetaSearchScore(movie => movie.Score)
    34                .MetaSearchHighlights("highlights"))
    35            .Limit(10)
    36            .ToList();
    37
    38        // print results
    39        foreach (var movie in results)
    40        {
    41            Console.WriteLine(movie.ToJson());
    42        }
    43    }
    44}
    45
    46[BsonIgnoreExtraElements]
    47public class MovieDocument
    48{
    49    [BsonIgnoreIfDefault]
    50    public ObjectId Id { get; set; }
    51    public string Title { get; set; }
    52    public int Year { get; set; }
    53    [BsonElement("highlights")]
    54    public List<SearchHighlight> Highlights { get; set; }
    55    public double Score { get; set; }
    56}

    This query uses the following compound operator clauses with the boost option to prioritize some fields more than other fields:

    • must clause with the text operator to prioritize the genre comedy the most, followed by the term snow in the title field. The boost option applies weights to the fields.

    • should clause with the range operator to search for movies between the years 2013 to 2015.

    Note

    The boost option applies different weights to the fields to prioritize the fields.

    1using MongoDB.Bson;
    2using MongoDB.Bson.Serialization.Attributes;
    3using MongoDB.Bson.Serialization.Conventions;
    4using MongoDB.Driver;
    5using MongoDB.Driver.Search;
    6
    7public class CompoundBoostMultipleExample
    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 MovieDocument
    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 mflixDatabase = mongoClient.GetDatabase("sample_mflix");
    20        var moviesCollection = mflixDatabase.GetCollection<MovieDocument>("movies");
    21
    22        // define and run pipeline
    23        var results = moviesCollection.Aggregate()
    24            .Search(Builders<MovieDocument>.Search.Compound()
    25                .Must(Builders<MovieDocument>.Search.Text(movie => movie.Genres, "comedy", score: new SearchScoreDefinitionBuilder<MovieDocument>().Boost(9)))
    26                .Must(Builders<MovieDocument>.Search.Text(movie => movie.Title, "snow", score: new SearchScoreDefinitionBuilder<MovieDocument>().Boost(5)))
    27                .Should(Builders<MovieDocument>.Search.Range(movie => movie.Year, SearchRangeBuilder.Gte(2013).Lte(2015), score: new SearchScoreDefinitionBuilder<MovieDocument>().Boost(3))),
    28                indexName: "compound-query-custom-score-tutorial")
    29            .Project<MovieDocument>(Builders<MovieDocument>.Projection
    30                .Include(movie => movie.Genres)
    31                .Include(movie => movie.Title)
    32                .Include(movie => movie.Year)
    33                .Exclude(movie => movie.Id)
    34                .MetaSearchScore(movie => movie.Score))
    35            .Limit(10)
    36            .ToList();
    37        
    38        // print results
    39        foreach (var movie in results)
    40        {
    41            Console.WriteLine(movie.ToJson());
    42        }
    43    }
    44}
    45
    46[BsonIgnoreExtraElements]
    47public class MovieDocument
    48{
    49    [BsonIgnoreIfDefault]
    50    public ObjectId Id { get; set; }
    51    public string [] Genres { get; set; }
    52    public string Title { get; set; }
    53    public int Year { get; set; }
    54    public double Score { get; set; }
    55}

  4. Before you run the sample, replace <connection-string> with your Atlas connection string. Ensure that your connection string includes your database user's credentials. To learn more, see Connect via Drivers.

  5. Compile and run the Program.cs file.

    dotnet run compound-boost-example.csproj
    {
      "title" : "Snow in Paradise",
      "year" : 2014,
      "highlights" : [{
        "path" : "title",
        "score" : 1.3828467130661011,
        "texts" : [{ "type" : "Hit", "value" : "Snow" }, { "type" : "Text", "value" : " in Paradise" }]
      }],
      "score" : 6.7722930908203125
    }
    {
      "title" : "Snow on the Blades",
      "year" : 2014,
      "highlights" : [{
        "path" : "title",
        "score" : 1.3766303062438965,
        "texts" : [{ "type" : "Hit", "value" : "Snow" }, { "type" : "Text", "value" : " on the Blades" }]
      }],
      "score" : 6.0634455680847168
    }
    {
      "title" : "The Snow White Murder Case",
      "year" : 2014,
      "highlights" : [{
        "path" : "title",
        "score" : 1.3525336980819702,
        "texts" : [{ "type" : "Text", "value" : "The " }, { "type" : "Hit", "value" : "Snow" }, { "type" : "Text", "value" : " White Murder Case" }]
      }],
      "score" : 5.5096521377563477
    }
    {
      "title" : "Dead Snow 2: Red vs. Dead",
      "year" : 2014,
      "highlights" : [{
        "path" : "title",
        "score" : 1.3924485445022583,
        "texts" : [{ "type" : "Text", "value" : "Dead " }, { "type" : "Hit", "value" : "Snow" }, { "type" : "Text", "value" : " 2: Red vs. " }]
      }],
      "score" : 5.0650539398193359
    }
    { "title" : "The Secret Life of Walter Mitty", "year" : 2013, "highlights" : [], "score" : 1.0 }
    { "title" : "Jurassic World", "year" : 2015, "highlights" : [], "score" : 1.0 }
    { "title" : "Action Jackson", "year" : 2014, "highlights" : [], "score" : 1.0 }
    { "title" : "In Secret", "year" : 2013, "highlights" : [], "score" : 1.0 }
    { "title" : "The Stanford Prison Experiment", "year" : 2015, "highlights" : [], "score" : 1.0 }
    { "title" : "The Giver", "year" : 2014, "highlights" : [], "score" : 1.0 }

    The first four documents in the results have a higher score because the should clause in the query specifies a preference for documents with snow in the title. The should clause also alters the score for the query term snow using the boost option.

    dotnet run compound-boost-example.csproj
    { "genres" : ["Comedy", "Horror"], "title" : "Dead Snow", "year" : 2009, "score" : 21.872983932495117 }
    { "genres" : ["Adventure", "Comedy", "Family"], "title" : "Snow Day", "year" : 2000, "score" : 21.043487548828125 }
    { "genres" : ["Adventure", "Comedy", "Family"], "title" : "Snow Dogs", "year" : 2002, "score" : 21.043487548828125 }
    { "genres" : ["Comedy", "Romance"], "title" : "Let It Snow", "year" : 1999, "score" : 19.523927688598633 }
    { "genres" : ["Action", "Comedy", "Horror"], "title" : "Dead Snow 2: Red vs. Dead", "year" : 2014, "score" : 17.426334381103516 }
    { "genres" : ["Comedy", "Drama"], "title" : "Snow White and Russian Red", "year" : 2009, "score" : 16.367326736450195 }
    { "genres" : ["Comedy", "Drama", "Romance"], "title" : "The Tiger and the Snow", "year" : 2005, "score" : 15.537829399108887 }
    { "genres" : ["Adventure", "Comedy", "Family"], "title" : "Snow White and the Three Stooges", "year" : 1961, "score" : 14.426333427429199 }
3

Run an Atlas Search compound query that alters the score using the function option.

  1. Create a new directory called compound-function-example and initialize your project with the dotnet new command.

    mkdir compound-function-example
    cd compound-function-example
    dotnet new console

  2. Add the .NET/C# Driver to your project as a dependency.

    dotnet add package MongoDB.Driver

  3. Replace the contents of the Program.cs file with the following code.

    The code example performs the following tasks:

    • Imports mongodb packages and dependencies.

    • Establishes a connection to your Atlas cluster.

    • Uses the following pipeline stages to query the collection:

      • must clause with the range operator to search for movies between the years 2013 to 2015.

      • should clause with the text operator to query for the term snow in the title field and alter the score with the function option. The function option adds the following using an arithmetic expression:

        • The relevance score of the query for the search term

        • The value of the numeric field named imdb.rating or the number 2 for those documents that do not have the imdb.rating field.

    • Uses the following pipeline stages:

      • $limit stage to limit the output to 10 results

      • $project stage to:

        • Exclude all fields except title and year

        • Add two fields named score and highlights

    • Specifies the highlight option to return snippets of text from the title field that match the query. The snippets contain matching text specified with type: 'hit', and adjacent text specified with type: 'text'.

    • Iterates over the cursor to print the documents that match the query.

    1using MongoDB.Bson;
    2using MongoDB.Bson.Serialization.Attributes;
    3using MongoDB.Bson.Serialization.Conventions;
    4using MongoDB.Driver;
    5using MongoDB.Driver.Search;
    6
    7public class CompoundFunctionExample
    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 MovieDocument
    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 mflixDatabase = mongoClient.GetDatabase("sample_mflix");
    20        var moviesCollection = mflixDatabase.GetCollection<MovieDocument>("movies");
    21
    22        var scoreFunction = Builders<MovieDocument>.SearchScore.Function(Builders<MovieDocument>.SearchScoreFunction.Add(Builders<MovieDocument>.SearchScoreFunction.Path(movie => movie.Imdb.Rating, 2), Builders<MovieDocument>.SearchScoreFunction.Relevance()));
    23        // define and run pipeline
    24        var results = moviesCollection.Aggregate()
    25            .Search(Builders<MovieDocument>.Search.Compound()
    26                .Must(Builders<MovieDocument>.Search.Range(movie => movie.Year, SearchRangeBuilder.Gte(2013).Lte(2015)))
    27                .Should(Builders<MovieDocument>.Search.Text(movie => movie.Title, "snow", score: scoreFunction)),
    28                new SearchHighlightOptions<MovieDocument>(movie => movie.Title),
    29                indexName: "compound-query-custom-score-tutorial")
    30            .Project<MovieDocument>(Builders<MovieDocument>.Projection
    31                .Include(movie => movie.Genres)
    32                .Include(movie => movie.Title)
    33                .Include(movie => movie.Year)
    34                .Exclude(movie => movie.Id)
    35                .MetaSearchScore(movie => movie.Score)
    36                .MetaSearchHighlights("highlights"))
    37            .Limit(10)
    38            .ToList();
    39        
    40        // print results
    41        foreach (var movie in results)
    42        {
    43            Console.WriteLine(movie.ToJson());
    44        }
    45    }
    46}
    47
    48[BsonIgnoreExtraElements]
    49public class MovieDocument
    50{
    51    [BsonIgnoreIfDefault]
    52    public ObjectId Id { get; set; }
    53    public string [] Genres { get; set; }
    54    public IMDB Imdb { get; set; }
    55    public string Title { get; set; }
    56    public int Year { get; set; }
    57    [BsonElement("highlights")]
    58    public List<SearchHighlight> Highlights { get; set; }
    59    public double Score { get; set; }
    60}
    61
    62[BsonIgnoreExtraElements]
    63public class IMDB
    64{
    65    public double Rating { get; set; }
    66}

  4. Before you run the sample, replace <connection-string> with your Atlas connection string. Ensure that your connection string includes your database user's credentials. To learn more, see Connect via Drivers.

  5. Compile and run the Program.cs file.

    dotnet run compound-function-example.csproj
    { "genres" : ["Drama", "Mystery"], "title" : "The Snow White Murder Case", "year" : 2014, "highlights" : [{ "path" : "title", "score" : 1.3525336980819702, "texts" : [{ "type" : "Text", "value" : "The " }, { "type" : "Hit", "value" : "Snow" }, { "type" : "Text", "value" : " White Murder Case" }] }], "score" : 10.454826354980469 }
    { "genres" : ["Action", "Drama", "History"], "title" : "Snow on the Blades", "year" : 2014, "highlights" : [{ "path" : "title", "score" : 1.3766303062438965, "texts" : [{ "type" : "Hit", "value" : "Snow" }, { "type" : "Text", "value" : " on the Blades" }] }], "score" : 10.331723213195801 }
    { "genres" : ["Action", "Comedy", "Horror"], "title" : "Dead Snow 2: Red vs. Dead", "year" : 2014, "highlights" : [{ "path" : "title", "score" : 1.3924485445022583, "texts" : [{ "type" : "Text", "value" : "Dead " }, { "type" : "Hit", "value" : "Snow" }, { "type" : "Text", "value" : " 2: Red vs. " }] }], "score" : 10.032526969909668 }
    { "genres" : ["Thriller"], "title" : "Snow in Paradise", "year" : 2014, "highlights" : [{ "path" : "title", "score" : 1.3828467130661011, "texts" : [{ "type" : "Hit", "value" : "Snow" }, { "type" : "Text", "value" : " in Paradise" }] }], "score" : 8.3861465454101562 }
    { "genres" : ["Adventure", "Comedy", "Drama"], "title" : "The Secret Life of Walter Mitty", "year" : 2013, "highlights" : [], "score" : 1.0 }
    { "genres" : ["Action", "Adventure", "Sci-Fi"], "title" : "Jurassic World", "year" : 2015, "highlights" : [], "score" : 1.0 }
    { "genres" : ["Action", "Comedy", "Drama"], "title" : "Action Jackson", "year" : 2014, "highlights" : [], "score" : 1.0 }
    { "genres" : ["Crime", "Drama", "Thriller"], "title" : "In Secret", "year" : 2013, "highlights" : [], "score" : 1.0 }
    { "genres" : ["Drama", "Thriller"], "title" : "The Stanford Prison Experiment", "year" : 2015, "highlights" : [], "score" : 1.0 }
    { "genres" : ["Drama", "Sci-Fi"], "title" : "The Giver", "year" : 2014, "highlights" : [], "score" : 1.0 }

    The first four documents in the results have a higher score because the should clause in the query specifies a preference for documents with snow in the title. The should clause also alters the score for the query term snow using the function option.

1

Run an Atlas Search compound query that alters the score using the constant option.

  1. Create a file named compound-constant-query.go.

  2. Copy and paste the code example into the compound-constant-query.go file.

    The code example performs the following tasks:

    • Imports mongodb packages and dependencies.

    • Establishes a connection to your Atlas cluster.

    • Uses the following compound clauses to query the collection:

      • filter clause with the range operator to search for movies between the years 2013 to 2015.

      • should clause with the text operator to query for the term snow in the title field and alter the score with the constant option. The constant option replaces all score results for the search term with 5.

    • Specifies the highlight option to return snippets of text from the title field that match the query. The snippets contain matching text specified with type: 'hit', and adjacent text specified with type: 'text'.

    • Uses the following pipeline stages:

      • $limit stage to limit the output to 10 results

      • $project stage to:

        • Exclude all fields except title and year

        • Add two fields named score and highlights

    • Iterates over the cursor to print the documents that match the query.

    1package main
    2
    3import (
    4	"context"
    5	"fmt"
    6	"time"
    7
    8	"go.mongodb.org/mongo-driver/bson"
    9	"go.mongodb.org/mongo-driver/mongo"
    10	"go.mongodb.org/mongo-driver/mongo/options"
    11)
    12
    13func main() {
    14	// connect to your Atlas cluster
    15	client, err := mongo.Connect(context.TODO(), options.Client().ApplyURI("<connection-string>"))
    16	if err != nil {
    17		panic(err)
    18	}
    19	defer client.Disconnect(context.TODO())
    20
    21	// set namespace
    22	collection := client.Database("sample_mflix").Collection("movies")
    23
    24	// define pipeline stages
    25	searchStage := bson.D{{"$search", bson.M{
    26		"index": "compound-query-custom-score-tutorial",
    27		"compound": bson.M{
    28			"filter": bson.M{
    29				"range": bson.M{
    30					"path": "year", "gte": 2013, "lte": 2015,
    31				},
    32			},
    33			"should": bson.D{
    34				{"text", bson.M{
    35					"path": "title", "query": "snow", "score": bson.M{
    36						"constant": bson.D{{"value", 5}},
    37					}}}},
    38		},
    39		"highlight": bson.D{{"path", "title"}},
    40	}}}
    41	limitStage := bson.D{{"$limit", 10}}
    42	projectStage := bson.D{{"$project", bson.D{{"title", 1}, {"year", 1}, {"_id", 0}, {"score", bson.D{{"$meta", "searchScore"}}}, {"highlights", bson.D{{"$meta", "searchHighlights"}}}}}}
    43
    44	// specify the amount of time the operation can run on the server
    45	opts := options.Aggregate().SetMaxTime(5 * time.Second)
    46
    47	// run pipeline
    48	cursor, err := collection.Aggregate(context.TODO(), mongo.Pipeline{searchStage, limitStage, projectStage}, opts)
    49	if err != nil {
    50		panic(err)
    51	}
    52
    53	// print results
    54	var results []bson.D
    55	if err = cursor.All(context.TODO(), &results); err != nil {
    56		panic(err)
    57	}
    58	for _, result := range results {
    59		fmt.Println(result)
    60	}
    61}

  3. Before you run the sample, replace <connection-string> with your Atlas connection string. Ensure that your connection string includes your database user's credentials. To learn more, see Connect via Drivers.

  4. Run the following command to query your collection:

    go run compound-constant-query.go
    [{title Snow in Paradise} {year 2014} {score 5} {highlights [[{score 1.382846713066101} {path title} {texts [[{value Snow} {type hit}] [{value  in Paradise} {type text}]]}]]}]
    [{title Dead Snow 2: Red vs. Dead} {year 2014} {score 5} {highlights [[{score 1.3924485445022583} {path title} {texts [[{value Dead } {type text}] [{value Snow} {type hit}] [{value  2: Red vs. } {type text}]]}]]}]
    [{title The Snow White Murder Case} {year 2014} {score 5} {highlights [[{score 1.3525336980819702} {path title} {texts [[{value The } {type text}] [{value Snow} {type hit}] [{value  White Murder Case} {type text}]]}]]}]
    [{title Snow on the Blades} {year 2014} {score 5} {highlights [[{score 1.3766303062438965} {path title} {texts [[{value Snow} {type hit}] [{value  on the Blades} {type text}]]}]]}]
    [{year 2013} {title The Secret Life of Walter Mitty} {score 0} {highlights []}]
    [{title Jurassic World} {year 2015} {score 0} {highlights []}]
    [{title Action Jackson} {year 2014} {score 0} {highlights []}]
    [{year 2013} {title In Secret} {score 0} {highlights []}]
    [{title The Stanford Prison Experiment} {year 2015} {score 0} {highlights []}]
    [{year 2014} {title The Giver} {score 0} {highlights []}]

    The first four documents in the results have a higher score because the should clause in the query specifies a preference for documents with snow in the title. The should clause also alters the score for the query term snow using the constant option.

2

Run an Atlas Search compound query that alters the score using the boost option.

  1. Create a file named compound-boost-query.go.

  2. Copy and paste the code example into the compound-boost-query.go file.

    The code examples perform the following tasks:

    • Imports mongodb packages and dependencies.

    • Establishes a connection to your Atlas cluster.

    • Iterates over the cursor to print the documents that match the query.

    The query uses the following pipeline stages:

    • $search stage to query the collection. The query:

      • Uses the following compound clauses to query the collection:

        • must clause with the range operator to search for movies between the years 2013 to 2015.

        • should clause with the text operator to query for the term snow in the title field and alter the score with the boost option. The boost option multiplies the base score in the results for the search term by 2.

      • Specifies the highlight option to return snippets of text from the title field that match the query. The snippets contain matching text specified with type: 'hit', and adjacent text specified with type: 'text'.

    • $limit stage to limit the output to 10 results

    • $project stage to:

      • Exclude all fields except title and year

      • Add two fields named score and highlights

    1package main
    2
    3import (
    4	"context"
    5	"fmt"
    6	"time"
    7
    8	"go.mongodb.org/mongo-driver/bson"
    9	"go.mongodb.org/mongo-driver/mongo"
    10	"go.mongodb.org/mongo-driver/mongo/options"
    11)
    12
    13// define structure of movies collection
    14type MovieCollection struct {
    15	title string `bson:"Title,omitempty"`
    16}
    17
    18func main() {
    19	var err error
    20	// connect to the Atlas cluster
    21	ctx := context.Background()
    22	client, err := mongo.Connect(ctx, options.Client().ApplyURI("<connection-string>"))
    23	if err != nil {
    24		panic(err)
    25	}
    26	defer client.Disconnect(ctx)
    27	// set namespace
    28	collection := client.Database("sample_mflix").Collection("movies")
    29	// define pipeline
    30	searchStage := bson.D{{"$search", bson.M{
    31		"index": "compound-query-custom-score-tutorial",
    32		"compound": bson.M{
    33			"must": bson.M{
    34				"range": bson.M{
    35					"path": "year", "gte": 2013, "lte": 2015,
    36				},
    37			},
    38			"should": bson.D{
    39				{"text", bson.M{
    40					"path": "title", "query": "snow", "score": bson.M{
    41						"boost": bson.D{{"value", 2}},
    42					},
    43				}},
    44			},
    45		},
    46	}}}
    47	limitStage := bson.D{{"$limit", 10}}
    48	projectStage := bson.D{{"$project", bson.D{{"title", 1}, {"year", 1}, {"_id", 0}, {"score", bson.D{{"$meta", "searchScore"}}}}}}
    49	// specify the amount of time the operation can run on the server
    50	opts := options.Aggregate().SetMaxTime(5 * time.Second)
    51	// run pipeline
    52	cursor, err := collection.Aggregate(ctx, mongo.Pipeline{searchStage, limitStage, projectStage}, opts)
    53	if err != nil {
    54		panic(err)
    55	}
    56	// print results
    57	var results []bson.D
    58	if err = cursor.All(context.TODO(), &results); err != nil {
    59		panic(err)
    60	}
    61	for _, result := range results {
    62		fmt.Println(result)
    63	}
    64}

    This query uses the following pipeline stages:

    • $search stage to query the collection. The query:

      • Uses the compound operator clauses with the boost option to prioritize some fields more than other fields:

        • must clause with the text operator to prioritize the genre comedy the most, followed by the term snow in the title field. The boost option applies weights to the fields.

        • should clause with the range operator to search for movies between the years 2013 to 2015.

        Note

        The boost option applies different weights to the fields to prioritize the fields.

    • $limit stage to limit the output to 10 results

    • $project stage to:

      • Exclude all fields except title and year

      • Add two fields named score and highlights

    1package main
    2
    3import (
    4	"context"
    5	"fmt"
    6	"time"
    7
    8	"go.mongodb.org/mongo-driver/bson"
    9	"go.mongodb.org/mongo-driver/mongo"
    10	"go.mongodb.org/mongo-driver/mongo/options"
    11)
    12
    13// define structure of movies collection
    14type MovieCollection struct {
    15	title string `bson:"Title,omitempty"`
    16}
    17
    18func main() {
    19	var err error
    20	// connect to the Atlas cluster
    21	ctx := context.Background()
    22	client, err := mongo.Connect(ctx, options.Client().ApplyURI("<connection-string>"))
    23	if err != nil {
    24		panic(err)
    25	}
    26	defer client.Disconnect(ctx)
    27	// set namespace
    28	collection := client.Database("sample_mflix").Collection("movies")
    29	// define pipeline
    30	searchStage := bson.D{{"$search", bson.M{
    31		"index": "compound-query-custom-score-tutorial",
    32		"compound": bson.M{
    33			"must": bson.A{
    34				bson.M{
    35					"text": bson.M{
    36						"path": "genres", "query": "comedy", "score": bson.M{
    37							"boost": bson.D{{"value", 9}},
    38						},
    39					},
    40				},
    41				bson.M{
    42					"text": bson.M{
    43						"path": "title", "query": "snow", "score": bson.M{
    44							"boost": bson.D{{"value", 5}},
    45						},
    46					},
    47				},
    48			},
    49			"should": bson.M{
    50				"range": bson.M{
    51					"path": "year", "gte": 2013, "lte": 2015, "score": bson.M{
    52						"boost": bson.D{{"value", 3}},
    53					},
    54				},
    55			},
    56		},
    57	}}}
    58	limitStage := bson.D{{"$limit", 10}}
    59	projectStage := bson.D{{"$project", bson.D{{"title", 1}, {"year", 1}, {"genres", 1}, {"_id", 0}, {"score", bson.D{{"$meta", "searchScore"}}}}}}
    60	// specify the amount of time the operation can run on the server
    61	opts := options.Aggregate().SetMaxTime(5 * time.Second)
    62	// run pipeline
    63	cursor, err := collection.Aggregate(ctx, mongo.Pipeline{searchStage, limitStage, projectStage}, opts)
    64	if err != nil {
    65		panic(err)
    66	}
    67	// print results
    68	var results []bson.D
    69	if err = cursor.All(context.TODO(), &results); err != nil {
    70		panic(err)
    71	}
    72	for _, result := range results {
    73		fmt.Println(result)
    74	}
    75}

  3. Before you run the sample, replace <connection-string> with your Atlas connection string. Ensure that your connection string includes your database user's credentials. To learn more, see Connect via Drivers.

  4. Run the following command to query your collection:

    go run compound-boost-query.go
    [{title Snow in Paradise} {year 2014} {score 6.7722930908203125} {highlights [[{score 1.382846713066101} {path title} {texts [[{value Snow} {type hit}] [{value  in Paradise} {type text}]]}]]}]
    [{title Snow on the Blades} {year 2014} {score 6.063445568084717} {highlights [[{score 1.3766303062438965} {path title} {texts [[{value Snow} {type hit}] [{value  on the Blades} {type text}]]}]]}]
    [{title The Snow White Murder Case} {year 2014} {score 5.509652137756348} {highlights [[{score 1.3525336980819702} {path title} {texts [[{value The } {type text}] [{value Snow} {type hit}] [{value  White Murder Case} {type text}]]}]]}]
    [{title Dead Snow 2: Red vs. Dead} {year 2014} {score 5.065053939819336} {highlights [[{score 1.3924485445022583} {path title} {texts [[{value Dead } {type text}] [{value Snow} {type hit}] [{value  2: Red vs. } {type text}]]}]]}]
    [{year 2013} {title The Secret Life of Walter Mitty} {score 1} {highlights []}]
    [{title Jurassic World} {year 2015} {score 1} {highlights []}]
    [{title Action Jackson} {year 2014} {score 1} {highlights []}]
    [{year 2013} {title In Secret} {score 1} {highlights []}]
    [{title The Stanford Prison Experiment} {year 2015} {score 1} {highlights []}]
    [{year 2014} {title The Giver} {score 1} {highlights []}]

    The first four documents in the results have a higher score because the should clause in the query specifies a preference for documents with snow in the title. The should clause also alters the score for the query term snow using the boost option.

    go run compound-boost-query.go
      [
        {
          genres: [ 'Comedy', 'Horror' ],
          title: 'Dead Snow',
          year: 2009,
          score: 21.872983932495117
        },
        {
          year: 2000,
          genres: [ 'Adventure', 'Comedy', 'Family' ],
          title: 'Snow Day',
          score: 21.043487548828125
        },
        {
          genres: [ 'Adventure', 'Comedy', 'Family' ],
          title: 'Snow Dogs',
          year: 2002,
          score: 21.043487548828125
        },
        {
          year: 1999,
          genres: [ 'Comedy', 'Romance' ],
          title: 'Let It Snow',
          score: 19.523927688598633
        },
        {
          genres: [ 'Action', 'Comedy', 'Horror' ],
          title: 'Dead Snow 2: Red vs. Dead',
          year: 2014,
          score: 17.426334381103516
        },
        {
          genres: [ 'Comedy', 'Drama' ],
          title: 'Snow White and Russian Red',
          year: 2009,
          score: 16.367326736450195
        },
        {
          genres: [ 'Comedy', 'Drama', 'Romance' ],
          title: 'The Tiger and the Snow',
          year: 2005,
          score: 15.537829399108887
        },
        {
          genres: [ 'Adventure', 'Comedy', 'Family' ],
          title: 'Snow White and the Three Stooges',
          year: 1961,
          score: 14.4263334274292
        }
      ]
3

Run an Atlas Search compound query that alters the score using the function option.

  1. Create a file named compound-boost-query.go.

  2. Copy and paste the code example into the compound-function-query.go file.

    The code example performs the following tasks:

    • Imports mongodb packages and dependencies.

    • Establishes a connection to your Atlas cluster.

    • Uses the following compound operator clauses:

      • must clause with the range operator to search for movies between the years 2013 to 2015.

      • should clause with the text operator to query for the term snow in the title field and alter the score with the function option. The function option adds the following using an arithmetic expression:

        • The relevance score of the query for the search term

        • The value of the numeric field named imdb.rating or the number 2 for those documents that do not have the imdb.rating field.

    • Specifies the highlight option to return snippets of text from the title field that match the query. The snippets contain matching text specified with type: 'hit', and adjacent text specified with type: 'text'.

    • Uses the following pipeline stages:

      • $limit stage to limit the output to 10 results

      • $project stage to:

        • Exclude all fields except title and year

        • Add two fields named score and highlights

    • Iterates over the cursor to print the documents that match the query.

    1package main
    2
    3import (
    4	"context"
    5	"fmt"
    6	"time"
    7
    8	"go.mongodb.org/mongo-driver/bson"
    9	"go.mongodb.org/mongo-driver/mongo"
    10	"go.mongodb.org/mongo-driver/mongo/options"
    11)
    12
    13func main() {
    14	// connect to your Atlas cluster
    15	client, err := mongo.Connect(context.TODO(), options.Client().ApplyURI("<connection-string>"))
    16	if err != nil {
    17		panic(err)
    18	}
    19	defer client.Disconnect(context.TODO())
    20
    21	// set namespace
    22	collection := client.Database("sample_mflix").Collection("movies")
    23
    24	// define pipeline
    25	searchStage := bson.D{{"$search", bson.M{
    26		"index": "compound-query-custom-score-tutorial",
    27		"compound": bson.M{
    28			"must": bson.M{
    29				"range": bson.M{
    30					"path": "year", "gte": 2013, "lte": 2015,
    31				},
    32			},
    33			"should": bson.D{
    34				{"text", bson.M{
    35					"path": "title", "query": "snow", "score": bson.M{
    36						"function": bson.D{{"add", bson.A{
    37							bson.D{{"path", bson.D{
    38								{"value", "imdb.rating"}, {"undefined", 2},
    39							}}},
    40							bson.D{{"score", "relevance"}},
    41						}}},
    42					}}}},
    43		},
    44		"highlight": bson.D{{"path", "title"}},
    45	}}}
    46	limitStage := bson.D{{"$limit", 10}}
    47	projectStage := bson.D{{"$project", bson.D{{"title", 1}, {"year", 1}, {"_id", 0}, {"score", bson.D{{"$meta", "searchScore"}}}, {"highlights", bson.D{{"$meta", "searchHighlights"}}}}}}
    48
    49	// specify the amount of time the operation can run on the server
    50	opts := options.Aggregate().SetMaxTime(5 * time.Second)
    51
    52	// run pipeline
    53	cursor, err := collection.Aggregate(context.TODO(), mongo.Pipeline{searchStage, limitStage, projectStage}, opts)
    54	if err != nil {
    55		panic(err)
    56	}
    57
    58	// print results
    59	var results []bson.D
    60	if err = cursor.All(context.TODO(), &results); err != nil {
    61		panic(err)
    62	}
    63	for _, result := range results {
    64		fmt.Println(result)
    65	}
    66}

  3. Before you run the sample, replace <connection-string> with your Atlas connection string. Ensure that your connection string includes your database user's credentials. To learn more, see Connect via Drivers.

  4. Run the following command to query your collection:

    go run compound-function-query.go
    [{title The Snow White Murder Case} {year 2014} {score 10.454826354980469} {highlights [[{score 1.3525336980819702} {path title} {texts [[{value The } {type text}] [{value Snow} {type hit}] [{value  White Murder Case} {type text}]]}]]}]
    [{title Snow on the Blades} {year 2014} {score 10.3317232131958} {highlights [[{score 1.3766303062438965} {path title} {texts [[{value Snow} {type hit}] [{value  on the Blades} {type text}]]}]]}]
    [{title Dead Snow 2: Red vs. Dead} {year 2014} {score 10.032526969909668} {highlights [[{score 1.3924485445022583} {path title} {texts [[{value Dead } {type text}] [{value Snow} {type hit}] [{value  2: Red vs. } {type text}]]}]]}]
    [{title Snow in Paradise} {year 2014} {score 8.386146545410156} {highlights [[{score 1.382846713066101} {path title} {texts [[{value Snow} {type hit}] [{value  in Paradise} {type text}]]}]]}]
    [{year 2013} {title The Secret Life of Walter Mitty} {score 1} {highlights []}]
    [{title Jurassic World} {year 2015} {score 1} {highlights []}]
    [{title Action Jackson} {year 2014} {score 1} {highlights []}]
    [{year 2013} {title In Secret} {score 1} {highlights []}]
    [{title The Stanford Prison Experiment} {year 2015} {score 1} {highlights []}]
    [{year 2014} {title The Giver} {score 1} {highlights []}]

    The first four documents in the results have a higher score because the should clause in the query specifies a preference for documents with snow in the title. The should clause also alters the score for the query term snow using the function option.

1

Ensure that your CLASSPATH contains the following libraries.

junit
4.11 or higher version
mongodb-driver-sync
4.3.0 or higher version
slf4j-log4j12
1.7.30 or higher version
2

Run an Atlas Search compound query that alters the score using the constant option.

  1. Create a file named CompoundConstantQuery.java.

  2. Copy and paste the following code into the file.

    The code example performs the following tasks:

    • Imports mongodb packages and dependencies.

    • Establishes a connection to your Atlas cluster.

    • Uses the following compound clauses to query the collection:

      • filter clause with the range operator to search for movies between the years 2013 to 2015.

      • should clause with the text operator to query for the term snow in the title field and alter the score with the constant option. The constant option replaces all score results for the search term with 5.

    • Specifies the highlight option to return snippets of text from the title field that match the query. The snippets contain matching text specified with type: 'hit', and adjacent text specified with type: 'text'.

    • Uses the following pipeline stages:

      • $limit stage to limit the output to 10 results

      • $project stage to:

        • Exclude all fields except title and year

        • Add two fields named score and highlights

    • Iterates over the cursor to print the documents that match the query.

    1import java.util.Arrays;
    2import java.util.List;
    3
    4import static com.mongodb.client.model.Aggregates.limit;
    5import static com.mongodb.client.model.Aggregates.project;
    6import static com.mongodb.client.model.Projections.*;
    7import com.mongodb.client.MongoClient;
    8import com.mongodb.client.MongoClients;
    9import com.mongodb.client.MongoCollection;
    10import com.mongodb.client.MongoDatabase;
    11
    12import org.bson.Document;
    13
    14public class CompoundConstantQuery {
    15  public static void main( String[] args ) {
    16    // define clauses
    17    List<Document> mustClauses =
    18        List.of(
    19            new Document(
    20                "range", new Document("path", "year")
    21                .append("gte", 2013)
    22                .append("lte", 2015)));
    23    List<Document> shouldClauses =
    24        List.of(
    25            new Document("text",
    26                new Document("query", "snow")
    27                    .append("path", "title")
    28                    .append("score", new Document("constant", new Document("value", 5)))));
    29    Document highlightOption = new Document("path", "title");
    30    // define query
    31    Document agg =
    32        new Document("$search",
    33            new Document("index", "compound-query-custom-score-tutorial")
    34            .append("compound",
    35                new Document("must", mustClauses).append("should", shouldClauses))
    36            .append("highlight", highlightOption));
    37    // specify connection
    38    String uri = "<connection-string>";
    39    // establish connection and set namespace
    40    try (MongoClient mongoClient = MongoClients.create(uri)) {
    41      MongoDatabase database = mongoClient.getDatabase("sample_mflix");
    42      MongoCollection<Document> collection = database.getCollection("movies");
    43	  // run query and print results		
    44      collection.aggregate(Arrays.asList(agg, 
    45        limit(10), 
    46        project(fields(
    47          excludeId(), 
    48          include("title", "year"), 
    49          computed("score", new Document("$meta", "searchScore")), 
    50          computed("highlights", new Document("$meta", "searchHighlights"))))))
    51      .forEach(doc -> System.out.println(doc.toJson()));	
    52    }
    53  }
    54}

    Note

    To run the sample code in your Maven environment, add the following above the import statements in your file.

    package com.mongodb.drivers;

  3. Before you run the sample, replace <connection-string> with your Atlas connection string. Ensure that your connection string includes your database user's credentials. To learn more, see Connect via Drivers.

  4. Compile and run CompoundConstantQuery.java file.

    javac CompoundConstantQuery.java
    java CompoundConstantQuery
    {"title": "Snow in Paradise", "year": 2014, "score": 5.0, "highlights": [{"score": 1.382846713066101, "path": "title", "texts": [{"value": "Snow", "type": "hit"}, {"value": " in Paradise", "type": "text"}]}]}
    {"title": "Dead Snow 2: Red vs. Dead", "year": 2014, "score": 5.0, "highlights": [{"score": 1.3924485445022583, "path": "title", "texts": [{"value": "Dead ", "type": "text"}, {"value": "Snow", "type": "hit"}, {"value": " 2: Red vs. ", "type": "text"}]}]}
    {"title": "The Snow White Murder Case", "year": 2014, "score": 5.0, "highlights": [{"score": 1.3525336980819702, "path": "title", "texts": [{"value": "The ", "type": "text"}, {"value": "Snow", "type": "hit"}, {"value": " White Murder Case", "type": "text"}]}]}
    {"title": "Snow on the Blades", "year": 2014, "score": 5.0, "highlights": [{"score": 1.3766303062438965, "path": "title", "texts": [{"value": "Snow", "type": "hit"}, {"value": " on the Blades", "type": "text"}]}]}
    {"year": 2013, "title": "The Secret Life of Walter Mitty", "score": 0.0, "highlights": []}
    {"title": "Jurassic World", "year": 2015, "score": 0.0, "highlights": []}
    {"title": "Action Jackson", "year": 2014, "score": 0.0, "highlights": []}
    {"year": 2013, "title": "In Secret", "score": 0.0, "highlights": []}
    {"title": "The Stanford Prison Experiment", "year": 2015, "score": 0.0, "highlights": []}
    {"year": 2014, "title": "The Giver", "score": 0.0, "highlights": []}

    The first four documents in the results have a higher score because the should clause in the query specifies a preference for documents with snow in the title. The should clause also alters the score for the query term snow using the constant option.

3

Run Atlas Search compound queries that alter the score using the boost option.

  1. Create a file named CompoundBoostQuery.java.

  2. Copy and paste the following code into the file.

    The code example performs the following tasks:

    • Imports mongodb packages and dependencies.

    • Establishes a connection to your Atlas cluster.

    • Iterates over the cursor to print the documents that match the query.

    The query uses the following pipeline stages:

    • $search stage to query the collection. The query:

      • Uses the following compound operator clauses:

        • must clause with the range operator to search for movies between the years 2013 to 2015.

        • should clause with the text operator to query for the term snow in the title field and alter the score with the boost option. The boost option multiplies the base score in the results for the search term by 2.

      Specifies the highlight option to return snippets of text from the title field that match the query. The snippets contain matching text specified with type: 'hit', and adjacent text specified with type: 'text'.

    • $limit stage to limit the output to 10 results

    • $project stage to:

      • Exclude all fields except title and year

      • Add two fields named score and highlights

    1import java.util.Arrays;
    2import java.util.List;
    3
    4import static com.mongodb.client.model.Aggregates.limit;
    5import static com.mongodb.client.model.Aggregates.project;
    6import static com.mongodb.client.model.Projections.*;
    7import com.mongodb.client.MongoClient;
    8import com.mongodb.client.MongoClients;
    9import com.mongodb.client.MongoCollection;
    10import com.mongodb.client.MongoDatabase;
    11import org.bson.Document;
    12
    13public class CompoundBoostQuery {
    14  public static void main( String[] args ) {
    15    // define clauses
    16    List<Document> mustClauses =
    17        List.of(
    18            new Document(
    19                "range", new Document("path", "year")
    20                .append("gte", 2013)
    21                .append("lte", 2015)));
    22    List<Document> shouldClauses =
    23        List.of(
    24            new Document(
    25                "text",
    26                new Document("query", "snow")
    27                    .append("path", "title")
    28                    .append("score", new Document("boost", new Document("value", 2)))));
    29    Document highlightOption = new Document("path", "title");
    30    // define query
    31    Document agg =
    32        new Document("$search",
    33            new Document("index", "compound-query-custom-score-tutorial")
    34            .append("compound",
    35                new Document("must", mustClauses).append("should", shouldClauses))
    36            .append("highlight", highlightOption));
    37    // specify connection
    38    String uri = "<connection-string>";
    39    // establish connection and set namespace
    40    try (MongoClient mongoClient = MongoClients.create(uri)) {
    41      MongoDatabase database = mongoClient.getDatabase("sample_mflix");
    42      MongoCollection<Document> collection = database.getCollection("movies");
    43      // run query and print results
    44      collection.aggregate(Arrays.asList(agg, 
    45        limit(10), 
    46        project(fields(
    47          excludeId(), 
    48          include("title", "year"), 
    49          computed("score", new Document("$meta", "searchScore")), 
    50          computed("highlights", new Document("$meta", "searchHighlights"))))))
    51      .forEach(doc -> System.out.println(doc.toJson()));	
    52    }
    53  }
    54}

    This query uses the following compound operator clauses with the boost option to prioritize some fields more than other fields:

    • must clause with the text operator to prioritize the genre comedy the most, followed by the term snow in the title field. The boost option applies weights to the fields.

    • should clause with the range operator to search for movies between the years 2013 to 2015.

    Note

    The boost option applies different weights to the fields to prioritize the fields.

    1import java.util.Arrays;
    2import static com.mongodb.client.model.Filters.eq;
    3import static com.mongodb.client.model.Aggregates.limit;
    4import static com.mongodb.client.model.Aggregates.project;
    5import static com.mongodb.client.model.Projections.computed;
    6import static com.mongodb.client.model.Projections.excludeId;
    7import static com.mongodb.client.model.Projections.fields;
    8import static com.mongodb.client.model.Projections.include;
    9import com.mongodb.client.MongoClient;
    10import com.mongodb.client.MongoClients;
    11import com.mongodb.client.MongoCollection;
    12import com.mongodb.client.MongoDatabase;
    13import org.bson.Document;
    14
    15public class CompoundBoostQuery {
    16	public static void main( String[] args ) {
    17		Document agg = new Document("index", "compound-query-custom-score-tutorial")
    18              .append("must", Arrays.asList(new Document("text", 
    19                new Document("path", "genres")
    20                .append("query", "comedy")
    21                .append("score", 
    22        new Document("boost", 
    23        new Document("value", 9)))), 
    24        new Document("text", 
    25        new Document("path", "title")
    26                .append("query", "snow")
    27                .append("score", 
    28        new Document("boost", 
    29        new Document("value", 5))))))
    30    .append("should", Arrays.asList(new Document("range", 
    31        new Document("path", "year")
    32                .append("gte", 2013)
    33                .append("lte", 2015)
    34                .append("score", 
    35        new Document("boost", 
    36        new Document("value", 3))))));
    37		
    38		String uri = "<connection-string>";
    39
    40		try (MongoClient mongoClient = MongoClients.create(uri)) {
    41			MongoDatabase database = mongoClient.getDatabase("sample_mflix");
    42			MongoCollection<Document> collection = database.getCollection("movies");
    43					
    44			collection.aggregate(Arrays.asList(
    45					eq("$search", eq("compound", agg)), 
    46					limit(10), 
    47					project(fields(excludeId(), include("title", "year","genres"), computed("score", new Document("$meta", "searchScore")))))
    48			).forEach(doc -> System.out.println(doc.toJson()));	
    49		}
    50	}
    51}

    Note

    To run the sample code in your Maven environment, add the following above the import statements in your file.

    package com.mongodb.drivers;

  3. Before you run the sample, replace <connection-string> with your Atlas connection string. Ensure that your connection string includes your database user's credentials. To learn more, see Connect via Drivers.

  4. Compile and run CompoundBoostQuery.java file.

    javac CompoundBoostQuery.java
    java CompoundBoostQuery
    {"title": "Snow in Paradise", "year": 2014, "score": 6.7722930908203125, "highlights": [{"score": 1.382846713066101, "path": "title", "texts": [{"value": "Snow", "type": "hit"}, {"value": " in Paradise", "type": "text"}]}]}
    {"title": "Snow on the Blades", "year": 2014, "score": 6.063445568084717, "highlights": [{"score": 1.3766303062438965, "path": "title", "texts": [{"value": "Snow", "type": "hit"}, {"value": " on the Blades", "type": "text"}]}]}
    {"title": "The Snow White Murder Case", "year": 2014, "score": 5.509652137756348, "highlights": [{"score": 1.3525336980819702, "path": "title", "texts": [{"value": "The ", "type": "text"}, {"value": "Snow", "type": "hit"}, {"value": " White Murder Case", "type": "text"}]}]}
    {"title": "Dead Snow 2: Red vs. Dead", "year": 2014, "score": 5.065053939819336, "highlights": [{"score": 1.3924485445022583, "path": "title", "texts": [{"value": "Dead ", "type": "text"}, {"value": "Snow", "type": "hit"}, {"value": " 2: Red vs. ", "type": "text"}]}]}
    {"year": 2013, "title": "The Secret Life of Walter Mitty", "score": 1.0, "highlights": []}
    {"title": "Jurassic World", "year": 2015, "score": 1.0, "highlights": []}
    {"title": "Action Jackson", "year": 2014, "score": 1.0, "highlights": []}
    {"year": 2013, "title": "In Secret", "score": 1.0, "highlights": []}
    {"title": "The Stanford Prison Experiment", "year": 2015, "score": 1.0, "highlights": []}
    {"year": 2014, "title": "The Giver", "score": 1.0, "highlights": []}

    The first four documents in the results have a higher score because the should clause in the query specifies a preference for documents with snow in the title. The should clause also alters the score for the query term snow using the boost option.

    javac CompoundBoostQuery.java
    java CompoundBoostQuery
    {
        "genres": ["Comedy", "Horror"], 
        "title": "Dead Snow", 
        "year": 2009, 
        "score": 21.872983932495117
    }
    {
        "year": 2000, 
        "genres": ["Adventure", "Comedy", "Family"], 
        "title": "Snow Day", 
        "score": 21.043487548828125
    }
    {
        "genres": ["Adventure", "Comedy", "Family"], 
        "title": "Snow Dogs", 
        "year": 2002, 
        "score": 21.043487548828125
    }
    {
        "year": 1999, 
        "genres": ["Comedy", "Romance"], 
        "title": "Let It Snow", 
        "score": 19.523927688598633
    }
    {
        "genres": ["Action", "Comedy", "Horror"], 
        "title": "Dead Snow 2: Red vs. Dead", 
        "year": 2014, 
        "score": 17.426334381103516
    }
    {
        "genres": ["Comedy", "Drama"], 
        "title": "Snow White and Russian Red", 
        "year": 2009, 
        "score": 16.367326736450195}
    {
        "genres": ["Comedy", "Drama", "Romance"], 
        "title": "The Tiger and the Snow", 
        "year": 2005, 
        "score": 15.537829399108887
    }
    {
        "genres": ["Adventure", "Comedy", "Family"], 
        "title": "Snow White and the Three Stooges", 
        "year": 1961, 
        "score": 14.4263334274292
    }
4

Run an Atlas Search compound query that alters the score using the function option.

  1. Create a file named CompoundFunctionQuery.java.

  2. Copy and paste the following code into the file.

    The code example performs the following tasks:

    • Imports mongodb packages and dependencies.

    • Establishes a connection to your Atlas cluster.

    • Uses the following pipeline stages to query the collection:

      • must clause with the range operator to search for movies between the years 2013 to 2015.

      • should clause with the text operator to query for the term snow in the title field and alter the score with the function option. The function option adds the following using an arithmetic expression:

        • The relevance score of the query for the search term

        • The value of the numeric field named imdb.rating or the number 2 for those documents that do not have the imdb.rating field.

    • Uses the following pipeline stages:

      • $limit stage to limit the output to 10 results

      • $project stage to:

        • Exclude all fields except title and year

        • Add two fields named score and highlights

    • Specifies the highlight option to return snippets of text from the title field that match the query. The snippets contain matching text specified with type: 'hit', and adjacent text specified with type: 'text'.

    • Iterates over the cursor to print the documents that match the query.

    1import java.util.Arrays;
    2import java.util.List;
    3
    4import static com.mongodb.client.model.Aggregates.limit;
    5import static com.mongodb.client.model.Aggregates.project;
    6import static com.mongodb.client.model.Projections.*;
    7import com.mongodb.client.MongoClient;
    8import com.mongodb.client.MongoClients;
    9import com.mongodb.client.MongoCollection;
    10import com.mongodb.client.MongoDatabase;
    11import org.bson.Document;
    12
    13public class CompoundFunctionQuery {
    14  public static void main( String[] args ) {
    15    // define clauses
    16    List<Document> mustClauses =
    17        List.of(
    18            new Document("range", new Document("path", "year")
    19            .append("gte", 2013)
    20            .append("lte", 2015)));
    21    List<Document> shouldClauses =
    22        List.of(
    23            new Document("text",
    24                new Document("query", "snow")
    25                    .append("path", "title")
    26                    .append("score", new Document("function", 
    27                        new Document("add", Arrays.asList(
    28                            new Document("path", new Document("value", "imdb.rating")
    29                            .append("undefined", 2)), new Document("score", "relevance")))))));
    30    Document highlightOption = new Document("path", "title");
    31    // define query
    32    Document agg =
    33        new Document("$search",
    34            new Document("index", "compound-query-custom-score-tutorial")
    35            .append("compound",
    36                new Document("must", mustClauses).append("should", shouldClauses))
    37            .append("highlight", highlightOption));
    38    // specify connection
    39    String uri = "<connection-string>";
    40    // establish connection and set namespace
    41    try (MongoClient mongoClient = MongoClients.create(uri)) {
    42      MongoDatabase database = mongoClient.getDatabase("sample_mflix");
    43      MongoCollection<Document> collection = database.getCollection("movies");
    44	  // run query and print results
    45      collection.aggregate(Arrays.asList(agg, 
    46        limit(10),
    47        project(fields(
    48          excludeId(), 
    49          include("title", "year"), 
    50          computed("score", new Document("$meta", "searchScore")), 
    51          computed("highlights", new Document("$meta", "searchHighlights"))))))
    52      .forEach(doc -> System.out.println(doc.toJson()));	
    53    }
    54  }
    55}

    Note

    To run the sample code in your Maven environment, add the following above the import statements in your file.

    package com.mongodb.drivers;

  3. Before you run the sample, replace <connection-string> with your Atlas connection string. Ensure that your connection string includes your database user's credentials. To learn more, see Connect via Drivers.

  4. Compile and run CompoundFunctionQuery.java file.

    javac CompoundFunctionQuery.java
    java CompoundFunctionQuery
    {"title": "The Snow White Murder Case", "year": 2014, "score": 10.454826354980469, "highlights": [{"score": 1.3525336980819702, "path": "title", "texts": [{"value": "The ", "type": "text"}, {"value": "Snow", "type": "hit"}, {"value": " White Murder Case", "type": "text"}]}]}
    {"title": "Snow on the Blades", "year": 2014, "score": 10.3317232131958, "highlights": [{"score": 1.3766303062438965, "path": "title", "texts": [{"value": "Snow", "type": "hit"}, {"value": " on the Blades", "type": "text"}]}]}
    {"title": "Dead Snow 2: Red vs. Dead", "year": 2014, "score": 10.032526969909668, "highlights": [{"score": 1.3924485445022583, "path": "title", "texts": [{"value": "Dead ", "type": "text"}, {"value": "Snow", "type": "hit"}, {"value": " 2: Red vs. ", "type": "text"}]}]}
    {"title": "Snow in Paradise", "year": 2014, "score": 8.386146545410156, "highlights": [{"score": 1.382846713066101, "path": "title", "texts": [{"value": "Snow", "type": "hit"}, {"value": " in Paradise", "type": "text"}]}]}
    {"year": 2013, "title": "The Secret Life of Walter Mitty", "score": 1.0, "highlights": []}
    {"title": "Jurassic World", "year": 2015, "score": 1.0, "highlights": []}
    {"title": "Action Jackson", "year": 2014, "score": 1.0, "highlights": []}
    {"year": 2013, "title": "In Secret", "score": 1.0, "highlights": []}
    {"title": "The Stanford Prison Experiment", "year": 2015, "score": 1.0, "highlights": []}
    {"year": 2014, "title": "The Giver", "score": 1.0, "highlights": []}

    The first four documents in the results have a higher score because the should clause in the query specifies a preference for documents with snow in the title. The should clause also alters the score for the query term snow using the function option.

1

Ensure that you add the following dependency to your project.

mongodb-driver-kotlin-coroutine
4.10.0 or higher version
2

Run an Atlas Search compound query that alters the score using the constant option.

  1. Create a file named CompoundConstantQuery.kt.

  2. Copy and paste the following code into the file.

    The code example performs the following tasks:

    • Imports mongodb packages and dependencies.

    • Establishes a connection to your Atlas cluster.

    • Uses the following compound clauses to query the collection:

      • filter clause with the range operator to search for movies between the years 2013 to 2015.

      • should clause with the text operator to query for the term snow in the title field and alter the score with the constant option. The constant option replaces all score results for the search term with 5.

    • Specifies the highlight option to return snippets of text from the title field that match the query. The snippets contain matching text specified with type: 'hit', and adjacent text specified with type: 'text'.

    • Uses the following pipeline stages:

      • $limit stage to limit the output to 10 results

      • $project stage to:

        • Exclude all fields except title and year

        • Add two fields named score and highlights

    • Prints the documents that match the query from the AggregateFlow instance.

    1import com.mongodb.client.model.Aggregates.limit
    2import com.mongodb.client.model.Aggregates.project
    3import com.mongodb.client.model.Projections.*
    4import com.mongodb.kotlin.client.coroutine.MongoClient
    5import kotlinx.coroutines.runBlocking
    6import org.bson.Document
    7
    8fun main() {
    9    // establish connection and set namespace
    10    val uri = "<connection-string>"
    11    val mongoClient = MongoClient.create(uri)
    12    val database = mongoClient.getDatabase("sample_mflix")
    13    val collection = database.getCollection<Document>("movies")
    14
    15    runBlocking {
    16        // define clauses
    17        val mustClauses = listOf(
    18            Document(
    19                "range", Document("path", "year")
    20                    .append("gte", 2013)
    21                    .append("lte", 2015)
    22            )
    23        )
    24
    25        val shouldClauses = listOf(
    26            Document(
    27                "text",
    28                Document("query", "snow")
    29                    .append("path", "title")
    30                    .append("score", Document("constant", Document("value", 5)))
    31            )
    32        )
    33
    34        val highlightOption = Document("path", "title")
    35
    36        // define pipeline
    37        val agg = Document(
    38            "\$search",
    39            Document("index", "compound-query-custom-score-tutorial")
    40                .append(
    41                    "compound",
    42                    Document("must", mustClauses).append("should", shouldClauses)
    43                )
    44                .append("highlight", highlightOption)
    45        )
    46
    47        val resultsFlow = collection.aggregate<Document>(
    48            listOf(
    49                agg,
    50                limit(10),
    51                project(fields(
    52                    excludeId(),
    53                    include("title", "year"),
    54                    computed("score", Document("\$meta", "searchScore")),
    55                    computed("highlights", Document("\$meta", "searchHighlights"))
    56                ))
    57            )
    58        )
    59        resultsFlow.collect { println(it) }
    60    }
    61    mongoClient.close()
    62}

  3. Before you run the sample, replace <connection-string> with your Atlas connection string. Ensure that your connection string includes your database user's credentials. To learn more, see Connect via Drivers.

  4. Run the CompoundConstantQuery.kt file.

    When you run the CompoundConstantQuery.kt program in your IDE, it prints the following documents:

    Document{{title=Snow in Paradise, year=2014, score=6.0, highlights=[Document{{score=1.382846713066101, path=title, texts=[Document{{value=Snow, type=hit}}, Document{{value= in Paradise, type=text}}]}}]}}
    Document{{title=Dead Snow 2: Red vs. Dead, year=2014, score=6.0, highlights=[Document{{score=1.3924485445022583, path=title, texts=[Document{{value=Dead , type=text}}, Document{{value=Snow, type=hit}}, Document{{value= 2: Red vs. , type=text}}]}}]}}
    Document{{title=The Snow White Murder Case, year=2014, score=6.0, highlights=[Document{{score=1.3525336980819702, path=title, texts=[Document{{value=The , type=text}}, Document{{value=Snow, type=hit}}, Document{{value= White Murder Case, type=text}}]}}]}}
    Document{{title=Snow on the Blades, year=2014, score=6.0, highlights=[Document{{score=1.3766303062438965, path=title, texts=[Document{{value=Snow, type=hit}}, Document{{value= on the Blades, type=text}}]}}]}}
    Document{{year=2013, title=The Secret Life of Walter Mitty, score=1.0, highlights=[]}}
    Document{{title=Jurassic World, year=2015, score=1.0, highlights=[]}}
    Document{{title=Action Jackson, year=2014, score=1.0, highlights=[]}}
    Document{{year=2013, title=In Secret, score=1.0, highlights=[]}}
    Document{{title=The Stanford Prison Experiment, year=2015, score=1.0, highlights=[]}}
    Document{{year=2014, title=The Giver, score=1.0, highlights=[]}}

    The first four documents in the results have a higher score because the should clause in the query specifies a preference for documents with snow in the title. The should clause also alters the score for the query term snow using the constant option.

3

Run Atlas Search compound queries that alter the score using the boost option.

  1. Create a file named CompoundBoostQuery.kt.

  2. Copy and paste the following code into the file.

    The code example performs the following tasks:

    • Imports mongodb packages and dependencies.

    • Establishes a connection to your Atlas cluster.

    • Prints the documents that match the query from the AggregateFlow instance.

    The query uses the following pipeline stages:

    • $search stage to query the collection. The query:

      • Uses the following compound operator clauses:

        • must clause with the range operator to search for movies between the years 2013 to 2015.

        • should clause with the text operator to query for the term snow in the title field and alter the score with the boost option. The boost option multiplies the base score in the results for the search term by 2.

      Specifies the highlight option to return snippets of text from the title field that match the query. The snippets contain matching text specified with type: 'hit', and adjacent text specified with type: 'text'.

    • $limit stage to limit the output to 10 results

    • $project stage to:

      • Exclude all fields except title and year

      • Add two fields named score and highlights

    1import com.mongodb.client.model.Aggregates.limit
    2import com.mongodb.client.model.Aggregates.project
    3import com.mongodb.client.model.Projections.*
    4import com.mongodb.kotlin.client.coroutine.MongoClient
    5import kotlinx.coroutines.runBlocking
    6import org.bson.Document
    7
    8fun main() {
    9    // establish connection and set namespace
    10    val uri = "<connection-string>"
    11    val mongoClient = MongoClient.create(uri)
    12
    13    val database = mongoClient.getDatabase("sample_mflix")
    14    val collection = database.getCollection<Document>("movies")
    15
    16    runBlocking {
    17        // define clauses
    18        val mustClauses = listOf(
    19            Document(
    20                "range", Document("path", "year")
    21                    .append("gte", 2013)
    22                    .append("lte", 2015)
    23            )
    24        )
    25
    26        val shouldClauses = listOf(
    27            Document(
    28                "text",
    29                Document("query", "snow")
    30                .append("path", "title")
    31                .append("score", Document("boost", Document("value", 2)))
    32            )
    33        )
    34
    35        val highlightOption = Document("path", "title")
    36
    37        // define pipeline
    38        val agg = Document(
    39            "\$search",
    40            Document("index", "compound-query-custom-score-tutorial")
    41                .append(
    42                    "compound",
    43                    Document("must", mustClauses).append("should", shouldClauses)
    44                )
    45                .append("highlight", highlightOption)
    46        )
    47
    48        // run query and print results
    49        val resultsFlow = collection.aggregate<Document>(
    50            listOf(
    51                agg,
    52                limit(10),
    53                project(fields(
    54                    excludeId(),
    55                    include("title", "year"),
    56                    computed("score", Document("\$meta", "searchScore")),
    57                    computed("highlights", Document("\$meta", "searchHighlights"))
    58                ))
    59            )
    60        )
    61        resultsFlow.collect { println(it) }
    62    }
    63    mongoClient.close()
    64}

    This query uses the following compound operator clauses with the boost option to prioritize some fields more than other fields:

    • must clause with the text operator to prioritize the genre comedy the most, followed by the term snow in the title field. The boost option applies weights to the fields.

    • should clause with the range operator to search for movies between the years 2013 to 2015.

    Note

    The boost option applies different weights to the fields to prioritize the fields.

    1import com.mongodb.client.model.Aggregates.limit
    2import com.mongodb.client.model.Aggregates.project
    3import com.mongodb.client.model.Projections.*
    4import com.mongodb.kotlin.client.coroutine.MongoClient
    5import kotlinx.coroutines.runBlocking
    6import org.bson.Document
    7
    8fun main() {
    9    // establish connection and set namespace
    10    val uri = "<connection-string>"
    11    val mongoClient = MongoClient.create(uri)
    12
    13    val database = mongoClient.getDatabase("sample_mflix")
    14    val collection = database.getCollection<Document>("movies")
    15
    16    runBlocking {
    17        // define pipeline
    18        val agg = Document(
    19            "\$search",
    20            Document("index", "compound-query-custom-score-tutorial")
    21                .append(
    22                    "compound",
    23                    Document(
    24                        "must", listOf(
    25                            Document(
    26                                "text",
    27                                Document("path", "genres")
    28                                    .append("query", "comedy")
    29                                    .append(
    30                                        "score",
    31                                        Document(
    32                                            "boost",
    33                                            Document("value", 9)
    34                                        )
    35                                    )
    36                            ),
    37                            Document(
    38                                "text",
    39                                Document("path", "title")
    40                                    .append("query", "snow")
    41                                    .append(
    42                                        "score",
    43                                        Document(
    44                                            "boost",
    45                                            Document("value", 5)
    46                                        )
    47                                    )
    48                            )
    49                        )
    50                    )
    51                        .append(
    52                            "should", listOf(
    53                                Document(
    54                                    "range",
    55                                    Document("path", "year")
    56                                        .append("gte", 2013)
    57                                        .append("lte", 2015)
    58                                        .append(
    59                                            "score",
    60                                            Document(
    61                                                "boost",
    62                                                Document("value", 3)
    63                                            )
    64                                        )
    65                                )
    66                            )
    67                        )
    68                )
    69        )
    70
    71        // run query and print results
    72        val resultsFlow = collection.aggregate<Document>(
    73            listOf(
    74                agg,
    75                limit(10),
    76                project(fields(
    77                    excludeId(),
    78                    include("title", "year","genres"),
    79                    computed("score", Document("\$meta", "searchScore"))
    80                ))
    81            )
    82        )
    83        resultsFlow.collect { println(it) }
    84    }
    85    mongoClient.close()
    86}

  3. Before you run the sample, replace <connection-string> with your Atlas connection string. Ensure that your connection string includes your database user's credentials. To learn more, see Connect via Drivers.

  4. Run the CompoundBoostQuery.kt file.

    When you run the CompoundBoostQuery.kt program in your IDE, it prints the following documents:

    Document{{title=Snow in Paradise, year=2014, score=6.784297466278076, highlights=[Document{{score=1.382846713066101, path=title, texts=[Document{{value=Snow, type=hit}}, Document{{value= in Paradise, type=text}}]}}]}}
    Document{{title=Snow on the Blades, year=2014, score=6.073266506195068, highlights=[Document{{score=1.3766303062438965, path=title, texts=[Document{{value=Snow, type=hit}}, Document{{value= on the Blades, type=text}}]}}]}}
    Document{{title=The Snow White Murder Case, year=2014, score=5.517906188964844, highlights=[Document{{score=1.3525336980819702, path=title, texts=[Document{{value=The , type=text}}, Document{{value=Snow, type=hit}}, Document{{value= White Murder Case, type=text}}]}}]}}
    Document{{title=Dead Snow 2: Red vs. Dead, year=2014, score=5.072136878967285, highlights=[Document{{score=1.3924485445022583, path=title, texts=[Document{{value=Dead , type=text}}, Document{{value=Snow, type=hit}}, Document{{value= 2: Red vs. , type=text}}]}}]}}
    Document{{year=2013, title=The Secret Life of Walter Mitty, score=1.0, highlights=[]}}
    Document{{title=Jurassic World, year=2015, score=1.0, highlights=[]}}
    Document{{title=Action Jackson, year=2014, score=1.0, highlights=[]}}
    Document{{year=2013, title=In Secret, score=1.0, highlights=[]}}
    Document{{title=The Stanford Prison Experiment, year=2015, score=1.0, highlights=[]}}
    Document{{year=2014, title=The Giver, score=1.0, highlights=[]}}

    The first four documents in the results have a higher score because the should clause in the query specifies a preference for documents with snow in the title. The should clause also alters the score for the query term snow using the boost option.

    When you run the CompoundBoostQuery.kt program in your IDE, it prints the following documents:

    Document{{year=2000, genres=[Adventure, Comedy, Family], title=Snow Day, score=20.998544692993164}}
    Document{{genres=[Adventure, Comedy, Family], title=Snow Dogs, year=2002, score=20.998544692993164}}
    Document{{year=1999, genres=[Comedy, Romance], title=Let It Snow, score=19.45327377319336}}
    Document{{genres=[Action, Comedy, Horror], title=Dead Snow 2: Red vs. Dead, year=2014, score=17.361087799072266}}
    Document{{genres=[Comedy, Drama], title=Snow White and Russian Red, year=2009, score=16.287294387817383}}
    Document{{genres=[Comedy, Drama, Romance], title=The Tiger and the Snow, year=2005, score=15.475509643554688}}
    Document{{genres=[Adventure, Comedy, Family], title=Snow White and the Three Stooges, year=1961, score=14.361087799072266}}
4

Run an Atlas Search compound query that alters the score using the function option.

  1. Create a file named CompoundFunctionQuery.kt.

  2. Copy and paste the following code into the file.

    The code example performs the following tasks:

    • Imports mongodb packages and dependencies.

    • Establishes a connection to your Atlas cluster.

    • Uses the following pipeline stages to query the collection:

      • must clause with the range operator to search for movies between the years 2013 to 2015.

      • should clause with the text operator to query for the term snow in the title field and alter the score with the function option. The function option adds the following using an arithmetic expression:

        • The relevance score of the query for the search term

        • The value of the numeric field named imdb.rating or the number 2 for those documents that do not have the imdb.rating field.

    • Uses the following pipeline stages:

      • $limit stage to limit the output to 10 results

      • $project stage to:

        • Exclude all fields except title and year

        • Add two fields named score and highlights

    • Specifies the highlight option to return snippets of text from the title field that match the query. The snippets contain matching text specified with type: 'hit', and adjacent text specified with type: 'text'.

    • Prints the documents that match the query from the AggregateFlow instance.

    1import com.mongodb.client.model.Aggregates.limit
    2import com.mongodb.client.model.Aggregates.project
    3import com.mongodb.client.model.Projections.*
    4import com.mongodb.kotlin.client.coroutine.MongoClient
    5import kotlinx.coroutines.runBlocking
    6import org.bson.Document
    7
    8fun main() {
    9    // establish connection and set namespace
    10    val uri = "<connection-string>"
    11    val mongoClient = MongoClient.create(uri)
    12
    13    val database = mongoClient.getDatabase("sample_mflix")
    14    val collection = database.getCollection<Document>("movies")
    15
    16    runBlocking {
    17        // define clauses
    18        val mustClauses = listOf(
    19            Document(
    20                "range", Document("path", "year")
    21                    .append("gte", 2013)
    22                    .append("lte", 2015)
    23            )
    24        )
    25
    26        val shouldClauses = listOf(
    27            Document("text", Document("query", "snow")
    28                .append("path", "title")
    29                .append("score",
    30                    Document("function", Document("add", listOf(
    31                        Document("path", Document("value", "imdb.rating").append("undefined", 2)),
    32                        Document("score", "relevance")
    33                    )))
    34                )
    35            )
    36        )
    37
    38        val highlightOption = Document("path", "title")
    39
    40        // define pipeline
    41        val agg = Document(
    42            "\$search",
    43            Document("index", "compound-query-custom-score-tutorial")
    44                .append(
    45                    "compound",
    46                    Document("must", mustClauses).append("should", shouldClauses)
    47                )
    48                .append("highlight", highlightOption)
    49        )
    50
    51        // run query and print results
    52        val resultsFlow = collection.aggregate<Document>(
    53            listOf(
    54                agg,
    55                limit(10),
    56                project(fields(
    57                    excludeId(),
    58                    include("title", "year"),
    59                    computed("score", Document("\$meta", "searchScore")),
    60                    computed("highlights", Document("\$meta", "searchHighlights"))
    61                ))
    62            )
    63        )
    64        resultsFlow.collect { println(it) }
    65    }
    66    mongoClient.close()
    67}

  3. Before you run the sample, replace <connection-string> with your Atlas connection string. Ensure that your connection string includes your database user's credentials. To learn more, see Connect via Drivers.

  4. Run the CompoundFunctionQuery.kt file.

    When you run the CompoundFunctionQuery.kt program in your IDE, it prints the following documents:

    Document{{title=The Snow White Murder Case, year=2014, score=10.458952903747559, highlights=[Document{{score=1.3525336980819702, path=title, texts=[Document{{value=The , type=text}}, Document{{value=Snow, type=hit}}, Document{{value= White Murder Case, type=text}}]}}]}}
    Document{{title=Snow on the Blades, year=2014, score=10.336633682250977, highlights=[Document{{score=1.3766303062438965, path=title, texts=[Document{{value=Snow, type=hit}}, Document{{value= on the Blades, type=text}}]}}]}}
    Document{{title=Dead Snow 2: Red vs. Dead, year=2014, score=10.036067962646484, highlights=[Document{{score=1.3924485445022583, path=title, texts=[Document{{value=Dead , type=text}}, Document{{value=Snow, type=hit}}, Document{{value= 2: Red vs. , type=text}}]}}]}}
    Document{{title=Snow in Paradise, year=2014, score=8.392148971557617, highlights=[Document{{score=1.382846713066101, path=title, texts=[Document{{value=Snow, type=hit}}, Document{{value= in Paradise, type=text}}]}}]}}
    Document{{year=2013, title=The Secret Life of Walter Mitty, score=1.0, highlights=[]}}
    Document{{title=Jurassic World, year=2015, score=1.0, highlights=[]}}
    Document{{title=Action Jackson, year=2014, score=1.0, highlights=[]}}
    Document{{year=2013, title=In Secret, score=1.0, highlights=[]}}
    Document{{title=The Stanford Prison Experiment, year=2015, score=1.0, highlights=[]}}
    Document{{year=2014, title=The Giver, score=1.0, highlights=[]}}

    The first four documents in the results have a higher score because the should clause in the query specifies a preference for documents with snow in the title. The should clause also alters the score for the query term snow using the function option.

1

Run an Atlas Search compound query that alters the score using the constant option.

  1. Create a file named compound-constant-query.js.

  2. Copy and paste the code example into the compound-constant-query.js file.

    The code example performs the following tasks:

    • Imports mongodb, MongoDB's Node.js driver.

    • Creates an instance of the MongoClient class to establish a connection to your Atlas cluster.

    • Uses the following compound clauses to query the collection:

      • filter clause with the range operator to search for movies between the years 2013 to 2015.

      • should clause with the text operator to query for the term snow in the title field and alter the score with the constant option. The constant option replaces all score results for the search term with 5.

    • Specifies the highlight option to return snippets of text from the title field that match the query. The snippets contain matching text specified with type: 'hit', and adjacent text specified with type: 'text'.

    • Uses the following pipeline stages:

      • $limit stage to limit the output to 10 results

      • $project stage to:

        • Exclude all fields except title and year

        • Add two fields named score and highlights

    • Iterates over the cursor to print the documents that match the query.

    1const MongoClient = require("mongodb").MongoClient;
    2const assert = require("assert");
    3
    4const agg = [
    5  {
    6    '$search': {
    7      'index': 'compound-query-custom-score-tutorial',
    8      'compound': {
    9        'filter': [
    10          {
    11            'range': {
    12              'path': 'year',
    13              'gte': 2013,
    14              'lte': 2015
    15            }
    16          }
    17        ],
    18        'should': [
    19          {
    20            'text': {
    21              'query': 'snow',
    22              'path': 'title',
    23              'score': {
    24                'constant': {
    25                  'value': 5
    26                }
    27              }
    28            }
    29          }
    30        ]
    31      },
    32      'highlight': {
    33        'path': 'title'
    34      }
    35    }
    36  }, {
    37    '$limit': 10
    38  }, {
    39    '$project': {
    40      '_id': 0,
    41      'title': 1,
    42      'year': 1,
    43      'score': {
    44        '$meta': 'searchScore'
    45      },
    46      'highlights': {
    47        '$meta': 'searchHighlights'
    48      }
    49    }
    50  }
    51];
    52
    53MongoClient.connect(
    54  "<connection-string>",
    55  { useNewUrlParser: true, useUnifiedTopology: true },
    56  async function (connectErr, client) {
    57    assert.equal(null, connectErr);
    58    const coll = client.db("sample_mflix").collection("movies");
    59    let cursor = await coll.aggregate(agg);
    60    await cursor.forEach((doc) => console.log(doc));
    61    client.close();
    62  }
    63);

  3. Before you run the sample, replace <connection-string> with your Atlas connection string. Ensure that your connection string includes your database user's credentials. To learn more, see Connect via Drivers.

  4. Run the following command to query your collection:

    node compound-constant-query.js
    '{"title":"Snow in Paradise","year":2014,"score":5,"highlights":[{"score":1.382846713066101,"path":"title","texts":[{"value":"Snow","type":"hit"},{"value":" in Paradise","type":"text"}]}]}'
    '{"title":"Dead Snow 2: Red vs. Dead","year":2014,"score":5,"highlights":[{"score":1.3924485445022583,"path":"title","texts":[{"value":"Dead ","type":"text"},{"value":"Snow","type":"hit"},{"value":" 2: Red vs. ","type":"text"}]}]}'
    '{"title":"The Snow White Murder Case","year":2014,"score":5,"highlights":[{"score":1.3525336980819702,"path":"title","texts":[{"value":"The ","type":"text"},{"value":"Snow","type":"hit"},{"value":" White Murder Case","type":"text"}]}]}'
    '{"title":"Snow on the Blades","year":2014,"score":5,"highlights":[{"score":1.3766303062438965,"path":"title","texts":[{"value":"Snow","type":"hit"},{"value":" on the Blades","type":"text"}]}]}'
    '{"year":2013,"title":"The Secret Life of Walter Mitty","score":0,"highlights":[]}'
    '{"title":"Jurassic World","year":2015,"score":0,"highlights":[]}'
    '{"title":"Action Jackson","year":2014,"score":0,"highlights":[]}'
    '{"year":2013,"title":"In Secret","score":0,"highlights":[]}'
    '{"title":"The Stanford Prison Experiment","year":2015,"score":0,"highlights":[]}'
    '{"year":2014,"title":"The Giver","score":0,"highlights":[]}'

    The first four documents in the results have a higher score because the should clause in the query specifies a preference for documents with snow in the title. The should clause also alters the score for the query term snow using the constant option.

2

Run an Atlas Search compound query that alters the score using the boost option.

  1. Create a file named compound-boost-query.js.

  2. Copy and paste the code example into the compound-boost-query.js file.

    The code example performs the following tasks:

    • Imports mongodb, MongoDB's Node.js driver.

    • Creates an instance of the MongoClient class to establish a connection to your Atlas cluster.

    • Iterates over the cursor to print the documents that match the query.

    The query uses the following pipeline stages:

    • $search stage to query the collection. The query:

      • Uses the following compound operator clauses:

        • must clause with the range operator to search for movies between the years 2013 to 2015.

        • should clause with the text operator to query for the term snow in the title field and alter the score with the boost option. The boost option multiplies the base score in the results for the search term by 2.

      • Specifies the highlight option to return snippets of text from the title field that match the query. The snippets contain matching text specified with type: 'hit', and adjacent text specified with type: 'text'.

    • $limit stage to limit the output to 10 results

    • $project stage to:

      • Exclude all fields except title and year

      • Add two fields named score and highlights

    1const MongoClient = require("mongodb").MongoClient;
    2const assert = require("assert");
    3
    4const agg = [
    5  {
    6    '$search': {
    7      'index': 'compound-query-custom-score-tutorial',
    8      'compound': {
    9        'must': [
    10          {
    11            'range': {
    12              'path': 'year',
    13              'gte': 2013,
    14              'lte': 2015
    15            }
    16          }
    17        ],
    18        'should': [
    19          {
    20            'text': {
    21              'query': 'snow',
    22              'path': 'title',
    23              'score': {
    24                'boost': {
    25                  'value': 2
    26                }
    27              }
    28            }
    29          }
    30        ]
    31      }
    32    }
    33  }, {
    34    '$limit': 10
    35  }, {
    36    '$project': {
    37      '_id': 0,
    38      'title': 1,
    39      'year': 1,
    40      'score': {
    41        '$meta': 'searchScore'
    42      }
    43    }
    44  }
    45];
    46
    47MongoClient.connect(
    48  "<connection-string>",
    49  { useNewUrlParser: true, useUnifiedTopology: true },
    50  async function (connectErr, client) {
    51    assert.equal(null, connectErr);
    52    const coll = client.db("sample_mflix").collection("movies");
    53    let cursor = await coll.aggregate(agg);
    54    await cursor.forEach((doc) => console.log(doc));
    55    client.close();
    56  }
    57);

    The query uses the following pipeline stages:

    • $search stage to query the collection. The query:

      • Uses the following compound operator clauses with the boost option to prioritize some fields more than other fields:

        • must clause with the text operator to prioritize the genre comedy the most, followed by the term snow in the title field. The boost option applies weights to the fields.

        • should clause with the range operator to search for movies between the years 2013 to 2015.

        Note

        The boost option applies different weights to the fields to prioritize the fields.

      • $limit stage to limit the output to 10 results

      • $project stage to:

        • Exclude all fields except title and year

        • Add two fields named score and highlights

    1const MongoClient = require("mongodb").MongoClient;
    2const assert = require("assert");
    3
    4const agg = [
    5  {
    6    '$search': {
    7      'index': 'compound-query-custom-score-tutorial',
    8      'compound': {
    9        'must': [
    10          {
    11            'text': {
    12              'path': 'genres',
    13              'query': 'comedy',
    14              'score': {
    15                'boost': {
    16                  'value': 9
    17                }
    18              }
    19            }
    20          }, {
    21            'text': {
    22              'path': 'title',
    23              'query': 'snow',
    24              'score': {
    25                'boost': {
    26                  'value': 5
    27                }
    28              }
    29            }
    30          }
    31        ],
    32        'should': [
    33          {
    34            'range': {
    35              'path': 'year',
    36              'gte': 2013,
    37              'lte': 2015,
    38              'score': {
    39                'boost': {
    40                  'value': 3
    41                }
    42              }
    43            }
    44          }
    45        ]
    46      }
    47    }
    48  }, {
    49    '$limit': 10
    50  }, {
    51    '$project': {
    52      '_id': 0,
    53      'title': 1,
    54      'year': 1,
    55      'genres': 1,
    56      'score': {
    57        '$meta': 'searchScore'
    58      }
    59    }
    60  }
    61];
    62
    63MongoClient.connect(
    64  "<connection-string>",
    65  { useNewUrlParser: true, useUnifiedTopology: true },
    66  async function (connectErr, client) {
    67    assert.equal(null, connectErr);
    68    const coll = client.db("sample_mflix").collection("movies");
    69    let cursor = await coll.aggregate(agg);
    70    await cursor.forEach((doc) => console.log(doc));
    71    client.close();
    72  }
    73);

  3. Before you run the sample, replace <connection-string> with your Atlas connection string. Ensure that your connection string includes your database user's credentials. To learn more, see Connect via Drivers.

  4. Run the following command to query your collection:

    node compound-boost-query.js
    '{"title":"Snow in Paradise","year":2014,"score":6.7722930908203125,"highlights":[{"score":1.382846713066101,"path":"title","texts":[{"value":"Snow","type":"hit"},{"value":" in Paradise","type":"text"}]}]}'
    '{"title":"Snow on the Blades","year":2014,"score":6.063445568084717,"highlights":[{"score":1.3766303062438965,"path":"title","texts":[{"value":"Snow","type":"hit"},{"value":" on the Blades","type":"text"}]}]}'
    '{"title":"The Snow White Murder Case","year":2014,"score":5.509652137756348,"highlights":[{"score":1.3525336980819702,"path":"title","texts":[{"value":"The ","type":"text"},{"value":"Snow","type":"hit"},{"value":" White Murder Case","type":"text"}]}]}'
    '{"title":"Dead Snow 2: Red vs. Dead","year":2014,"score":5.065053939819336,"highlights":[{"score":1.3924485445022583,"path":"title","texts":[{"value":"Dead ","type":"text"},{"value":"Snow","type":"hit"},{"value":" 2: Red vs. ","type":"text"}]}]}'
    '{"year":2013,"title":"The Secret Life of Walter Mitty","score":1,"highlights":[]}'
    '{"title":"Jurassic World","year":2015,"score":1,"highlights":[]}'
    '{"title":"Action Jackson","year":2014,"score":1,"highlights":[]}'
    '{"year":2013,"title":"In Secret","score":1,"highlights":[]}'
    '{"title":"The Stanford Prison Experiment","year":2015,"score":1,"highlights":[]}'
    '{"year":2014,"title":"The Giver","score":1,"highlights":[]}'

    The first four documents in the results have a higher score because the should clause in the query specifies a preference for documents with snow in the title. The should clause also alters the score for the query term snow using the boost option.

    node compound-boost-query.js
      {
        genres: [ 'Comedy', 'Horror' ],
        title: 'Dead Snow',
        year: 2009,
        score: 21.872983932495117
      }
      {
        year: 2000,
        genres: [ 'Adventure', 'Comedy', 'Family' ],
        title: 'Snow Day',
        score: 21.043487548828125
      }
      {
        genres: [ 'Adventure', 'Comedy', 'Family' ],
        title: 'Snow Dogs',
        year: 2002,
        score: 21.043487548828125
      }
      {
        year: 1999,
        genres: [ 'Comedy', 'Romance' ],
        title: 'Let It Snow',
        score: 19.523927688598633
      }
      {
        genres: [ 'Action', 'Comedy', 'Horror' ],
        title: 'Dead Snow 2: Red vs. Dead',
        year: 2014,
        score: 17.426334381103516
      }
      {
        genres: [ 'Comedy', 'Drama' ],
        title: 'Snow White and Russian Red',
        year: 2009,
        score: 16.367326736450195
      }
      {
        genres: [ 'Comedy', 'Drama', 'Romance' ],
        title: 'The Tiger and the Snow',
        year: 2005,
        score: 15.537829399108887
      }
      {
        genres: [ 'Adventure', 'Comedy', 'Family' ],
        title: 'Snow White and the Three Stooges',
        year: 1961,
        score: 14.4263334274292
      }
3

Run an Atlas Search compound query that alters the score using the function option.

  1. Create a file named compound-function-query.js.

  2. Copy and paste the code example into the compound-function-query.js file.

    The code example performs the following tasks:

    • Imports mongodb, MongoDB's Node.js driver.

    • Creates an instance of the MongoClient class to establish a connection to your Atlas cluster.

    • Uses the following compound clauses to query the collection:

      • must clause with the range operator to search for movies between the years 2013 to 2015.

      • should clause with the text operator to query for the term snow in the title field and alter the score with the function option. The function option adds the following using an arithmetic expression:

        • The relevance score of the query for the search term

        • The value of the numeric field named imdb.rating or the number 2 for those documents that do not have the imdb.rating field.

    • Specifies the highlight option to return snippets of text from the title field that match the query. The snippets contain matching text specified with type: 'hit', and adjacent text specified with type: 'text'.

    • Uses the following pipeline stages:

      • $limit stage to limit the output to 10 results

      • $project stage to:

        • Exclude all fields except title and year

        • Add two fields named score and highlights

    • Iterates over the cursor to print the documents that match the query.

    1const MongoClient = require("mongodb").MongoClient;
    2const assert = require("assert");
    3
    4const agg = [
    5    {
    6        '$search': {
    7            'index': 'compound-query-custom-score-tutorial',
    8            'compound': {
    9                'must': [
    10                    {
    11                        'range': {
    12                            'path': 'year',
    13                            'gte': 2013,
    14                            'lte': 2015
    15                        }
    16                    }
    17                ],
    18                'should': [
    19                    {
    20                        'text': {
    21                            'query': 'snow',
    22                            'path': 'title',
    23                            'score': {
    24                                'function': {
    25                                    'add': [
    26                                        {
    27                                            'path': {
    28                                                'value': 'imdb.rating',
    29                                                'undefined': 2
    30                                            }
    31                                        }, {
    32                                            'score': 'relevance'
    33                                        }
    34                                    ]
    35                                }
    36                            }
    37                        }
    38                    }
    39                ]
    40            }
    41        }
    42    }, {
    43        '$limit': 10
    44    }, {
    45      '$project': {
    46        '_id': 0,
    47        'title': 1,
    48        'year': 1,
    49        'score': {
    50          '$meta': 'searchScore'
    51        },
    52        'highlights': {
    53          '$meta': 'searchHighlights'
    54        }
    55      }
    56    }
    57];
    58
    59MongoClient.connect(
    60  "<connection-string>",
    61  { useNewUrlParser: true, useUnifiedTopology: true },
    62  async function (connectErr, client) {
    63    assert.equal(null, connectErr);
    64    const coll = client.db("sample_mflix").collection("movies");
    65    let cursor = await coll.aggregate(agg);
    66    await cursor.forEach((doc) => console.log(doc));
    67    client.close();
    68  }
    69);

  3. Before you run the sample, replace <connection-string> with your Atlas connection string. Ensure that your connection string includes your database user's credentials. To learn more, see Connect via Drivers.

  4. Run the following command to query your collection:

    node compound-function-query.js
    '{"title":"The Snow White Murder Case","year":2014,"score":10.454826354980469,"highlights":[{"score":1.3525336980819702,"path":"title","texts":[{"value":"The ","type":"text"},{"value":"Snow","type":"hit"},{"value":" White Murder Case","type":"text"}]}]}'
    '{"title":"Snow on the Blades","year":2014,"score":10.3317232131958,"highlights":[{"score":1.3766303062438965,"path":"title","texts":[{"value":"Snow","type":"hit"},{"value":" on the Blades","type":"text"}]}]}'
    '{"title":"Dead Snow 2: Red vs. Dead","year":2014,"score":10.032526969909668,"highlights":[{"score":1.3924485445022583,"path":"title","texts":[{"value":"Dead ","type":"text"},{"value":"Snow","type":"hit"},{"value":" 2: Red vs. ","type":"text"}]}]}'
    '{"title":"Snow in Paradise","year":2014,"score":8.386146545410156,"highlights":[{"score":1.382846713066101,"path":"title","texts":[{"value":"Snow","type":"hit"},{"value":" in Paradise","type":"text"}]}]}'
    '{"year":2013,"title":"The Secret Life of Walter Mitty","score":1,"highlights":[]}'
    '{"title":"Jurassic World","year":2015,"score":1,"highlights":[]}'
    '{"title":"Action Jackson","year":2014,"score":1,"highlights":[]}'
    '{"year":2013,"title":"In Secret","score":1,"highlights":[]}'
    '{"title":"The Stanford Prison Experiment","year":2015,"score":1,"highlights":[]}'
    '{"year":2014,"title":"The Giver","score":1,"highlights":[]}'

    The first four documents in the results have a higher score because the should clause in the query specifies a preference for documents with snow in the title. The should clause also alters the score for the query term snow using the function option.

1

Run an Atlas Search compound query that alters the score using the constant option.

  1. Create a file named compound-constant-query.py.

  2. Copy and paste the code example into the compound-constant.py file.

    The following code example:

    • Imports pymongo, MongoDB's Python driver, and the dns module, which is required to connect pymongo to Atlas using a DNS seed list connection string.

    • Creates an instance of the MongoClient class to establish a connection to your Atlas cluster.

    • Uses the following compound clauses to query the collection:

      • filter clause with the range operator to search for movies between the years 2013 to 2015.

      • should clause with the text operator to query for the term snow in the title field and alter the score with the constant option. The constant option replaces all score results for the search term with 5.

    • Specifies the highlight option to return snippets of text from the title field that match the query. The snippets contain matching text specified with type: 'hit', and adjacent text specified with type: 'text'.

    • Uses the following pipeline stages:

      • $limit stage to limit the output to 10 results

      • $project stage to:

        • Exclude all fields except title and year

        • Add two fields named score and highlights

    • Iterates over the cursor to print the documents that match the query.

    1import pymongo
    2
    3# connect to your Atlas cluster
    4client = pymongo.MongoClient('<connection-string>')
    5
    6# define pipeline
    7pipeline = [
    8  {'$search': {
    9      'index': 'compound-query-custom-score-tutorial',
    10      'compound': {
    11        'filter': [{'range': {'path': 'year', 'gte': 2013, 'lte': 2015}}],
    12        'should': [{'text': {'query': 'snow', 'path': 'title', 'score': {'constant': {'value': 5}}}}]},
    13      'highlight': {'path': 'title'}}},
    14  {'$limit': 10}, 
    15  {'$project': {'_id': 0, 'title': 1, 'year': 1, 
    16    'score': {'$meta': 'searchScore'}, "highlights": {"$meta": "searchHighlights"}}}
    17]
    18
    19# run pipeline
    20result = client['sample_mflix']['movies'].aggregate(pipeline)
    21
    22# print results
    23for i in result:
    24    print(i)

  3. Before you run the sample, replace <connection-string> with your Atlas connection string. Ensure that your connection string includes your database user's credentials. To learn more, see Connect via Drivers.

  4. Run the following command to query your collection:

    python compound-constant-query.py
    {'highlights': [{'path': 'title', 'score': 1.382846713066101, 'texts': [{'type': 'hit', 'value': 'Snow'}, {'type': 'text', 'value': ' in Paradise'}]}], 'year': 2014, 'score': 5.0, 'title': 'Snow in Paradise'}
    {'highlights': [{'path': 'title', 'score': 1.3924485445022583, 'texts': [{'type': 'text', 'value': 'Dead '}, {'type': 'hit', 'value': 'Snow'}, {'type': 'text', 'value': ' 2: Red vs. '}]}], 'year': 2014, 'score': 5.0, 'title': 'Dead Snow 2: Red vs. Dead'}
    {'highlights': [{'path': 'title', 'score': 1.3525336980819702, 'texts': [{'type': 'text', 'value': 'The '}, {'type': 'hit', 'value': 'Snow'}, {'type': 'text', 'value': ' White Murder Case'}]}], 'year': 2014, 'score': 5.0, 'title': 'The Snow White Murder Case'}
    {'highlights': [{'path': 'title', 'score': 1.3766303062438965, 'texts': [{'type': 'hit', 'value': 'Snow'}, {'type': 'text', 'value': ' on the Blades'}]}], 'year': 2014, 'score': 5.0, 'title': 'Snow on the Blades'}
    {'highlights': [], 'title': 'The Secret Life of Walter Mitty', 'score': 0.0, 'year': 2013}
    {'highlights': [], 'year': 2015, 'score': 0.0, 'title': 'Jurassic World'}
    {'highlights': [], 'year': 2014, 'score': 0.0, 'title': 'Action Jackson'}
    {'highlights': [], 'title': 'In Secret', 'score': 0.0, 'year': 2013}
    {'highlights': [], 'year': 2015, 'score': 0.0, 'title': 'The Stanford Prison Experiment'}
    {'highlights': [], 'title': 'The Giver', 'score': 0.0, 'year': 2014}

    The first four documents in the results have a higher score because the should clause in the query specifies a preference for documents with snow in the title. The should clause also alters the score for the query term snow using the constant option.

2

Run an Atlas Search compound query that alters the score using the boost option.

  1. Create a file named compound-boost-query.py.

  2. Copy and paste the code example into the compound-boost-query.py file.

    The following code example:

    • Imports pymongo, MongoDB's Python driver, and the dns module, which is required to connect pymongo to Atlas using a DNS seed list connection string.

    • Creates an instance of the MongoClient class to establish a connection to your Atlas cluster.

    • Iterates over the cursor to print the documents that match the query.

    The query uses the following pipeline stages:

    • $search stage to query the collection. The query:

      • Uses the following compound operator clauses:

        • must clause with the range operator to search for movies between the years 2013 to 2015.

        • should clause with the text operator to query for the term snow in the title field and alter the score with the boost option. The boost option multiplies the base score in the results for the search term by 2.

        • Specifies the highlight option to return snippets of text from the title field that match the query. The snippets contain matching text specified with type: 'hit', and adjacent text specified with type: 'text'.

    • $limit stage to limit the output to 10 results

    • $project stage to:

      • Exclude all fields except title and year

      • Add two fields named score and highlights

    1import pymongo
    2
    3# connect to your Atlas cluster
    4client = pymongo.MongoClient('<connection-string>')
    5
    6# define pipeline
    7pipeline = [
    8  {'$search': {
    9      'index': 'compound-query-custom-score-tutorial',
    10      'compound': {
    11        'must': [{'range': {'path': 'year', 'gte': 2013, 'lte': 2015}}],
    12        'should': [{'text': {'query': 'snow', 'path': 'title', 'score': {'boost': {'value': 2}}}}]}, 
    13      'highlight': {'path': 'title'}}},
    14  {'$limit': 10}, 
    15  {'$project': {'_id': 0, 'title': 1, 'year': 1, 'score': {'$meta': 'searchScore'}, "highlights": {"$meta": "searchHighlights"}}}
    16]
    17
    18# run pipeline
    19result = client['sample_mflix']['movies'].aggregate(pipeline)
    20
    21# print results
    22for i in result:
    23    print(i)

    The query uses the following pipeline stages:

    • $search stage to query the collection. The query uses the following compound operator clauses with the boost option to prioritize some fields more than other fields:

      • must clause with the text operator to prioritize the genre comedy the most, followed by the term snow in the title field. The boost option applies weights to the fields.

      • should clause with the range operator to search for movies between the years 2013 to 2015.

      Note

      The boost option applies different weights to the fields to prioritize the fields.

    • $limit stage to limit the output to 10 results.

    • $project stage to:

      • Exclude all fields except title, year, and genres

      • Add a field named score

    import pymongo
    import dns
    client = pymongo.MongoClient('<connection-string>')
    result = client['sample_mflix']['movies'].aggregate([
        {
            '$search': {
                'index': 'compound-query-custom-score-tutorial',
                'compound': {
                    'must': [
                        {
                            'text': {
                                'path': 'genres',
                                'query': 'comedy',
                                'score': {
                                    'boost': {
                                        'value': 9
                                    }
                                }
                            }
                        }, {
                            'text': {
                                'path': 'title',
                                'query': 'snow',
                                'score': {
                                    'boost': {
                                        'value': 5
                                    }
                                }
                            }
                        }
                    ],
                    'should': [
                        {
                            'range': {
                                'path': 'year',
                                'gte': 2013,
                                'lte': 2015,
                                'score': {
                                    'boost': {
                                        'value': 3
                                    }
                                }
                            }
                        }
                    ]
                }
            }
        }, {
            '$limit': 10
        }, {
            '$project': {
                '_id': 0,
                'title': 1,
                'year': 1,
                'genres': 1,
                'score': {
                    '$meta': 'searchScore'
                }
            }
        }
    ])
    for i in result:
        print(i)

  3. Before you run the sample, replace <connection-string> with your Atlas connection string. Ensure that your connection string includes your database user's credentials. To learn more, see Connect via Drivers.

  4. Run the following command to query your collection:

    python compound-boost-query.py
    {'highlights': [{'path': 'title', 'score': 1.382846713066101, 'texts': [{'type': 'hit', 'value': 'Snow'}, {'type': 'text', 'value': ' in Paradise'}]}], 'year': 2014, 'score': 6.7722930908203125, 'title': 'Snow in Paradise'}
    {'highlights': [{'path': 'title', 'score': 1.3766303062438965, 'texts': [{'type': 'hit', 'value': 'Snow'}, {'type': 'text', 'value': ' on the Blades'}]}], 'year': 2014, 'score': 6.063445568084717, 'title': 'Snow on the Blades'}
    {'highlights': [{'path': 'title', 'score': 1.3525336980819702, 'texts': [{'type': 'text', 'value': 'The '}, {'type': 'hit', 'value': 'Snow'}, {'type': 'text', 'value': ' White Murder Case'}]}], 'year': 2014, 'score': 5.509652137756348, 'title': 'The Snow White Murder Case'}
    {'highlights': [{'path': 'title', 'score': 1.3924485445022583, 'texts': [{'type': 'text', 'value': 'Dead '}, {'type': 'hit', 'value': 'Snow'}, {'type': 'text', 'value': ' 2: Red vs. '}]}], 'year': 2014, 'score': 5.065053939819336, 'title': 'Dead Snow 2: Red vs. Dead'}
    {'highlights': [], 'title': 'The Secret Life of Walter Mitty', 'score': 1.0, 'year': 2013}
    {'highlights': [], 'year': 2015, 'score': 1.0, 'title': 'Jurassic World'}
    {'highlights': [], 'year': 2014, 'score': 1.0, 'title': 'Action Jackson'}
    {'highlights': [], 'title': 'In Secret', 'score': 1.0, 'year': 2013}
    {'highlights': [], 'year': 2015, 'score': 1.0, 'title': 'The Stanford Prison Experiment'}
    {'highlights': [], 'title': 'The Giver', 'score': 1.0, 'year': 2014}

    The first four documents in the results have a higher score because the should clause in the query specifies a preference for documents with snow in the title. The should clause also alters the score for the query term snow using the boost option.

    python compound-boost-query.py
    {
        'genres': ['Comedy', 'Horror'], 
        'title': 'Dead Snow', 
        'year': 2009, 
        'score': 21.872983932495117
    }
    {
        'year': 2000, 
        'genres': ['Adventure', 'Comedy', 'Family'], 
        'title': 'Snow Day', 
        'score': 21.043487548828125
    }
    {
        'genres': ['Adventure', 'Comedy', 'Family'], 
        'title': 'Snow Dogs', 
        'year': 2002, 
        'score': 21.043487548828125
    }
    {
        'year': 1999, 
        'genres': ['Comedy', 'Romance'], 
        'title': 'Let It Snow', 
        'score': 19.523927688598633
    }
    {
        'genres': ['Action', 'Comedy', 'Horror'], 
        'title': 'Dead Snow 2: Red vs. Dead', 
        'year': 2014, 
        'score': 17.426334381103516
    }
    {
        'genres': ['Comedy', 'Drama'], 
        'title': 'Snow White and Russian Red', 
        'year': 2009, 
        'score': 16.367326736450195
    }
    {
        'genres': ['Comedy', 'Drama', 'Romance'], 
        'title': 'The Tiger and the Snow', 
        'year': 2005, 
        'score': 15.537829399108887
    }
    {
        'genres': ['Adventure', 'Comedy', 'Family'], 
        'title': 'Snow White and the Three Stooges', 
        'year': 1961, 
        'score': 14.4263334274292
    }
3

Run an Atlas Search compound query that alters the score using the function option.

  1. Create a file named compound-function-query.py.

  2. Copy and paste the code example into the compound-function-query.py file.

    The following code example:

    • Imports pymongo, MongoDB's Python driver, and the dns module, which is required to connect pymongo to Atlas using a DNS seed list connection string.

    • Creates an instance of the MongoClient class to establish a connection to your Atlas cluster.

    • Uses the following compound clauses to query the collection:

      • must clause with the range operator to search for movies between the years 2013 to 2015.

      • should clause with the text operator to query for the term snow in the title field and alter the score with the function option. The function option adds the following using an arithmetic expression:

        • The relevance score of the query for the search term

        • The value of the numeric field named imdb.rating or the number 2 for those documents that do not have the imdb.rating field.

    • Specifies the highlight option to return snippets of text from the title field that match the query. The snippets contain matching text specified with type: 'hit', and adjacent text specified with type: 'text'.

    • Uses the following pipeline stages:

      • $limit stage to limit the output to 10 results

      • $project stage to:

        • Exclude all fields except title and year

        • Add two fields named score and highlights

    • Iterates over the cursor to print the documents that match the query.

    1import pymongo
    2
    3# connect to your Atlas cluster
    4client = pymongo.MongoClient('<connection-string>')
    5
    6# define pipeline
    7pipeline = [
    8  {'$search': {
    9      'index': 'compound-query-custom-score-tutorial',
    10      'compound': {
    11        'must': [{'range': {'path': 'year', 'gte': 2013, 'lte': 2015}}],
    12        'should': [{'text': {'query': 'snow', 'path': 'title', 
    13                    'score': {'function': {
    14                        'add': [{'path': {'value': 'imdb.rating','undefined': 2}}, {'score': 'relevance'}]}}}}]},
    15      'highlight': {'path': 'title'}}},
    16  {'$limit': 10}, 
    17  {'$project': {'_id': 0, 'title': 1, 'year': 1, 'score': {'$meta': 'searchScore'}, "highlights": {"$meta": "searchHighlights"}}}
    18]
    19
    20# run pipeline
    21result = client['sample_mflix']['movies'].aggregate(pipeline)
    22
    23# print results
    24for i in result:
    25    print(i)

  3. Before you run the sample, replace <connection-string> with your Atlas connection string. Ensure that your connection string includes your database user's credentials. To learn more, see Connect via Drivers.

  4. Run the following command to query your collection:

    python compound-function-query.py
    {'highlights': [{'path': 'title', 'score': 1.3525336980819702, 'texts': [{'type': 'text', 'value': 'The '}, {'type': 'hit', 'value': 'Snow'}, {'type': 'text', 'value': ' White Murder Case'}]}], 'year': 2014, 'score': 10.454826354980469, 'title': 'The Snow White Murder Case'}
    {'highlights': [{'path': 'title', 'score': 1.3766303062438965, 'texts': [{'type': 'hit', 'value': 'Snow'}, {'type': 'text', 'value': ' on the Blades'}]}], 'year': 2014, 'score': 10.3317232131958, 'title': 'Snow on the Blades'}
    {'highlights': [{'path': 'title', 'score': 1.3924485445022583, 'texts': [{'type': 'text', 'value': 'Dead '}, {'type': 'hit', 'value': 'Snow'}, {'type': 'text', 'value': ' 2: Red vs. '}]}], 'year': 2014, 'score': 10.032526969909668, 'title': 'Dead Snow 2: Red vs. Dead'}
    {'highlights': [{'path': 'title', 'score': 1.382846713066101, 'texts': [{'type': 'hit', 'value': 'Snow'}, {'type': 'text', 'value': ' in Paradise'}]}], 'year': 2014, 'score': 8.386146545410156, 'title': 'Snow in Paradise'}
    {'highlights': [], 'title': 'The Secret Life of Walter Mitty', 'score': 1.0, 'year': 2013}
    {'highlights': [], 'year': 2015, 'score': 1.0, 'title': 'Jurassic World'}
    {'highlights': [], 'year': 2014, 'score': 1.0, 'title': 'Action Jackson'}
    {'highlights': [], 'title': 'In Secret', 'score': 1.0, 'year': 2013}
    {'highlights': [], 'year': 2015, 'score': 1.0, 'title': 'The Stanford Prison Experiment'}
    {'highlights': [], 'title': 'The Giver', 'score': 1.0, 'year': 2014}

    The first four documents in the results have a higher score because the should clause in the query specifies a preference for documents with snow in the title. The should clause also alters the score for the query term snow using the function option.

Run a Compound Query to Bury Results

In this section, you connect to your Atlas cluster and run the sample queries against the title, plot, and genres fields in the movies collection in the sample_mflix database. The sample queries use nested compound operator clauses to perform the following searches:

  • Search for all movies containing the word "ghost", but reduce the score of comedy movies by 50%.

  • Search for all movies containing the word "ghost", but reduce the score of movies with specified ObjectIds by 50%.

1

Go to the Search Tester.

  1. Click the cluster name to view the cluster details.

  2. Click the Atlas Search tab.

  3. Click the Query button to the right of the index to query.

2

View and edit the query syntax.

Click Edit Query to view a default query syntax sample in JSON format.

3

Run an Atlas Search query with the compound operator on the movies collection.

  1. Copy and paste the following query into the Query Editor.

    The query uses the $search compound operator should clause to nest compound operator queries that perform the following actions:

    • Searches for movies that contain the term ghost in the plot or title (must clause) and aren't in the comedy genre (mustNot clause).

    • Searches for movies that contain the term ghost in the plot or title (must clause), but reduces (boost) the score by 50% (0.5) for movies in the comedy genre with the term ghost in the title or plot.

    1[
    2  {
    3    "$search": {
    4      "index": "compound-query-custom-score-tutorial",
    5      "compound": {
    6        "should":[ {
    7          "compound":{
    8            "must":[ 
    9              {
    10                "text": {
    11                  "query": "ghost",
    12                  "path": ["plot","title"]
    13                }
    14              } 
    15            ],
    16            "mustNot":[ 
    17              {
    18                "text": {
    19                  "query": "Comedy",
    20                  "path": ["genres"]
    21                }
    22              } 
    23            ]
    24          }
    25        },
    26        {
    27          "compound":{
    28            "must":[ 
    29              {
    30                "text": {
    31                  "query": "ghost",
    32                  "path": ["plot","title"]
    33                }
    34              } 
    35            ],
    36            "filter":[ 
    37              {
    38                "text": {
    39                  "query": "Comedy",
    40                  "path": ["genres"]
    41                }
    42              } 
    43            ],
    44            "score":{ "boost": { "value": 0.5} }
    45            }
    46          } 
    47        ]
    48      }
    49    }
    50  }
    51]

    The query uses the $search compound operator should clause to nest compound operator queries that perform the following actions:

    • Searches for movies that contain the term ghost in the plot or title (must clause), but doesn't have the specified ObjectIds (mustNot clause).

    • Searches for movies that contain the term ghost in the plot or title (must clause), but reduces (boost) the score by 50% (0.5) for movies with the specified ObjectIds (filter clause).

    1[
    2  {
    3    "$search": {
    4      "index": "compound-query-custom-score-tutorial",        
    5      "compound": {
    6        "should":[ 
    7          {
    8            "compound":{
    9              "must":[ 
    10                {
    11                  "text": {
    12                    "query": "ghost",
    13                    "path": ["plot","title"]
    14                  }
    15                } 
    16              ],
    17              "mustNot":[ 
    18                {
    19                  "in": {
    20                    "value": [ObjectId('573a13cdf29313caabd83c08'), ObjectId('573a13cef29313caabd873a2')],
    21                    "path": "_id"
    22                  }
    23                } 
    24              ]
    25            }
    26          },
    27          {
    28            "compound":{
    29              "must":[ 
    30                {
    31                  "text": {
    32                    "query": "ghost",
    33                    "path": ["plot","title"]
    34                  }
    35                } 
    36              ],
    37              "filter":[ 
    38                {
    39                  "in": {
    40                    "value": [ObjectId('573a13cdf29313caabd83c08'), ObjectId('573a13cef29313caabd873a2')],
    41                    "path": "_id"
    42                  }
    43                } 
    44              ],
    45              "score":{ "boost": { "value": 0.5} }
    46            }
    47          } 
    48        ]
    49      }
    50    }
    51  }
    52]

  2. Click the Search button in the Query Editor.

    1SCORE: 5.909613132476807
    2_id:  “573a139af29313caabcefcce”
    3plot: "Adaption of the famous Oscar Wilde tale about a young American girl th…"
    4genres: Array (3)
    5runtime: 92
    6
    7SCORE: 5.367666244506836
    8_id:  “573a13d8f29313caabda5dc1”
    9plot: "The Little Ghost lives in the castle over looking a small town and awa…"
    10genres: Array (2)
    11runtime: 92
    12
    13SCORE: 4.676314353942871
    14_id:  “573a13c0f29313caabd6139d”
    15plot: "Renowned "ghost hunter", Carter Simms is paid to conduct a paranormal …"
    16genres: Array (2)
    17runtime: 107
    18
    19SCORE: 3.9638845920562744
    20_id:  “573a1398f29313caabcebf6f”
    21plot: "After an accident leaves a young man dead, his spirit stays behind to …"
    22genres: Array (3)
    23runtime: 127
    24
    25SCORE: 3.9638845920562744
    26_id:  “573a13cdf29313caabd83c08”
    27plot: "A man tries to solve his lover's murder by communicating with her spir…"
    28genres: Array (3)
    29runtime: 115
    30
    31SCORE: 3.9638845920562744
    32_id:  “573a13cef29313caabd873a2”
    33plot: "A man tries to solve his lover's murder by communicating with her spir…"
    34genres: Array (3)
    35runtime: 115
    36
    37SCORE: 3.526711940765381
    38_id:  “573a13c3f29313caabd6a149”
    39plot: "What kind of scenes in a horror film scares you the most? When a ghost…"
    40genres: Array (2)
    41runtime: 95
    42
    43SCORE: 3.3177831172943115
    44_id:  “573a1397f29313caabce7ea1”
    45plot: "Four successful elderly gentlemen, members of the Chowder Society, sha…"
    46genres: Array (3)
    47runtime: 110
    48
    49SCORE: 3.3177831172943115
    50_id:  “573a13a4f29313caabd117df”
    51fullplot: "When the motorcyclist Johnny Blaze finds that his father Barton Blaze …"
    52imdb: Object
    53year: 2007
    54
    55SCORE: 3.3177831172943115
    56_id:  “573a13a6f29313caabd185dc”
    57fullplot: "After discovering a passenger ship missing since 1962 floating adrift …"
    58imdb: Object
    59year: 2002

    The movie documents in the results contain the query term ghost in the plot or title field and aren't in the Comedy genre. Atlas Search didn't return documents in the Comedy genre with the term ghost in the plot or title field because those documents didn't rank in the top 10 documents since the query reduced the score of those documents by 50%.

    1SCORE: 5.909613132476807
    2_id:  “573a139af29313caabcefcce”
    3plot: "Adaption of the famous Oscar Wilde tale about a young American girl th…"
    4genres: Array (3)
    5runtime: 92
    6
    7SCORE: 5.367666244506836
    8_id:  “573a13d8f29313caabda5dc1”
    9plot: "The Little Ghost lives in the castle over looking a small town and awa…"
    10genres: Array (2)
    11runtime: 92
    12
    13SCORE: 4.676314353942871
    14_id:  “573a13c0f29313caabd6139d”
    15plot: "Renowned "ghost hunter", Carter Simms is paid to conduct a paranormal …"
    16genres: Array (2)
    17runtime: 107
    18
    19SCORE: 3.9638845920562744
    20_id:  “573a1398f29313caabcebf6f”
    21plot: "After an accident leaves a young man dead, his spirit stays behind to …"
    22genres: Array (3)
    23runtime: 127
    24
    25SCORE: 3.526711940765381
    26_id:  “573a13c3f29313caabd6a149”
    27plot: "What kind of scenes in a horror film scares you the most? When a ghost…"
    28genres:Array (2)
    29runtime: 95
    30
    31SCORE: 3.5241782665252686
    32_id:  “573a1398f29313caabce912c”
    33plot: "Three unemployed parapsychology professors set up shop as a unique gho…"
    34genres: Array (2)
    35runtime: 105
    36
    37SCORE: 3.5241782665252686
    38_id:  “573a139cf29313caabcf5a48”
    39plot: "Casper, a ghost, teams up with Wendy, a witch, against an evil warlock…"
    40genres: Array (3)
    41runtime: 90
    42
    43SCORE: 3.4605300426483154
    44_id:  “573a13bdf29313caabd58274”
    45plot: "Banku, his mother, Anjali Sharma and father move in to their new house…"
    46genres: Array (3)
    47runtime: 150
    48
    49SCORE: 3.3177831172943115
    50_id:  “573a1397f29313caabce7ea1”
    51plot: "Four successful elderly gentlemen, members of the Chowder Society, sha…"
    52genres: Array (3)
    53runtime: 110
    54
    55SCORE: 3.3177831172943115
    56_id:  “573a1398f29313caabcebf79”
    57plot: "Elliot Hopper is a widower with three children, he is currently workin…"
    58genres: Array (3)
    59runtime: 83

    The movie documents in the results contain the query term ghost in the plot or title field and don't have the specified ObjectIds in the _id field. Atlas Search didn't return the documents with the specified ObjectsIds, even though they contain the query term ghost in the title field, because the query reduced the score of these documents by 50% and so, these documents didn't rank in the top 10 documents.

1

Connect to your cluster in mongosh.

Open mongosh in a terminal window and connect to your cluster. For detailed instructions on connecting, see Connect via mongosh.

2

Use the sample_mflix database.

use sample_mflix
switched to db sample_mflix
3

Run the following Atlas Search compound operator queries on the movies collection.

This query uses the following pipeline stages:

  • Searches for movies that contain the term ghost in the plot or title (must clause) and aren't in the comedy genre (mustNot clause).

  • Searches for movies that contain the term ghost in the plot or title (must clause) and are in the comedy genre (filter clause), but reduces the score by 50% (boost).

Limits the number of results to 10 documents.

  • Includes only the _id, title, plot, and genres fields from the documents in the results.

  • Adds a field named score that shows the score in the results.

1db.movies.aggregate([
2    {
3      "$search": {
4        "index": "compound-query-custom-score-tutorial",
5        "compound": {
6          "should": [ 
7            {
8              "compound":{
9                "must": [ 
10                  {
11                    "text": {
12                      "query": "ghost",
13                      "path": ["plot","title"]
14                    }
15                  } 
16                ],
17                "mustNot": [ 
18                  {
19                    "text": {
20                      "query": "Comedy",
21                      "path": ["genres"]
22                    }
23                  } 
24                ]
25              }
26            },
27            {
28              "compound":{
29                "must":[ 
30                  {
31                    "text": {
32                      "query": "ghost",
33                      "path": ["plot","title"]
34                    }
35                  } 
36                ],
37                "filter": [ 
38                  {
39                    "text": {
40                      "query": "Comedy",
41                      "path": ["genres"]
42                    }
43                  } 
44                ],
45                "score": { "boost": { "value": 0.5} }
46              }
47            } 
48          ]
49        }
50      }
51    },
52    {
53      "$limit": 10
54    },
55    {
56      "$project": {
57        "_id": 1,
58        "title": 1,
59        "plot": 1,
60        "genres": 1,
61        "score": { "$meta": "searchScore" }
62      }
63    }
64])
1[
2  {
3    _id: ObjectId('573a139af29313caabcefcce'),
4    plot: 'Adaption of the famous Oscar Wilde tale about a young American girl that helps a British ghost find rest and forgiveness.',
5    genres: [ 'Family', 'Drama', 'Fantasy' ],
6    title: 'The Canterville Ghost',
7    score: 5.909613132476807
8  },
9  {
10    _id: ObjectId('573a13d8f29313caabda5dc1'),
11    plot: 'The Little Ghost lives in the castle over looking a small town and awakens for precisely one hour after the clock strikes midnight. Follow him on this adventure to see his first sunrise ever!',
12    genres: [ 'Family', 'Fantasy' ],
13    title: 'The Little Ghost',
14    score: 5.367666244506836
15  },
16  {
17    _id: ObjectId('573a13c0f29313caabd6139d'),
18    plot: 'Renowned "ghost hunter", Carter Simms is paid to conduct a paranormal investigation of a supposedly haunted house. Along with a cameraman, a reporter, and a spiritual advocate, she embarks on a three night journey into terror.',
19    genres: [ 'Horror', 'Thriller' ],
20    title: 'Death of a Ghost Hunter',
21    score: 4.676314353942871
22  },
23  {
24    _id: ObjectId('573a1398f29313caabcebf6f'),
25    plot: 'After an accident leaves a young man dead, his spirit stays behind to warn his lover of impending danger, with the help of a reluctant psychic.',
26    genres: [ 'Drama', 'Fantasy', 'Romance' ],
27    title: 'Ghost',
28    score: 3.9638845920562744
29  },
30  {
31    _id: ObjectId('573a13cdf29313caabd83c08'),
32    plot: "A man tries to solve his lover's murder by communicating with her spirit through the help of a medium.",
33    genres: [ 'Drama', 'Fantasy', 'Mystery' ],
34    title: 'Ghost',
35    score: 3.9638845920562744
36  },
37  {
38    _id: ObjectId('573a13cef29313caabd873a2'),
39    plot: "A man tries to solve his lover's murder by communicating with her spirit through the help of a medium.",
40    genres: [ 'Drama', 'Fantasy', 'Mystery' ],
41    title: 'Ghost',
42    score: 3.9638845920562744
43  },
44  {
45    _id: ObjectId('573a13c3f29313caabd6a149'),
46    plot: 'What kind of scenes in a horror film scares you the most? When a ghost appears totally unexpectedly? When the main character does not see the ghost sneaking up behind him? When at the very ...',
47    genres: [ 'Horror', 'Thriller' ],
48    title: 'Coming Soon',
49    score: 3.526711940765381
50  },
51  {
52    _id: ObjectId('573a1397f29313caabce7ea1'),
53    plot: "Four successful elderly gentlemen, members of the Chowder Society, share a gruesome, 50-year old secret. When one of Edward Wanderley's twin sons dies in a bizarre accident, the group ...",
54    genres: [ 'Drama', 'Horror', 'Thriller' ],
55    title: 'Ghost Story',
56    score: 3.3177831172943115
57  },
58  {
59    _id: ObjectId('573a13a4f29313caabd117df'),
60    plot: 'Stunt motorcyclist Johnny Blaze gives up his soul to become a hellblazing vigilante, to fight against power hungry Blackheart, the son of the devil himself.',
61    genres: [ 'Action', 'Fantasy', 'Thriller' ],
62    title: 'Ghost Rider',
63    score: 3.3177831172943115
64  },
65  {
66    _id: ObjectId('573a13a6f29313caabd185dc'),
67    plot: 'A salvage crew that discovers a long-lost 1962 passenger ship floating lifeless in a remote region of the Bering Sea soon notices, as they prepare to tow it back to land, that "strange things" happen...',
68    genres: [ 'Horror', 'Mystery' ],
69    title: 'Ghost Ship',
70    score: 3.3177831172943115
71  }
72]

The movie documents in the results contain the query term ghost in the plot or title field and aren't in the Comedy genre. Atlas Search didn't return documents in the Comedy genre with the term ghost in the plot or title field because those documents didn't rank in the top 10 documents since the query reduced the score of those documents by 50%.

This query uses the following pipeline stages:

  • Searches for movies that contain the term ghost in the plot or title (must clause), but doesn't have the specified ObjectIds (mustNot clause).

  • Searches for movies that contain the term ghost in the plot or title (must clause) and have the specified ObjectIds (filter clause), but reduces the score by 50% (boost) .

Limits the number of results to 10 documents.

  • Includes only the title, plot, and _id fields from the documents in the results.

  • Adds a field named score that shows the score of the document in the results.

1db.movies.aggregate([
2  {
3    "$search": {
4      "compound": {
5        "index": "compound-query-custom-score-tutorial",
6        "should": [ 
7          {
8            "compound": {
9              "must": [ 
10                {
11                  "text": {
12                    "query": "ghost",
13                    "path": ["plot","title"]
14                  }
15                } 
16              ],
17              "mustNot": [ 
18                {
19                  "in": {
20                    "value": [ObjectId('573a13cdf29313caabd83c08'), ObjectId('573a13cef29313caabd873a2')],
21                    "path": "_id"
22                  }
23                } 
24              ]
25            }
26          },
27          {
28            "compound": {
29              "must": [ 
30                {
31                  "text": {
32                    "query": "ghost",
33                    "path": ["plot","title"]
34                  }
35                } 
36              ],
37              "filter": [ 
38                {
39                  "in": {
40                    "value": [ObjectId('573a13cdf29313caabd83c08'), ObjectId('573a13cef29313caabd873a2')],
41                    "path": "_id"
42                  }
43                } 
44              ],
45              "score": { "boost": { "value": 0.5} }
46            }
47          } 
48        ]
49      }
50    }
51  },
52  {
53    "$limit": 10
54  },
55  {
56    "$project": {
57      "_id": 1,
58      "title": 1,
59      "plot": 1,
60      "score": { "$meta": "searchScore" }
61    }
62  }
63])
1[
2  {
3    _id: ObjectId('573a139af29313caabcefcce'),
4    plot: 'Adaption of the famous Oscar Wilde tale about a young American girl that helps a British ghost find rest and forgiveness.',
5    genres: [ 'Family', 'Drama', 'Fantasy' ],
6    title: 'The Canterville Ghost',
7    score: 5.909613132476807
8  },
9  {
10    _id: ObjectId('573a13d8f29313caabda5dc1'),
11    plot: 'The Little Ghost lives in the castle over looking a small town and awakens for precisely one hour after the clock strikes midnight. Follow him on this adventure to see his first sunrise ever!',
12    genres: [ 'Family', 'Fantasy' ],
13    title: 'The Little Ghost',
14    score: 5.367666244506836
15  },
16  {
17    _id: ObjectId('573a13c0f29313caabd6139d'),
18    plot: 'Renowned "ghost hunter", Carter Simms is paid to conduct a paranormal investigation of a supposedly haunted house. Along with a cameraman, a reporter, and a spiritual advocate, she embarks on a three night journey into terror.',
19    genres: [ 'Horror', 'Thriller' ],
20    title: 'Death of a Ghost Hunter',
21    score: 4.676314353942871
22  },
23  {
24    _id: ObjectId('573a1398f29313caabcebf6f'),
25    plot: 'After an accident leaves a young man dead, his spirit stays behind to warn his lover of impending danger, with the help of a reluctant psychic.',
26    genres: [ 'Drama', 'Fantasy', 'Romance' ],
27    title: 'Ghost',
28    score: 3.9638845920562744
29  },
30  {
31    _id: ObjectId('573a13c3f29313caabd6a149'),
32    plot: 'What kind of scenes in a horror film scares you the most? When a ghost appears totally unexpectedly? When the main character does not see the ghost sneaking up behind him? When at the very ...',
33    genres: [ 'Horror', 'Thriller' ],
34    title: 'Coming Soon',
35    score: 3.526711940765381
36  },
37  {
38    _id: ObjectId('573a1398f29313caabce912c'),
39    plot: 'Three unemployed parapsychology professors set up shop as a unique ghost removal service.',
40    genres: [ 'Comedy', 'Fantasy' ],
41    title: 'Ghostbusters',
42    score: 3.5241782665252686
43  },
44  {
45    _id: ObjectId('573a139cf29313caabcf5a48'),
46    plot: 'Casper, a ghost, teams up with Wendy, a witch, against an evil warlock.',
47    genres: [ 'Adventure', 'Comedy', 'Family' ],
48    title: 'Casper Meets Wendy',
49    score: 3.5241782665252686
50  },
51  {
52    _id: ObjectId('573a13bdf29313caabd58274'),
53    plot: 'Banku, his mother, Anjali Sharma and father move in to their new house -- the Nath villa, unaware of the fact that the house is inhabited by a ghost. It is learnt the ghost is not too happy...',
54    genres: [ 'Comedy', 'Drama', 'Fantasy' ],
55    title: 'Bhoothnath',
56    score: 3.4605300426483154
57  },
58  {
59    _id: ObjectId('573a1397f29313caabce7ea1'),
60    plot: "Four successful elderly gentlemen, members of the Chowder Society, share a gruesome, 50-year old secret. When one of Edward Wanderley's twin sons dies in a bizarre accident, the group ...",
61    genres: [ 'Drama', 'Horror', 'Thriller' ],
62    title: 'Ghost Story',
63    score: 3.3177831172943115
64  },
65  {
66    _id: ObjectId('573a1398f29313caabcebf79'),
67    plot: 'Elliot Hopper is a widower with three children, he is currently working on a deal. It seems like his wife illness was very costly and this deal could put them out of the red. However he ...',
68    genres: [ 'Comedy', 'Family', 'Fantasy' ],
69    title: 'Ghost Dad',
70    score: 3.3177831172943115
71  }
72]

The movie documents in the results contain the query term ghost in the plot or title field and don't have the specified ObjectIds in the _id field. Atlas Search didn't return the documents with the specified ObjectsIds, even though they contain the query term ghost in the title field, because the query reduced the score of these documents by 50% and so, these documents didn't rank in the top 10 documents.

1

Connect to your cluster in MongoDB Compass.

Open MongoDB Compass and connect to your cluster. For detailed instructions on connecting, see Connect via Compass.

2

Use the movies collection in the sample_mflix database.

On the Database screen, click the sample_mflix database, then click the movies collection.

3

Run the following Atlas Search queries on the movies collection.

This query uses the following pipeline stages:

  • Searches for movies that contain the term ghost in the plot or title (must clause) and aren't in the comedy genre (mustNot clause).

  • Searches for movies that contain the term ghost in the plot or title (must clause) and are in the comedy genre (filter clause), but reduces the score by 50% (boost).

Limits the number of results to 10 documents.

  • Includes only the _id, title, plot, and genres fields from the documents in the results.

  • Adds a field named score that shows the score in the results.

This query uses the following pipeline stages:

  • Searches for movies that contain the term ghost in the plot or title (must clause), but doesn't have the specified ObjectIds (mustNot clause).

  • Searches for movies that contain the term ghost in the plot or title (must clause) and have the specified ObjectIds (filter clause), but reduces the score by 50% (boost) .

Limits the number of results to 10 documents.

  • Includes only the title, plot, and _id fields from the documents in the results.

  • Adds a field named score that shows the score of the document in the results.

To run this query, perform the following steps in MongoDB Compass:

  1. Click the Aggregations tab.

  2. Click Select..., then configure each of the following pipeline stages by selecting the stage from the dropdown and adding the query for that stage.

    Tip

    Click Add Stage to add additional stages.

    Pipeline Stage
    Query
    $search
    {
      "index": "compound-query-custom-score-tutorial",
      "compound": {
        "should": [
          {
            "compound":{
              "must": [
                {
                  "text": {
                    "query": "ghost",
                    "path": ["plot","title"]
                  }
                }
              ],
              "mustNot": [
                {
                  "text": {
                    "query": "Comedy",
                    "path": ["genres"]
                  }
                }
              ]
            }
          },
          {
            "compound":{
              "must":[
                {
                  "text": {
                    "query": "ghost",
                    "path": ["plot","title"]
                  }
                }
              ],
              "filter": [
                {
                  "text": {
                    "query": "Comedy",
                    "path": ["genres"]
                  }
                }
              ],
              "score": { "boost": { "value": 0.5} }
            }
          }
        ]
      }
    }
    $limit
    10
    $project
    {
       "_id": 1,
       "title": 1,
       "plot": 1,
       "genres": 1,
       "score": { "$meta": "searchScore" }
    }

    If you enabled Auto Preview, MongoDB Compass displays the following documents next to the $project pipeline stage:

    1_id: ObjectId('573a139af29313caabcefcce'),
    2plot: 'Adaption of the famous Oscar Wilde tale about a young American girl that helps a British ghost find rest and forgiveness.',
    3genres: [ 'Family', 'Drama', 'Fantasy' ],
    4title: 'The Canterville Ghost',
    5score: 5.909613132476807
    6
    7_id: ObjectId('573a13d8f29313caabda5dc1'),
    8plot: 'The Little Ghost lives in the castle over looking a small town and awakens for precisely one hour after the clock strikes midnight. Follow him on this adventure to see his first sunrise ever!',
    9genres: [ 'Family', 'Fantasy' ],
    10title: 'The Little Ghost',
    11score: 5.367666244506836
    12
    13_id: ObjectId('573a13c0f29313caabd6139d'),
    14plot: 'Renowned "ghost hunter", Carter Simms is paid to conduct a paranormal investigation of a supposedly haunted house. Along with a cameraman, a reporter, and a spiritual advocate, she embarks on a three night journey into terror.',
    15genres: [ 'Horror', 'Thriller' ],
    16title: 'Death of a Ghost Hunter',
    17score: 4.676314353942871
    18
    19_id: ObjectId('573a1398f29313caabcebf6f'),
    20plot: 'After an accident leaves a young man dead, his spirit stays behind to warn his lover of impending danger, with the help of a reluctant psychic.',
    21genres: [ 'Drama', 'Fantasy', 'Romance' ],
    22title: 'Ghost',
    23score: 3.9638845920562744
    24
    25_id: ObjectId('573a13cdf29313caabd83c08'),
    26plot: "A man tries to solve his lover's murder by communicating with her spirit through the help of a medium.",
    27genres: [ 'Drama', 'Fantasy', 'Mystery' ],
    28title: 'Ghost',
    29score: 3.9638845920562744
    30
    31_id: ObjectId('573a13cef29313caabd873a2'),
    32plot: "A man tries to solve his lover's murder by communicating with her spirit through the help of a medium.",
    33genres: [ 'Drama', 'Fantasy', 'Mystery' ],
    34title: 'Ghost',
    35score: 3.9638845920562744
    36
    37_id: ObjectId('573a13c3f29313caabd6a149'),
    38plot: 'What kind of scenes in a horror film scares you the most? When a ghost appears totally unexpectedly? When the main character does not see the ghost sneaking up behind him? When at the very ...',
    39genres: [ 'Horror', 'Thriller' ],
    40title: 'Coming Soon',
    41score: 3.526711940765381
    42
    43_id: ObjectId('573a1397f29313caabce7ea1'),
    44plot: "Four successful elderly gentlemen, members of the Chowder Society, share a gruesome, 50-year old secret. When one of Edward Wanderley's twin sons dies in a bizarre accident, the group ...",
    45genres: [ 'Drama', 'Horror', 'Thriller' ],
    46title: 'Ghost Story',
    47score: 3.3177831172943115
    48
    49_id: ObjectId('573a13a4f29313caabd117df'),
    50plot: 'Stunt motorcyclist Johnny Blaze gives up his soul to become a hellblazing vigilante, to fight against power hungry Blackheart, the son of the devil himself.',
    51genres: [ 'Action', 'Fantasy', 'Thriller' ],
    52title: 'Ghost Rider',
    53score: 3.3177831172943115
    54
    55_id: ObjectId('573a13a6f29313caabd185dc'),
    56plot: 'A salvage crew that discovers a long-lost 1962 passenger ship floating lifeless in a remote region of the Bering Sea soon notices, as they prepare to tow it back to land, that "strange things" happen...',
    57genres: [ 'Horror', 'Mystery' ],
    58title: 'Ghost Ship',
    59score: 3.3177831172943115

    The movie documents in the results contain the query term ghost in the plot or title field and aren't in the Comedy genre. Atlas Search didn't return documents in the Comedy genre with the term ghost in the plot or title field because those documents didn't rank in the top 10 documents since the query reduced the score of those documents by 50%.

    Pipeline Stage
    Query
    $search
    {
      "index": "compound-query-custom-score-tutorial",
      "compound": {
        "should": [
          {
            "compound":{
              "must": [
                {
                  "text": {
                    "query": "ghost",
                    "path": ["plot","title"]
                  }
                }
              ],
              "mustNot": [
                {
                  "in": {
                    "value": [ObjectId('573a13cdf29313caabd83c08'), ObjectId('573a13cef29313caabd873a2')],
                    "path": "_id"
                  }
                }
              ]
            }
          },
          {
            "compound":{
              "must":[
                {
                  "text": {
                    "query": "ghost",
                    "path": ["plot","title"]
                  }
                }
              ],
              "filter": [
                {
                  "in": {
                    "value": [ObjectId('573a13cdf29313caabd83c08'), ObjectId('573a13cef29313caabd873a2')],
                    "path": "_id"
                  }
                }
              ],
              "score": { "boost": { "value": 0.5} }
            }
          }
        ]
      }
    }
    $limit
    10
    $project
    {
       "_id": 1,
       "title": 1,
       "plot": 1,
       "score": { "$meta": "searchScore" }
    }

    If you enabled Auto Preview, MongoDB Compass displays the following documents next to the $project pipeline stage:

    1_id: ObjectId('573a139af29313caabcefcce'),
    2plot: 'Adaption of the famous Oscar Wilde tale about a young American girl that helps a British ghost find rest and forgiveness.',
    3title: 'The Canterville Ghost',
    4score: 5.909613132476807
    5
    6_id: ObjectId('573a13d8f29313caabda5dc1'),
    7plot: 'The Little Ghost lives in the castle over looking a small town and awakens for precisely one hour after the clock strikes midnight. Follow him on this adventure to see his first sunrise ever!',
    8title: 'The Little Ghost',
    9score: 5.367666244506836
    10
    11_id: ObjectId('573a13c0f29313caabd6139d'),
    12plot: 'Renowned "ghost hunter", Carter Simms is paid to conduct a paranormal investigation of a supposedly haunted house. Along with a cameraman, a reporter, and a spiritual advocate, she embarks on a three night journey into terror.',
    13title: 'Death of a Ghost Hunter',
    14score: 4.676314353942871
    15
    16_id: ObjectId('573a1398f29313caabcebf6f'),
    17plot: 'After an accident leaves a young man dead, his spirit stays behind to warn his lover of impending danger, with the help of a reluctant psychic.',
    18title: 'Ghost',
    19score: 3.9638845920562744
    20
    21_id: ObjectId('573a13c3f29313caabd6a149'),
    22plot: 'What kind of scenes in a horror film scares you the most? When a ghost appears totally unexpectedly? When the main character does not see the ghost sneaking up behind him? When at the very ...',
    23title: 'Coming Soon',
    24score: 3.526711940765381
    25
    26_id: ObjectId('573a1398f29313caabce912c'),
    27plot: 'Three unemployed parapsychology professors set up shop as a unique ghost removal service.',
    28title: 'Ghostbusters',
    29score: 3.5241782665252686
    30
    31_id: ObjectId('573a139cf29313caabcf5a48'),
    32plot: 'Casper, a ghost, teams up with Wendy, a witch, against an evil warlock.',
    33title: 'Casper Meets Wendy',
    34score: 3.5241782665252686
    35
    36_id: ObjectId('573a13bdf29313caabd58274'),
    37plot: 'Banku, his mother, Anjali Sharma and father move in to their new house -- the Nath villa, unaware of the fact that the house is inhabited by a ghost. It is learnt the ghost is not too happy...',
    38title: 'Bhoothnath',
    39score: 3.4605300426483154
    40
    41_id: ObjectId('573a1397f29313caabce7ea1'),
    42plot: "Four successful elderly gentlemen, members of the Chowder Society, share a gruesome, 50-year old secret. When one of Edward Wanderley's twin sons dies in a bizarre accident, the group ...",
    43title: 'Ghost Story',
    44score: 3.3177831172943115
    45
    46_id: ObjectId('573a1398f29313caabcebf79'),
    47plot: 'Elliot Hopper is a widower with three children, he is currently working on a deal. It seems like his wife illness was very costly and this deal could put them out of the red. However he ...',
    48title: 'Ghost Dad',
    49score: 3.3177831172943115

    The movie documents in the results contain the query term ghost in the plot or title field and don't have the specified ObjectIds in the _id field. Atlas Search didn't return the documents with the specified ObjectsIds, even though they contain the query term ghost in the title field, because the query reduced the score of these documents by 50% and so, these documents didn't rank in the top 10 documents.

1

Set up and initialize the .NET/C# project for the query.

  1. Create a new directory called compound-bury-results and initialize your project with the dotnet new command.

    mkdir compound-bury-results
    cd compound-bury-results
    dotnet new console

  2. Add the .NET/C# Driver to your project as a dependency.

    dotnet add package MongoDB.Driver
2

Copy and paste the query into the Program.cs file.

This query uses the following pipeline stages:

  • Searches for movies that contain the term ghost in the plot or title (must clause) and aren't in the comedy genre (mustNot clause).

  • Searches for movies that contain the term ghost in the plot or title (must clause) and are in the comedy genre (filter clause), but reduces the score by 50% (boost).

Limits the number of results to 10 documents.

  • Includes only the _id, title, plot, and genres fields from the documents in the results.

  • Adds a field named score that shows the score in the results.

1using MongoDB.Bson;
2using MongoDB.Bson.Serialization.Attributes;
3using MongoDB.Bson.Serialization.Conventions;
4using MongoDB.Driver;
5using MongoDB.Driver.Search;
6
7public class BuryGenreCompoundExample
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 MovieDocument
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 mflixDatabase = mongoClient.GetDatabase("sample_mflix");
20        var moviesCollection = mflixDatabase.GetCollection<MovieDocument>("movies");
21
22        // define and run pipeline
23        var results = moviesCollection.Aggregate()
24            .Search(Builders<MovieDocument>.Search.Compound()
25                .Should(Builders<MovieDocument>.Search.Compound()
26                    .Must(Builders<MovieDocument>.Search.Text(
27                        Builders<MovieDocument>.SearchPath.Multi(movie => movie.Title, movie => movie.Plot), "ghost"))
28                    .MustNot(Builders<MovieDocument>.Search.Text(movie => movie.Genres, "Comedy"))
29                )
30                .Should(Builders<MovieDocument>.Search.Compound()
31                    .Must(Builders<MovieDocument>.Search.Text(
32                        Builders<MovieDocument>.SearchPath.Multi(movie => movie.Title, movie => movie.Plot), "ghost"))
33                    .Filter(Builders<MovieDocument>.Search.Text(movie => movie.Genres, "Comedy", score: new SearchScoreDefinitionBuilder<MovieDocument>().Boost(0.5)))
34                ),
35                indexName: "compound-query-custom-score-tutorial")
36            .Project<MovieDocument>(Builders<MovieDocument>.Projection
37                .Include(movie => movie.Plot)
38                .Include(movie => movie.Title)
39                .Include(movie => movie.Id)
40                .Include(movie => movie.Genres)
41                .MetaSearchScore("score"))
42            .Limit(10)
43            .ToList();
44
45        // print results
46        foreach (var movie in results)
47        {
48            Console.WriteLine(movie.ToJson());
49        }
50    }
51}
52
53[BsonIgnoreExtraElements]
54public class MovieDocument
55{
56    [BsonIgnoreIfDefault]
57    public ObjectId Id { get; set; }
58    public string Plot { get; set; }
59    public string Title { get; set; }
60    public string[] Genres { get; set; }
61    public double Score { get; set; }
62}

This query uses the following pipeline stages:

  • Searches for movies that contain the term ghost in the plot or title (must clause), but doesn't have the specified ObjectIds (mustNot clause).

  • Searches for movies that contain the term ghost in the plot or title (must clause) and have the specified ObjectIds (filter clause), but reduces the score by 50% (boost) .

Limits the number of results to 10 documents.

  • Includes only the title, plot, and _id fields from the documents in the results.

  • Adds a field named score that shows the score of the document in the results.

1using MongoDB.Bson;
2using MongoDB.Bson.Serialization.Attributes;
3using MongoDB.Bson.Serialization.Conventions;
4using MongoDB.Driver;
5using MongoDB.Driver.Search;
6
7public class BuryDocumentCompoundExample
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 MovieDocument
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 mflixDatabase = mongoClient.GetDatabase("sample_mflix");
20        var moviesCollection = mflixDatabase.GetCollection<MovieDocument>("movies");
21
22        string id1 = "573a13cef29313caabd873a2";
23        string id2 = "573a13cdf29313caabd83c08";
24
25        // define and run pipeline
26        var results = moviesCollection.Aggregate()
27            .Search(Builders<MovieDocument>.Search.Compound()
28                .Should(Builders<MovieDocument>.Search.Compound()
29                    .Must(Builders<MovieDocument>.Search.Text(
30                        Builders<MovieDocument>.SearchPath.Multi(movie => movie.Title, movie => movie.Plot), "ghost"))
31                    .MustNot(Builders<MovieDocument>.Search.In(movie => movie.Id, new[] {ObjectId.Parse(id1), ObjectId.Parse(id2)}))
32                )
33                .Should(Builders<MovieDocument>.Search.Compound()
34                    .Must(Builders<MovieDocument>.Search.Text(
35                        Builders<MovieDocument>.SearchPath.Multi(movie => movie.Title, movie => movie.Plot), "ghost"))
36                    .Filter(Builders<MovieDocument>.Search.In(movie => movie.Id, new[] {ObjectId.Parse(id1), ObjectId.Parse(id2)}, score: new SearchScoreDefinitionBuilder<MovieDocument>().Boost(0.5)))
37                ),
38                indexName: "compound-query-custom-score-tutorial")
39            .Project<MovieDocument>(Builders<MovieDocument>.Projection
40                .Include(movie => movie.Plot)
41                .Include(movie => movie.Title)
42                .Include(movie => movie.Id)
43                .MetaSearchScore("score"))
44            .Limit(10)
45            .ToList();
46
47        // print results
48        foreach (var movie in results)
49        {
50            Console.WriteLine(movie.ToJson());
51        }
52    }
53}
54
55[BsonIgnoreExtraElements]
56public class MovieDocument
57{
58    [BsonIgnoreIfDefault]
59    public ObjectId Id { get; set; }
60    public string Plot { get; set; }
61    public string Title { get; set; }
62    public double Score { get; set; }
63}
3

Replace the <connection-string> in the query and then save the file.

Ensure that your connection string includes your database user's credentials. To learn more, see Connect via Drivers.

4

Compile and run the Program.cs file.

dotnet run compound-bury-results.csproj
{ "_id" : ObjectId("573a139af29313caabcefcce"), "plot" : "Adaption of the famous Oscar Wilde tale about a young American girl that helps a British ghost find rest and forgiveness.", "title" : "The Canterville Ghost", "genres" : ["Family", "Drama", "Fantasy"], "score" : 5.9096131324768066 }
{ "_id" : ObjectId("573a13d8f29313caabda5dc1"), "plot" : "The Little Ghost lives in the castle over looking a small town and awakens for precisely one hour after the clock strikes midnight. Follow him on this adventure to see his first sunrise ever!", "title" : "The Little Ghost", "genres" : ["Family", "Fantasy"], "score" : 5.3676662445068359 }
{ "_id" : ObjectId("573a13c0f29313caabd6139d"), "plot" : "Renowned \"ghost hunter\", Carter Simms is paid to conduct a paranormal investigation of a supposedly haunted house. Along with a cameraman, a reporter, and a spiritual advocate, she embarks on a three night journey into terror.", "title" : "Death of a Ghost Hunter", "genres" : ["Horror", "Thriller"], "score" : 4.6763143539428711 }
{ "_id" : ObjectId("573a1398f29313caabcebf6f"), "plot" : "After an accident leaves a young man dead, his spirit stays behind to warn his lover of impending danger, with the help of a reluctant psychic.", "title" : "Ghost", "genres" : ["Drama", "Fantasy", "Romance"], "score" : 3.9638845920562744 }
{ "_id" : ObjectId("573a13cdf29313caabd83c08"), "plot" : "A man tries to solve his lover's murder by communicating with her spirit through the help of a medium.", "title" : "Ghost", "genres" : ["Drama", "Fantasy", "Mystery"], "score" : 3.9638845920562744 }
{ "_id" : ObjectId("573a13cef29313caabd873a2"), "plot" : "A man tries to solve his lover's murder by communicating with her spirit through the help of a medium.", "title" : "Ghost", "genres" : ["Drama", "Fantasy", "Mystery"], "score" : 3.9638845920562744 }
{ "_id" : ObjectId("573a13c3f29313caabd6a149"), "plot" : "What kind of scenes in a horror film scares you the most? When a ghost appears totally unexpectedly? When the main character does not see the ghost sneaking up behind him? When at the very ...", "title" : "Coming Soon", "genres" : ["Horror", "Thriller"], "score" : 3.5267119407653809 }
{ "_id" : ObjectId("573a1398f29313caabce912c"), "plot" : "Three unemployed parapsychology professors set up shop as a unique ghost removal service.", "title" : "Ghostbusters", "genres" : ["Comedy", "Fantasy"], "score" : 3.5241782665252686 }
{ "_id" : ObjectId("573a139cf29313caabcf5a48"), "plot" : "Casper, a ghost, teams up with Wendy, a witch, against an evil warlock.", "title" : "Casper Meets Wendy", "genres" : ["Adventure", "Comedy", "Family"], "score" : 3.5241782665252686 }
{ "_id" : ObjectId("573a13bdf29313caabd58274"), "plot" : "Banku, his mother, Anjali Sharma and father move in to their new house -- the Nath villa, unaware of the fact that the house is inhabited by a ghost. It is learnt the ghost is not too happy...", "title" : "Bhoothnath", "genres" : ["Comedy", "Drama", "Fantasy"], "score" : 3.4605300426483154 }

The movie documents in the results contain the query term ghost in the plot or title field and aren't in the Comedy genre. Atlas Search didn't return documents in the Comedy genre with the term ghost in the plot or title field because those documents didn't rank in the top 10 documents since the query reduced the score of those documents by 50%.

dotnet run compound-bury-results.csproj
{ "_id" : ObjectId("573a139af29313caabcefcce"), "plot" : "Adaption of the famous Oscar Wilde tale about a young American girl that helps a British ghost find rest and forgiveness.", "title" : "The Canterville Ghost", "score" : 5.9096131324768066 }
{ "_id" : ObjectId("573a13d8f29313caabda5dc1"), "plot" : "The Little Ghost lives in the castle over looking a small town and awakens for precisely one hour after the clock strikes midnight. Follow him on this adventure to see his first sunrise ever!", "title" : "The Little Ghost", "score" : 5.3676662445068359 }
{ "_id" : ObjectId("573a13c0f29313caabd6139d"), "plot" : "Renowned \"ghost hunter\", Carter Simms is paid to conduct a paranormal investigation of a supposedly haunted house. Along with a cameraman, a reporter, and a spiritual advocate, she embarks on a three night journey into terror.", "title" : "Death of a Ghost Hunter", "score" : 4.6763143539428711 }
{ "_id" : ObjectId("573a1398f29313caabcebf6f"), "plot" : "After an accident leaves a young man dead, his spirit stays behind to warn his lover of impending danger, with the help of a reluctant psychic.", "title" : "Ghost", "score" : 3.9638845920562744 }
{ "_id" : ObjectId("573a13cdf29313caabd83c08"), "plot" : "A man tries to solve his lover's murder by communicating with her spirit through the help of a medium.", "title" : "Ghost", "score" : 3.9638845920562744 }
{ "_id" : ObjectId("573a13cef29313caabd873a2"), "plot" : "A man tries to solve his lover's murder by communicating with her spirit through the help of a medium.", "title" : "Ghost", "score" : 3.9638845920562744 }
{ "_id" : ObjectId("573a13c3f29313caabd6a149"), "plot" : "What kind of scenes in a horror film scares you the most? When a ghost appears totally unexpectedly? When the main character does not see the ghost sneaking up behind him? When at the very ...", "title" : "Coming Soon", "score" : 3.5267119407653809 }
{ "_id" : ObjectId("573a1398f29313caabce912c"), "plot" : "Three unemployed parapsychology professors set up shop as a unique ghost removal service.", "title" : "Ghostbusters", "score" : 3.5241782665252686 }
{ "_id" : ObjectId("573a139cf29313caabcf5a48"), "plot" : "Casper, a ghost, teams up with Wendy, a witch, against an evil warlock.", "title" : "Casper Meets Wendy", "score" : 3.5241782665252686 }
{ "_id" : ObjectId("573a13bdf29313caabd58274"), "plot" : "Banku, his mother, Anjali Sharma and father move in to their new house -- the Nath villa, unaware of the fact that the house is inhabited by a ghost. It is learnt the ghost is not too happy...", "title" : "Bhoothnath", "score" : 3.4605300426483154 }

The movie documents in the results contain the query term ghost in the plot or title field and don't have the specified ObjectIds in the _id field. Atlas Search didn't return the documents with the specified ObjectsIds, even though they contain the query term ghost in the title field, because the query reduced the score of these documents by 50% and so, these documents didn't rank in the top 10 documents.

1

Create a file named compound-bury-results.go

2

Copy and paste the query into the compound-bury-results.go file.

This query uses the following pipeline stages:

  • Searches for movies that contain the term ghost in the plot or title (must clause) and aren't in the comedy genre (mustNot clause).

  • Searches for movies that contain the term ghost in the plot or title (must clause) and are in the comedy genre (filter clause), but reduces the score by 50% (boost).

Limits the number of results to 10 documents.

  • Includes only the _id, title, plot, and genres fields from the documents in the results.

  • Adds a field named score that shows the score in the results.

1package main
2
3import (
4	"context"
5	"fmt"
6	"time"
7
8	"go.mongodb.org/mongo-driver/bson"
9	"go.mongodb.org/mongo-driver/mongo"
10	"go.mongodb.org/mongo-driver/mongo/options"
11)
12
13// define structure of movies collection
14type MovieCollection struct {
15	title string `bson:"Title,omitempty"`
16	plot  string `bson:"Plot,omitempty"`
17}
18
19func main() {
20	var err error
21	// connect to the Atlas cluster
22	ctx := context.Background()
23	client, err := mongo.Connect(ctx, options.Client().ApplyURI("<connection-string>"))
24	if err != nil {
25		panic(err)
26	}
27	defer client.Disconnect(ctx)
28	// set namespace
29	collection := client.Database("sample_mflix").Collection("movies")
30	// define pipeline
31	searchStage := bson.D{{"$search", bson.D{
32		{"index", "compound-query-custom-score-tutorial"},
33		{"compound", bson.D{
34		  {"should", bson.A{
35			bson.D{{"compound", bson.D{
36				{"must", bson.A{
37				  bson.D{{"text", bson.D{
38					  {"query", "ghost"},
39					  {"path", bson.A{ "plot", "title" }},
40				  }}},
41				}},
42				{"mustNot", bson.A{
43				  bson.D{{"text", bson.D{
44					  {"query", "Comedy"},
45					  {"path", bson.A{ "genres" }},
46				  }}},
47				}},
48			}}},
49			bson.D{{"compound", bson.D{
50				{"must", bson.A{
51				  bson.D{{"text", bson.D{
52					  {"query", "ghost"},
53				      {"path", bson.A{ "plot", "title" }},
54				  }}},
55				}},
56				{"filter", bson.A{
57				  bson.D{{"text", bson.D{
58					  {"query", "Comedy"},
59					  {"path", bson.A{ "genres" }},
60				  }}},
61				}},
62				{"score", bson.D{{"boost", bson.D{{"value", 0.5}}}}},
63			}}},
64		}},
65	  }},
66	}}}
67	limitStage := bson.D{{"$limit", 10}}
68	projectStage := bson.D{{"$project", bson.D{{"title", 1}, {"plot", 1}, {"_id", 0}, {"genres", 1}, {"score", bson.D{{"$meta", "searchScore"}}}}}}
69	// specify the amount of time the operation can run on the server
70	opts := options.Aggregate().SetMaxTime(5 * time.Second)
71	// run pipeline
72	cursor, err := collection.Aggregate(ctx, mongo.Pipeline{searchStage, limitStage, projectStage}, opts)
73	if err != nil {
74		panic(err)
75	}
76	// print results
77	var results []bson.D
78	if err = cursor.All(context.TODO(), &results); err != nil {
79		panic(err)
80	}
81	for _, result := range results {
82		fmt.Println(result)
83	}
84}

This query uses the following pipeline stages:

  • Searches for movies that contain the term ghost in the plot or title (must clause), but doesn't have the specified ObjectIds (mustNot clause).

  • Searches for movies that contain the term ghost in the plot or title (must clause) and have the specified ObjectIds (filter clause), but reduces the score by 50% (boost) .

Limits the number of results to 10 documents.

  • Includes only the title, plot, and _id fields from the documents in the results.

  • Adds a field named score that shows the score of the document in the results.

1package main
2
3import (
4    "context"
5    "fmt"
6    "time"
7    "log"
8
9    "go.mongodb.org/mongo-driver/bson"
10    "go.mongodb.org/mongo-driver/mongo"
11    "go.mongodb.org/mongo-driver/mongo/options"
12    "go.mongodb.org/mongo-driver/bson/primitive"
13)
14
15// define structure of movies collection
16type MovieCollection struct {
17    title string `bson:"Title,omitempty"`
18    plot  string `bson:"Plot,omitempty"`
19}
20
21func main() {
22    var err error
23    // connect to the Atlas cluster
24    ctx := context.Background()
25    client, err := mongo.Connect(ctx, options.Client().ApplyURI("<connection-string>"))
26    if err != nil {
27        panic(err)
28    }
29    defer client.Disconnect(ctx)
30    // set namespace
31    collection := client.Database("sample_mflix").Collection("movies")
32    // define variable 
33    var objectIDFromHex = func(hex string) primitive.ObjectID {
34        objectID, err := primitive.ObjectIDFromHex(hex)
35        if err != nil {
36            log.Fatal(err)
37        }
38        return objectID
39    }
40    // define pipeline
41    searchStage := bson.D{{"$search", bson.D{
42        {"index", "compound-query-custom-score-tutorial"},
43		{"compound", bson.D{
44            {"should", bson.A{
45                bson.D{{"compound", bson.D{
46                    {"must", bson.A{
47                        bson.D{{"text", bson.D{
48                            {"query", "ghost"},
49                            {"path", bson.A{ "plot", "title" }},
50                        }}},
51                    }},
52                    {"mustNot", bson.A{
53                        bson.D{{"in", bson.D{
54                            {"value", bson.A{objectIDFromHex("573a13cdf29313caabd83c08"), objectIDFromHex("573a13cef29313caabd873a2") }},
55                            {"path", "_id"},
56                        }}},
57                    }},
58                }}},
59                bson.D{{"compound", bson.D{
60                    {"must", bson.A{
61                        bson.D{{"text", bson.D{
62                            {"query", "ghost"},
63                            {"path", bson.A{ "plot", "title" }},
64                         }}},
65                    }},
66                    {"filter", bson.A{
67                        bson.D{{"in", bson.D{
68                            {"value", bson.A{ objectIDFromHex("573a13cdf29313caabd83c08"), objectIDFromHex("573a13cef29313caabd873a2")}},
69                            {"path", "_id"},
70                        }}},
71                    }},
72                    {"score", bson.D{{"boost", bson.D{{"value", 0.5}}}}},
73                 }}},
74             }},
75        }},
76    }}}
77
78    limitStage := bson.D{{"$limit", 10}}
79    projectStage := bson.D{{"$project", bson.D{{"title", 1}, {"plot", 1}, {"_id", 0}, {"score", bson.D{{"$meta", "searchScore"}}}}}}
80    // specify the amount of time the operation can run on the server
81    opts := options.Aggregate().SetMaxTime(5 * time.Second)
82    // run pipeline
83    cursor, err := collection.Aggregate(ctx, mongo.Pipeline{searchStage, limitStage, projectStage}, opts)
84    if err != nil {
85        panic(err)
86    }
87    // print results
88    var results []bson.D
89    if err = cursor.All(context.TODO(), &results); err != nil {
90        panic(err)
91    }
92    for _, result := range results {
93        fmt.Println(result)
94    }
95}
3

Replace the <connection-string> in the query and then save the file.

Ensure that your connection string includes your database user's credentials. To learn more, see Connect via Drivers.

4

Run the command to query your collection.

go run compound-bury-results.go
[{plot Adaption of the famous Oscar Wilde tale about a young American girl that helps a British ghost find rest and forgiveness.} {genres [Family Drama Fantasy]} {title The Canterville Ghost} {score 5.909613132476807}]
[{plot The Little Ghost lives in the castle over looking a small town and awakens for precisely one hour after the clock strikes midnight. Follow him on this adventure to see his first sunrise ever!} {genres [Family Fantasy]} {title The Little Ghost} {score 5.367666244506836}]
[{plot Renowned "ghost hunter", Carter Simms is paid to conduct a paranormal investigation of a supposedly haunted house. Along with a cameraman, a reporter, and a spiritual advocate, she embarks on a three night journey into terror.} {genres [Horror Thriller]} {title Death of a Ghost Hunter} {score 4.676314353942871}]
[{plot After an accident leaves a young man dead, his spirit stays behind to warn his lover of impending danger, with the help of a reluctant psychic.} {genres [Drama Fantasy Romance]} {title Ghost} {score 3.9638845920562744}]
[{plot A man tries to solve his lover's murder by communicating with her spirit through the help of a medium.} {genres [Drama Fantasy Mystery]} {title Ghost} {score 3.9638845920562744}]
[{plot A man tries to solve his lover's murder by communicating with her spirit through the help of a medium.} {genres [Drama Fantasy Mystery]} {title Ghost} {score 3.9638845920562744}]
[{plot What kind of scenes in a horror film scares you the most? When a ghost appears totally unexpectedly? When the main character does not see the ghost sneaking up behind him? When at the very ...} {genres [Horror Thriller]} {title Coming Soon} {score 3.526711940765381}]
[{plot Four successful elderly gentlemen, members of the Chowder Society, share a gruesome, 50-year old secret. When one of Edward Wanderley's twin sons dies in a bizarre accident, the group ...} {genres [Drama Horror Thriller]} {title Ghost Story} {score 3.3177831172943115}]
[{plot Stunt motorcyclist Johnny Blaze gives up his soul to become a hellblazing vigilante, to fight against power hungry Blackheart, the son of the devil himself.} {genres [Action Fantasy Thriller]} {title Ghost Rider} {score 3.3177831172943115}]
[{plot A salvage crew that discovers a long-lost 1962 passenger ship floating lifeless in a remote region of the Bering Sea soon notices, as they prepare to tow it back to land, that "strange things" happen...} {genres [Horror Mystery]} {title Ghost Ship} {score 3.3177831172943115}]

The movie documents in the results contain the query term ghost in the plot or title field and aren't in the Comedy genre. Atlas Search didn't return documents in the Comedy genre with the term ghost in the plot or title field because those documents didn't rank in the top 10 documents since the query reduced the score of those documents by 50%.

go run compound-bury-results.go
[{plot Adaption of the famous Oscar Wilde tale about a young American girl that helps a British ghost find rest and forgiveness.} {title The Canterville Ghost} {score 5.909613132476807}]
[{plot The Little Ghost lives in the castle over looking a small town and awakens for precisely one hour after the clock strikes midnight. Follow him on this adventure to see his first sunrise ever!} {title The Little Ghost} {score 5.367666244506836}]
[{plot Renowned "ghost hunter", Carter Simms is paid to conduct a paranormal investigation of a supposedly haunted house. Along with a cameraman, a reporter, and a spiritual advocate, she embarks on a three night journey into terror.} {title Death of a Ghost Hunter} {score 4.676314353942871}]
[{plot After an accident leaves a young man dead, his spirit stays behind to warn his lover of impending danger, with the help of a reluctant psychic.} {title Ghost} {score 3.9638845920562744}]
[{plot What kind of scenes in a horror film scares you the most? When a ghost appears totally unexpectedly? When the main character does not see the ghost sneaking up behind him? When at the very ...} {title Coming Soon} {score 3.526711940765381}]
[{plot Three unemployed parapsychology professors set up shop as a unique ghost removal service.} {title Ghostbusters} {score 3.5241782665252686}]
[{plot Casper, a ghost, teams up with Wendy, a witch, against an evil warlock.} {title Casper Meets Wendy} {score 3.5241782665252686}]
[{plot Banku, his mother, Anjali Sharma and father move in to their new house -- the Nath villa, unaware of the fact that the house is inhabited by a ghost. It is learnt the ghost is not too happy...} {title Bhoothnath} {score 3.4605300426483154}]
[{plot Four successful elderly gentlemen, members of the Chowder Society, share a gruesome, 50-year old secret. When one of Edward Wanderley's twin sons dies in a bizarre accident, the group ...} {title Ghost Story} {score 3.3177831172943115}]
[{plot Elliot Hopper is a widower with three children, he is currently working on a deal. It seems like his wife illness was very costly and this deal could put them out of the red. However he ...} {title Ghost Dad} {score 3.3177831172943115}]

The movie documents in the results contain the query term ghost in the plot or title field and don't have the specified ObjectIds in the _id field. Atlas Search didn't return the documents with the specified ObjectsIds, even though they contain the query term ghost in the title field, because the query reduced the score of these documents by 50% and so, these documents didn't rank in the top 10 documents.

1

Ensure that your CLASSPATH contains the following libraries.

junit
4.11 or higher version
mongodb-driver-sync
4.3.0 or higher version
slf4j-log4j12
1.7.30 or higher version
2

Create a file named CompoundBuryQuery.java.

3

Copy and paste the query into the CompoundBuryQuery.java file.

This query uses the following pipeline stages:

  • Searches for movies that contain the term ghost in the plot or title (must clause) and aren't in the comedy genre (mustNot clause).

  • Searches for movies that contain the term ghost in the plot or title (must clause) and are in the comedy genre (filter clause), but reduces the score by 50% (boost).

Limits the number of results to 10 documents.

  • Includes only the _id, title, plot, and genres fields from the documents in the results.

  • Adds a field named score that shows the score in the results.

1import java.util.Arrays;
2import static com.mongodb.client.model.Aggregates.limit;
3import static com.mongodb.client.model.Aggregates.project;
4import static com.mongodb.client.model.Projections.*;
5import com.mongodb.client.MongoClient;
6import com.mongodb.client.MongoClients;
7import com.mongodb.client.MongoCollection;
8import com.mongodb.client.MongoDatabase;
9
10import org.bson.Document;
11
12public class CompoundBuryQuery {
13  public static void main( String[] args ) {
14    // define query
15    Document agg =
16        new Document("$search", 
17            new Document("index", "compound-query-custom-score-tutorial")
18            .append("compound", 
19                new Document("should", Arrays.asList(new Document("compound", 
20        		    new Document("must", Arrays.asList(new Document("text", 
21        			    new Document("query", "ghost")
22        			    .append("path", Arrays.asList("plot", "title")))))
23        		    .append("mustNot", Arrays.asList(new Document("text", 
24        			    new Document("query", "Comedy")
25        			    .append("path", Arrays.asList("genres")))))
26        		), 
27        	new Document("compound", 
28        		new Document("must", Arrays.asList(new Document("text", 
29        			new Document("query", "ghost")
30        			.append("path", Arrays.asList("plot", "title")))))
31        		.append("filter", Arrays.asList(new Document("text", 
32        			new Document("query", "Comedy")
33        			.append("path", Arrays.asList("genres")))))
34        		.append("score", new Document("boost", 
35        			new Document("value", 0.5d))))))
36                )
37        );
38    // specify connection
39    String uri = "<connection-string>";
40    // establish connection and set namespace
41    try (MongoClient mongoClient = MongoClients.create(uri)) {
42      MongoDatabase database = mongoClient.getDatabase("sample_mflix");
43      MongoCollection<Document> collection = database.getCollection("movies");
44	// run query and print results		
45      collection.aggregate(Arrays.asList(agg, 
46        limit(10), 
47        project(fields(
48          include("title", "plot", "genres", "_id"), 
49          computed("score", new Document("$meta", "searchScore"))))))
50      .forEach(doc -> System.out.println(doc.toJson()));	
51    }
52  }
53}

This query uses the following pipeline stages:

  • Searches for movies that contain the term ghost in the plot or title (must clause), but doesn't have the specified ObjectIds (mustNot clause).

  • Searches for movies that contain the term ghost in the plot or title (must clause) and have the specified ObjectIds (filter clause), but reduces the score by 50% (boost) .

Limits the number of results to 10 documents.

  • Includes only the title, plot, and _id fields from the documents in the results.

  • Adds a field named score that shows the score of the document in the results.

1import java.util.Arrays;
2import static com.mongodb.client.model.Aggregates.limit;
3import static com.mongodb.client.model.Aggregates.project;
4import static com.mongodb.client.model.Projections.*;
5import com.mongodb.client.MongoClient;
6import com.mongodb.client.MongoClients;
7import com.mongodb.client.MongoCollection;
8import com.mongodb.client.MongoDatabase;
9import org.bson.types.ObjectId;
10
11import org.bson.Document;
12
13public class CompoundBuryQuery {
14  public static void main( String[] args ) {
15    // define query
16    Document agg =
17        new Document("$search", 
18        	new Document("index", "compound-query-custom-score-tutorial")
19            .append("compound", 
20            	new Document("should", Arrays.asList(
21            	    new Document("compound", 
22                        new Document("must", Arrays.asList(new Document("text", 
23                            new Document("query", "ghost")
24                            .append("path", Arrays.asList("plot", "title")))))
25                        .append("mustNot", Arrays.asList(new Document("in", 
26                            new Document("value", Arrays.asList(new ObjectId("573a13cdf29313caabd83c08"), 
27                                new ObjectId("573a13cef29313caabd873a2")))
28                                .append("path", "_id"))))), 
29                    new Document("compound", 
30                        new Document("must", Arrays.asList(new Document("text", 
31                            new Document("query", "ghost")
32                            .append("path", Arrays.asList("plot", "title")))))
33                        .append("filter", Arrays.asList(new Document("in", 
34                            new Document("value", Arrays.asList(new ObjectId("573a13cdf29313caabd83c08"), 
35                                new ObjectId("573a13cef29313caabd873a2")))
36                        .append("path", "_id"))))
37                        .append("score", new Document("boost", 
38                            new Document("value", 0.5d)))))
39            	)
40            )
41         );
42    // specify connection
43    String uri = "<connection-string>";
44    // establish connection and set namespace
45    try (MongoClient mongoClient = MongoClients.create(uri)) {
46      MongoDatabase database = mongoClient.getDatabase("sample_mflix");
47      MongoCollection<Document> collection = database.getCollection("movies");
48	// run query and print results		
49      collection.aggregate(Arrays.asList(agg, 
50        limit(10), 
51        project(fields(
52          include("title", "plot", "_id"), 
53          computed("score", new Document("$meta", "searchScore"))))))
54      .forEach(doc -> System.out.println(doc.toJson()));	
55    }
56  }
57}
4

Replace the <connection-string> in the query and then save the file.

Ensure that your connection string includes your database user's credentials. To learn more, see Connect via Drivers.

5

Compile and run the CompoundBuryQuery.java file.

javac CompoundBuryQuery.java
{"_id": {"$oid": "573a139af29313caabcefcce"}, "plot": "Adaption of the famous Oscar Wilde tale about a young American girl that helps a British ghost find rest and forgiveness.", "genres": ["Family", "Drama", "Fantasy"], "title": "The Canterville Ghost", "score": 5.909613132476807}
{"_id": {"$oid": "573a13d8f29313caabda5dc1"}, "plot": "The Little Ghost lives in the castle over looking a small town and awakens for precisely one hour after the clock strikes midnight. Follow him on this adventure to see his first sunrise ever!", "genres": ["Family", "Fantasy"], "title": "The Little Ghost", "score": 5.367666244506836}
{"_id": {"$oid": "573a13c0f29313caabd6139d"}, "plot": "Renowned \"ghost hunter\", Carter Simms is paid to conduct a paranormal investigation of a supposedly haunted house. Along with a cameraman, a reporter, and a spiritual advocate, she embarks on a three night journey into terror.", "genres": ["Horror", "Thriller"], "title": "Death of a Ghost Hunter", "score": 4.676314353942871}
{"_id": {"$oid": "573a1398f29313caabcebf6f"}, "plot": "After an accident leaves a young man dead, his spirit stays behind to warn his lover of impending danger, with the help of a reluctant psychic.", "genres": ["Drama", "Fantasy", "Romance"], "title": "Ghost", "score": 3.9638845920562744}
{"_id": {"$oid": "573a13cdf29313caabd83c08"}, "plot": "A man tries to solve his lover's murder by communicating with her spirit through the help of a medium.", "genres": ["Drama", "Fantasy", "Mystery"], "title": "Ghost", "score": 3.9638845920562744}
{"_id": {"$oid": "573a13cef29313caabd873a2"}, "plot": "A man tries to solve his lover's murder by communicating with her spirit through the help of a medium.", "genres": ["Drama", "Fantasy", "Mystery"], "title": "Ghost", "score": 3.9638845920562744}
{"_id": {"$oid": "573a13c3f29313caabd6a149"}, "plot": "What kind of scenes in a horror film scares you the most? When a ghost appears totally unexpectedly? When the main character does not see the ghost sneaking up behind him? When at the very ...", "genres": ["Horror", "Thriller"], "title": "Coming Soon", "score": 3.526711940765381}
{"_id": {"$oid": "573a1397f29313caabce7ea1"}, "plot": "Four successful elderly gentlemen, members of the Chowder Society, share a gruesome, 50-year old secret. When one of Edward Wanderley's twin sons dies in a bizarre accident, the group ...", "genres": ["Drama", "Horror", "Thriller"], "title": "Ghost Story", "score": 3.3177831172943115}
{"_id": {"$oid": "573a13a4f29313caabd117df"}, "plot": "Stunt motorcyclist Johnny Blaze gives up his soul to become a hellblazing vigilante, to fight against power hungry Blackheart, the son of the devil himself.", "genres": ["Action", "Fantasy", "Thriller"], "title": "Ghost Rider", "score": 3.3177831172943115}
{"_id": {"$oid": "573a13a6f29313caabd185dc"}, "plot": "A salvage crew that discovers a long-lost 1962 passenger ship floating lifeless in a remote region of the Bering Sea soon notices, as they prepare to tow it back to land, that \"strange things\" happen...", "genres": ["Horror", "Mystery"], "title": "Ghost Ship", "score": 3.3177831172943115}

The movie documents in the results contain the query term ghost in the plot or title field and aren't in the Comedy genre. Atlas Search didn't return documents in the Comedy genre with the term ghost in the plot or title field because those documents didn't rank in the top 10 documents since the query reduced the score of those documents by 50%.

javac CompoundBuryQuery.java
{"_id": {"$oid": "573a139af29313caabcefcce"}, "plot": "Adaption of the famous Oscar Wilde tale about a young American girl that helps a British ghost find rest and forgiveness.", "title": "The Canterville Ghost", "score": 5.909613132476807}
{"_id": {"$oid": "573a13d8f29313caabda5dc1"}, "plot": "The Little Ghost lives in the castle over looking a small town and awakens for precisely one hour after the clock strikes midnight. Follow him on this adventure to see his first sunrise ever!", "title": "The Little Ghost", "score": 5.367666244506836}
{"_id": {"$oid": "573a13c0f29313caabd6139d"}, "plot": "Renowned \"ghost hunter\", Carter Simms is paid to conduct a paranormal investigation of a supposedly haunted house. Along with a cameraman, a reporter, and a spiritual advocate, she embarks on a three night journey into terror.", "title": "Death of a Ghost Hunter", "score": 4.676314353942871}
{"_id": {"$oid": "573a1398f29313caabcebf6f"}, "plot": "After an accident leaves a young man dead, his spirit stays behind to warn his lover of impending danger, with the help of a reluctant psychic.", "title": "Ghost", "score": 3.9638845920562744}
{"_id": {"$oid": "573a13c3f29313caabd6a149"}, "plot": "What kind of scenes in a horror film scares you the most? When a ghost appears totally unexpectedly? When the main character does not see the ghost sneaking up behind him? When at the very ...", "title": "Coming Soon", "score": 3.526711940765381}
{"_id": {"$oid": "573a1398f29313caabce912c"}, "plot": "Three unemployed parapsychology professors set up shop as a unique ghost removal service.", "title": "Ghostbusters", "score": 3.5241782665252686}
{"_id": {"$oid": "573a139cf29313caabcf5a48"}, "plot": "Casper, a ghost, teams up with Wendy, a witch, against an evil warlock.", "title": "Casper Meets Wendy", "score": 3.5241782665252686}
{"_id": {"$oid": "573a13bdf29313caabd58274"}, "plot": "Banku, his mother, Anjali Sharma and father move in to their new house -- the Nath villa, unaware of the fact that the house is inhabited by a ghost. It is learnt the ghost is not too happy...", "title": "Bhoothnath", "score": 3.4605300426483154}
{"_id": {"$oid": "573a1397f29313caabce7ea1"}, "plot": "Four successful elderly gentlemen, members of the Chowder Society, share a gruesome, 50-year old secret. When one of Edward Wanderley's twin sons dies in a bizarre accident, the group ...", "title": "Ghost Story", "score": 3.3177831172943115}
{"_id": {"$oid": "573a1398f29313caabcebf79"}, "plot": "Elliot Hopper is a widower with three children, he is currently working on a deal. It seems like his wife illness was very costly and this deal could put them out of the red. However he ...", "title": "Ghost Dad", "score": 3.3177831172943115}

The movie documents in the results contain the query term ghost in the plot or title field and don't have the specified ObjectIds in the _id field. Atlas Search didn't return the documents with the specified ObjectsIds, even though they contain the query term ghost in the title field, because the query reduced the score of these documents by 50% and so, these documents didn't rank in the top 10 documents.

1

Ensure that you add the following dependency to your project.

mongodb-driver-kotlin-coroutine
4.10.0 or higher version
2

Create a file named CompoundBuryQuery.kt.

3

Copy and paste the following code into the CompoundBuryQuery.kt file.

This query uses the following pipeline stages:

  • Searches for movies that contain the term ghost in the plot or title (must clause) and aren't in the comedy genre (mustNot clause).

  • Searches for movies that contain the term ghost in the plot or title (must clause) and are in the comedy genre (filter clause), but reduces the score by 50% (boost).

Limits the number of results to 10 documents.

  • Includes only the _id, title, plot, and genres fields from the documents in the results.

  • Adds a field named score that shows the score in the results.

1import com.mongodb.client.model.Aggregates.limit
2import com.mongodb.client.model.Aggregates.project
3import com.mongodb.client.model.Projections.*
4import com.mongodb.kotlin.client.coroutine.MongoClient
5import kotlinx.coroutines.runBlocking
6import org.bson.Document
7
8fun main() {
9    // establish connection and set namespace
10    val uri = "<connection-string>"
11    val mongoClient = MongoClient.create(uri)
12    val database = mongoClient.getDatabase("sample_mflix")
13    val collection = database.getCollection<Document>("movies")
14
15    runBlocking {
16        // define clauses
17        val mustClause = listOf(
18            Document("text",
19                Document("query", "ghost")
20                    .append("path", listOf("plot","title"))
21            )
22        )
23
24        val mustNotClauseAndFilterClause = listOf(
25            Document("text",
26                Document("query", "Comedy")
27                    .append("path", listOf("genres"))
28            )
29        )
30
31        val compound1 = Document("must", mustClause)
32            .append("mustNot", mustNotClauseAndFilterClause)
33
34        val compound2 = Document("must", mustClause)
35            .append("filter", mustNotClauseAndFilterClause)
36            .append("score",
37                Document("boost",
38                    Document("value", 0.5)
39                )
40            )
41
42        val agg = Document("\$search",
43            Document("index", "compound-query-custom-score-tutorial")
44                .append("compound", Document("should", listOf(
45                    Document("compound", compound1),
46                    Document("compound", compound2)
47                )))
48        )
49
50        val resultsFlow = collection.aggregate<Document>(
51            listOf(
52                agg,
53                limit(10),
54                project(fields(
55                    include("title", "plot", "genres"),
56                    computed("score", Document("\$meta", "searchScore"))
57                ))
58            )
59        )
60        resultsFlow.collect { println(it) }
61    }
62    mongoClient.close()
63}

This query uses the following pipeline stages:

  • Searches for movies that contain the term ghost in the plot or title (must clause), but doesn't have the specified ObjectIds (mustNot clause).

  • Searches for movies that contain the term ghost in the plot or title (must clause) and have the specified ObjectIds (filter clause), but reduces the score by 50% (boost) .

Limits the number of results to 10 documents.

  • Includes only the title, plot, and _id fields from the documents in the results.

  • Adds a field named score that shows the score of the document in the results.

1import com.mongodb.client.model.Aggregates.limit
2import com.mongodb.client.model.Aggregates.project
3import com.mongodb.client.model.Projections.*
4import com.mongodb.kotlin.client.coroutine.MongoClient
5import kotlinx.coroutines.runBlocking
6import org.bson.Document
7import org.bson.types.ObjectId
8
9fun main() {
10    // establish connection and set namespace
11    val uri = "<connection-string>"
12    val mongoClient = MongoClient.create(uri)
13    val database = mongoClient.getDatabase("sample_mflix")
14    val collection = database.getCollection<Document>("movies")
15
16    runBlocking {
17        // define clauses
18        val mustClause = listOf(
19            Document("text",
20                Document("query", "ghost")
21                    .append("path", listOf("plot","title"))
22            )
23        )
24
25        val mustNotClauseAndFilterClause = listOf(
26            Document("in",
27                Document("value", listOf(ObjectId("573a13cdf29313caabd83c08"), ObjectId("573a13cef29313caabd873a2")))
28                    .append("path", "_id")
29            )
30        )
31
32        val compound1 = Document("must", mustClause)
33            .append("mustNot", mustNotClauseAndFilterClause)
34
35        val compound2 = Document("must", mustClause)
36            .append("filter", mustNotClauseAndFilterClause)
37            .append("score",
38                Document("boost",
39                    Document("value", 0.5)
40                )
41            )
42
43        val agg = Document("\$search",
44            Document("index", "compound-query-custom-score-tutorial")
45                .append("compound", Document("should", listOf(
46                    Document("compound", compound1),
47                    Document("compound", compound2)
48                )))
49        )
50
51        val resultsFlow = collection.aggregate<Document>(
52            listOf(
53                agg,
54                limit(10),
55                project(fields(
56                    include("title", "plot", "_id"),
57                    computed("score", Document("\$meta", "searchScore"))
58                ))
59            )
60        )
61        resultsFlow.collect { println(it) }
62    }
63    mongoClient.close()
64}
4

Replace the <connection-string> in the query and then save the file.

Ensure that your connection string includes your database user's credentials. To learn more, see Connect via Drivers.

5

Run the CompoundBuryQuery.kt file.

When you run the CompoundBuryQuery.kt program in your IDE, it prints the following documents:

dotnet run compound-bury-results.csproj
Document{{_id=573a139af29313caabcefcce, plot=Adaption of the famous Oscar Wilde tale about a young American girl that helps a British ghost find rest and forgiveness., genres=[Family, Drama, Fantasy], title=The Canterville Ghost, score=5.909613132476807}}
Document{{_id=573a13d8f29313caabda5dc1, plot=The Little Ghost lives in the castle over looking a small town and awakens for precisely one hour after the clock strikes midnight. Follow him on this adventure to see his first sunrise ever!, genres=[Family, Fantasy], title=The Little Ghost, score=5.367666244506836}}
Document{{_id=573a13c0f29313caabd6139d, plot=Renowned "ghost hunter", Carter Simms is paid to conduct a paranormal investigation of a supposedly haunted house. Along with a cameraman, a reporter, and a spiritual advocate, she embarks on a three night journey into terror., genres=[Horror, Thriller], title=Death of a Ghost Hunter, score=4.676314353942871}}
Document{{_id=573a1398f29313caabcebf6f, plot=After an accident leaves a young man dead, his spirit stays behind to warn his lover of impending danger, with the help of a reluctant psychic., genres=[Drama, Fantasy, Romance], title=Ghost, score=3.9638845920562744}}
Document{{_id=573a13cdf29313caabd83c08, plot=A man tries to solve his lover's murder by communicating with her spirit through the help of a medium., genres=[Drama, Fantasy, Mystery], title=Ghost, score=3.9638845920562744}}
Document{{_id=573a13cef29313caabd873a2, plot=A man tries to solve his lover's murder by communicating with her spirit through the help of a medium., genres=[Drama, Fantasy, Mystery], title=Ghost, score=3.9638845920562744}}
Document{{_id=573a13c3f29313caabd6a149, plot=What kind of scenes in a horror film scares you the most? When a ghost appears totally unexpectedly? When the main character does not see the ghost sneaking up behind him? When at the very ..., genres=[Horror, Thriller], title=Coming Soon, score=3.526711940765381}}
Document{{_id=573a1397f29313caabce7ea1, plot=Four successful elderly gentlemen, members of the Chowder Society, share a gruesome, 50-year old secret. When one of Edward Wanderley's twin sons dies in a bizarre accident, the group ..., genres=[Drama, Horror, Thriller], title=Ghost Story, score=3.3177831172943115}}
Document{{_id=573a13a4f29313caabd117df, plot=Stunt motorcyclist Johnny Blaze gives up his soul to become a hellblazing vigilante, to fight against power hungry Blackheart, the son of the devil himself., genres=[Action, Fantasy, Thriller], title=Ghost Rider, score=3.3177831172943115}}
Document{{_id=573a13a6f29313caabd185dc, plot=A salvage crew that discovers a long-lost 1962 passenger ship floating lifeless in a remote region of the Bering Sea soon notices, as they prepare to tow it back to land, that "strange things" happen..., genres=[Horror, Mystery], title=Ghost Ship, score=3.3177831172943115}}

The movie documents in the results contain the query term ghost in the plot or title field and aren't in the Comedy genre. Atlas Search didn't return documents in the Comedy genre with the term ghost in the plot or title field because those documents didn't rank in the top 10 documents since the query reduced the score of those documents by 50%.

dotnet run compound-bury-results.csproj
Document{{_id=573a139af29313caabcefcce, plot=Adaption of the famous Oscar Wilde tale about a young American girl that helps a British ghost find rest and forgiveness., title=The Canterville Ghost, score=5.909613132476807}}
Document{{_id=573a13d8f29313caabda5dc1, plot=The Little Ghost lives in the castle over looking a small town and awakens for precisely one hour after the clock strikes midnight. Follow him on this adventure to see his first sunrise ever!, title=The Little Ghost, score=5.367666244506836}}
Document{{_id=573a13c0f29313caabd6139d, plot=Renowned "ghost hunter", Carter Simms is paid to conduct a paranormal investigation of a supposedly haunted house. Along with a cameraman, a reporter, and a spiritual advocate, she embarks on a three night journey into terror., title=Death of a Ghost Hunter, score=4.676314353942871}}
Document{{_id=573a1398f29313caabcebf6f, plot=After an accident leaves a young man dead, his spirit stays behind to warn his lover of impending danger, with the help of a reluctant psychic., title=Ghost, score=3.9638845920562744}}
Document{{_id=573a13c3f29313caabd6a149, plot=What kind of scenes in a horror film scares you the most? When a ghost appears totally unexpectedly? When the main character does not see the ghost sneaking up behind him? When at the very ..., title=Coming Soon, score=3.526711940765381}}
Document{{_id=573a1398f29313caabce912c, plot=Three unemployed parapsychology professors set up shop as a unique ghost removal service., title=Ghostbusters, score=3.5241782665252686}}
Document{{_id=573a139cf29313caabcf5a48, plot=Casper, a ghost, teams up with Wendy, a witch, against an evil warlock., title=Casper Meets Wendy, score=3.5241782665252686}}
Document{{_id=573a13bdf29313caabd58274, plot=Banku, his mother, Anjali Sharma and father move in to their new house -- the Nath villa, unaware of the fact that the house is inhabited by a ghost. It is learnt the ghost is not too happy..., title=Bhoothnath, score=3.4605300426483154}}
Document{{_id=573a1397f29313caabce7ea1, plot=Four successful elderly gentlemen, members of the Chowder Society, share a gruesome, 50-year old secret. When one of Edward Wanderley's twin sons dies in a bizarre accident, the group ..., title=Ghost Story, score=3.3177831172943115}}
Document{{_id=573a1398f29313caabcebf79, plot=Elliot Hopper is a widower with three children, he is currently working on a deal. It seems like his wife illness was very costly and this deal could put them out of the red. However he ..., title=Ghost Dad, score=3.3177831172943115}}

The movie documents in the results contain the query term ghost in the plot or title field and don't have the specified ObjectIds in the _id field. Atlas Search didn't return the documents with the specified ObjectsIds, even though they contain the query term ghost in the title field, because the query reduced the score of these documents by 50% and so, these documents didn't rank in the top 10 documents.

1

Create a file named compound-bury-results.js.

2

Copy and paste the sample query into the compound-bury-results.js file.

This query uses the following pipeline stages:

  • Searches for movies that contain the term ghost in the plot or title (must clause) and aren't in the comedy genre (mustNot clause).

  • Searches for movies that contain the term ghost in the plot or title (must clause) and are in the comedy genre (filter clause), but reduces the score by 50% (boost).

Limits the number of results to 10 documents.

  • Includes only the _id, title, plot, and genres fields from the documents in the results.

  • Adds a field named score that shows the score in the results.

1const { MongoClient } = require("mongodb");
2
3// connect to your Atlas cluster
4const uri = "<connection-string>";
5const client = new MongoClient(uri);
6
7async function run() {
8  try {
9    await client.connect();
10
11    // set namespace
12    const database = client.db("sample_mflix");
13    const coll = database.collection("movies");
14
15    // define pipeline
16    const agg = [
17      {
18        "$search": {
19            "index": "compound-query-custom-score-tutorial", 
20            "compound": {
21            "should": [
22              {
23                "compound": {
24                  "must": [
25                    {
26                      "text": {
27                        "query": "ghost", 
28                        "path": [
29                          "plot", "title"
30                        ]
31                      }
32                    }
33                  ], 
34                  "mustNot": [
35                    {
36                      "text": {
37                        "query": "Comedy", 
38                        "path": [
39                          "genres"
40                        ]
41                      }
42                    }
43                  ]
44                }
45              }, {
46                "compound": {
47                  "must": [
48                    {
49                      "text": {
50                        "query": "ghost", 
51                        "path": [
52                          "plot", "title"
53                        ]
54                      }
55                    }
56                  ], 
57                  "filter": [
58                    {
59                      "text": {
60                        "query": "Comedy", 
61                        "path": [
62                          "genres"
63                        ]
64                      }
65                    }
66                  ], 
67                  "score": { "boost": { "value": 0.5 } }
68                }
69              }
70            ]
71          }
72        }
73      }, {
74        "$limit": 10
75      }, {
76        "$project": {
77          "_id": 1, 
78          "title": 1, 
79          "plot": 1, 
80          "genres": 1, 
81          "score": { "$meta": "searchScore" }
82        }
83      }
84    ];
85
86  // run pipeline
87   const result = coll.aggregate(agg);
88
89  // print results
90   await result.forEach((doc) => console.dir(JSON.stringify(doc)));
91  } finally {
92    await client.close();
93  }
94}
95run().catch(console.dir);

This query uses the following pipeline stages:

  • Searches for movies that contain the term ghost in the plot or title (must clause), but doesn't have the specified ObjectIds (mustNot clause).

  • Searches for movies that contain the term ghost in the plot or title (must clause) and have the specified ObjectIds (filter clause), but reduces the score by 50% (boost) .

Limits the number of results to 10 documents.

  • Includes only the title, plot, and _id fields from the documents in the results.

  • Adds a field named score that shows the score of the document in the results.

1const { MongoClient } = require("mongodb");
2const { ObjectId } = require("mongodb");
3
4// connect to your Atlas cluster
5const uri = "<connection-string>";
6const client = new MongoClient(uri);
7
8async function run() {
9  try {
10    await client.connect();
11
12    // set namespace
13    const database = client.db("sample_mflix");
14    const coll = database.collection("movies");
15
16    // define pipeline
17    const agg = [
18      {
19        '$search': {
20          'index': 'compound-query-custom-score-tutorial',
21          'compound': {
22            'should': [
23              {
24                'compound': {
25                  'must': [
26                    {
27                      'text': {
28                        'query': 'ghost', 
29                        'path': [ 'plot', 'title' ]
30                      }
31                    }
32                  ], 
33                  'mustNot': [
34                    {
35                      'in': {
36                        'value': [ new ObjectId('573a13cdf29313caabd83c08'), new ObjectId('573a13cef29313caabd873a2')  ], 
37                        'path': '_id'
38                      }
39                    }
40                  ]
41                }
42              }, {
43                'compound': {
44                  'must': [
45                    {
46                      'text': {
47                        'query': 'ghost', 
48                        'path': [ 'plot', 'title' ]
49                      }
50                    }
51                  ], 
52                  'filter': [
53                    {
54                      'in': {
55                        'value': [ new ObjectId('573a13cdf29313caabd83c08'), new ObjectId('573a13cef29313caabd873a2') ], 
56                        'path': '_id'
57                      }
58                    }
59                  ], 
60                  'score': {
61                    'boost': { 'value': 0.5 }
62                  }
63                }
64              }
65            ]
66          }
67        }
68      }, {
69        '$limit': 10
70      }, {
71        '$project': {
72          '_id': 1, 
73          'title': 1, 
74          'plot': 1, 
75          'score': { '$meta': 'searchScore' }
76        }
77      }
78    ];
79
80  // run pipeline
81    const result = coll.aggregate(agg);
82
83  // print results
84    await result.forEach((doc) => console.dir(JSON.stringify(doc)));
85  } finally {
86    await client.close();
87  }
88}
89run().catch(console.dir);
3

Replace the <connection-string> in the query and then save the file.

Ensure that your connection string includes your database user's credentials. To learn more, see Connect via Drivers.

4

Query your collection.

Run the following command to query your collection:

node compound-bury-results.js
{"_id":"573a139af29313caabcefcce","plot":"Adaption of the famous Oscar Wilde tale about a young American girl that helps a British ghost find rest and forgiveness.","genres":["Family","Drama","Fantasy"],"title":"The Canterville Ghost","score":5.909613132476807}
{"_id":"573a13d8f29313caabda5dc1","plot":"The Little Ghost lives in the castle over looking a small town and awakens for precisely one hour after the clock strikes midnight. Follow him on this adventure to see his first sunrise ever!","genres":["Family","Fantasy"],"title":"The Little Ghost","score":5.367666244506836}
{"_id":"573a13c0f29313caabd6139d","plot":"Renowned \\"ghost hunter\\", Carter Simms is paid to conduct a paranormal investigation of a supposedly haunted house. Along with a cameraman, a reporter, and a spiritual advocate, she embarks on a three night journey into terror.","genres":["Horror","Thriller"],"title":"Death of a Ghost Hunter","score":4.676314353942871}
{"_id":"573a1398f29313caabcebf6f","plot":"After an accident leaves a young man dead, his spirit stays behind to warn his lover of impending danger, with the help of a reluctant psychic.","genres":["Drama","Fantasy","Romance"],"title":"Ghost","score":3.9638845920562744}
{"_id":"573a13cdf29313caabd83c08","plot":"A man tries to solve his lovers murder by communicating with her spirit through the help of a medium.","genres":["Drama","Fantasy","Mystery"],"title":"Ghost","score":3.9638845920562744}
{"_id":"573a13cef29313caabd873a2","plot":"A man tries to solve his lovers murder by communicating with her spirit through the help of a medium.","genres":["Drama","Fantasy","Mystery"],"title":"Ghost","score":3.9638845920562744}
{"_id":"573a13c3f29313caabd6a149","plot":"What kind of scenes in a horror film scares you the most? When a ghost appears totally unexpectedly? When the main character does not see the ghost sneaking up behind him? When at the very ...","genres":["Horror","Thriller"],"title":"Coming Soon","score":3.526711940765381}
{"_id":"573a1397f29313caabce7ea1","plot":"Four successful elderly gentlemen, members of the Chowder Society, share a gruesome, 50-year old secret. When one of Edward Wanderleys twin sons dies in a bizarre accident, the group ...","genres":["Drama","Horror","Thriller"],"title":"Ghost Story","score":3.3177831172943115}
{"_id":"573a13a4f29313caabd117df","plot":"Stunt motorcyclist Johnny Blaze gives up his soul to become a hellblazing vigilante, to fight against power hungry Blackheart, the son of the devil himself.","genres":["Action","Fantasy","Thriller"],"title":"Ghost Rider","score":3.3177831172943115}
{"_id":"573a13a6f29313caabd185dc","plot":"A salvage crew that discovers a long-lost 1962 passenger ship floating lifeless in a remote region of the Bering Sea soon notices, as they prepare to tow it back to land, that \\"strange things\\" happen...","genres":["Horror","Mystery"],"title":"Ghost Ship","score":3.3177831172943115}

The movie documents in the results contain the query term ghost in the plot or title field and aren't in the Comedy genre. Atlas Search didn't return documents in the Comedy genre with the term ghost in the plot or title field because those documents didn't rank in the top 10 documents since the query reduced the score of those documents by 50%.

node compound-bury-results.js
{"_id":"573a139af29313caabcefcce","plot":"Adaption of the famous Oscar Wilde tale about a young American girl that helps a British ghost find rest and forgiveness.","title":"The Canterville Ghost","score":5.909613132476807}
{"_id":"573a13d8f29313caabda5dc1","plot":"The Little Ghost lives in the castle over looking a small town and awakens for precisely one hour after the clock strikes midnight. Follow him on this adventure to see his first sunrise ever!","title":"The Little Ghost","score":5.367666244506836}
{"_id":"573a13c0f29313caabd6139d","plot":"Renowned \\"ghost hunter\\", Carter Simms is paid to conduct a paranormal investigation of a supposedly haunted house. Along with a cameraman, a reporter, and a spiritual advocate, she embarks on a three night journey into terror.","title":"Death of a Ghost Hunter","score":4.676314353942871}
{"_id":"573a1398f29313caabcebf6f","plot":"After an accident leaves a young man dead, his spirit stays behind to warn his lover of impending danger, with the help of a reluctant psychic.","title":"Ghost","score":3.9638845920562744}
{"_id":"573a13c3f29313caabd6a149","plot":"What kind of scenes in a horror film scares you the most? When a ghost appears totally unexpectedly? When the main character does not see the ghost sneaking up behind him? When at the very ...","title":"Coming Soon","score":3.526711940765381}
{"_id":"573a1398f29313caabce912c","plot":"Three unemployed parapsychology professors set up shop as a unique ghost removal service.","title":"Ghostbusters","score":3.5241782665252686}
{"_id":"573a139cf29313caabcf5a48","plot":"Casper, a ghost, teams up with Wendy, a witch, against an evil warlock.","title":"Casper Meets Wendy","score":3.5241782665252686}
{"_id":"573a13bdf29313caabd58274","plot":"Banku, his mother, Anjali Sharma and father move in to their new house -- the Nath villa, unaware of the fact that the house is inhabited by a ghost. It is learnt the ghost is not too happy...","title":"Bhoothnath","score":3.4605300426483154}
{"_id":"573a1397f29313caabce7ea1","plot":"Four successful elderly gentlemen, members of the Chowder Society, share a gruesome, 50-year old secret. When one of Edward Wanderleys twin sons dies in a bizarre accident, the group ...","title":"Ghost Story","score":3.3177831172943115}
{"_id":"573a1398f29313caabcebf79","plot":"Elliot Hopper is a widower with three children, he is currently working on a deal. It seems like his wife illness was very costly and this deal could put them out of the red. However he ...","title":"Ghost Dad","score":3.3177831172943115}

The movie documents in the results contain the query term ghost in the plot or title field and don't have the specified ObjectIds in the _id field. Atlas Search didn't return the documents with the specified ObjectsIds, even though they contain the query term ghost in the title field, because the query reduced the score of these documents by 50% and so, these documents didn't rank in the top 10 documents.

1

Create a file named compound-bury-results.py.

2

Copy and paste the query into the compound-bury-results.py file.

This query uses the following pipeline stages:

  • Searches for movies that contain the term ghost in the plot or title (must clause) and aren't in the comedy genre (mustNot clause).

  • Searches for movies that contain the term ghost in the plot or title (must clause) and are in the comedy genre (filter clause), but reduces the score by 50% (boost).

Limits the number of results to 10 documents.

  • Includes only the _id, title, plot, and genres fields from the documents in the results.

  • Adds a field named score that shows the score in the results.

1import pymongo
2import dns
3
4client = pymongo.MongoClient('<connection-string>')
5result = client['sample_mflix']['movies'].aggregate([
6  {
7    '$search': {
8      'index': 'compound-query-custom-score-tutorial',
9      'compound': {
10        'should': [
11          {
12            'compound': {
13              'must': [
14                {
15                  'text': {
16                    'query': 'ghost', 
17                    'path': [ 'plot', 'title' ]
18                  }
19                }
20              ], 
21              'mustNot': [
22                {
23                  'text': {
24                    'query': 'Comedy', 
25                    'path': [ 'genres' ]
26                  }
27                }
28              ]
29            }
30          }, {
31            'compound': {
32              'must': [
33                {
34                  'text': {
35                    'query': 'ghost', 
36                    'path': [ 'plot', 'title' ]
37                  }
38                }
39              ], 
40              'filter': [
41                {
42                  'text': {
43                    'query': 'Comedy', 
44                    'path': [ 'genres' ]
45                  }
46                }
47              ], 
48              'score': { 'boost': { 'value': 0.5 } }
49            }
50          }
51        ]
52      }
53    }
54  }, {
55    '$limit': 10
56  }, {
57    '$project': {
58      '_id': 1, 
59      'title': 1, 
60      'plot': 1, 
61      'genres': 1, 
62      'score': { '$meta': 'searchScore' }
63    }
64  }
65])
66
67for i in result:
68    print(i)

This query uses the following pipeline stages:

  • Searches for movies that contain the term ghost in the plot or title (must clause), but doesn't have the specified ObjectIds (mustNot clause).

  • Searches for movies that contain the term ghost in the plot or title (must clause) and have the specified ObjectIds (filter clause), but reduces the score by 50% (boost) .

Limits the number of results to 10 documents.

  • Includes only the title, plot, and _id fields from the documents in the results.

  • Adds a field named score that shows the score of the document in the results.

1import pymongo
2import dns
3from bson import ObjectId
4
5client = pymongo.MongoClient('<connection-string>')
6result = client['sample_mflix']['movies'].aggregate([
7  {
8    '$search': {
9      'index': 'compound-query-custom-score-tutorial',
10      'compound': {
11        'should': [
12          {
13            'compound': {
14              'must': [
15                {
16                  'text': {
17                    'query': 'ghost', 
18                    'path': [ 'plot', 'title' ]
19                  }
20                }
21              ], 
22              'mustNot': [
23                {
24                  'in': {
25                    'value': [ ObjectId('573a13cdf29313caabd83c08'), ObjectId('573a13cef29313caabd873a2') ], 
26                    'path': '_id'
27                  }
28                }
29              ]
30            }
31          }, {
32            'compound': {
33              'must': [
34                {
35                  'text': {
36                    'query': 'ghost', 
37                    'path': [ 'plot', 'title' ]
38                  }
39                }
40              ], 
41              'filter': [
42                {
43                  'in': {
44                    'value': [ ObjectId('573a13cdf29313caabd83c08'), ObjectId('573a13cef29313caabd873a2') ], 
45                    'path': '_id'
46                  }
47                }
48              ], 
49              'score': { 'boost': { 'value': 0.5 } }
50            }
51          }
52        ]
53      }
54    }
55  }, {
56    '$limit': 10
57  }, {
58    '$project': {
59      '_id': 1, 
60      'title': 1, 
61      'plot': 1, 
62      'score': { '$meta': 'searchScore' }
63    }
64  }
65])
66
67for i in result:
68    print(i)
3

Replace the <connection-string> in the query and then save the file.

Ensure that your connection string includes your database user's credentials. To learn more, see Connect via Drivers.

4

Run the command to query your collection.

python compound-bury-results.csproj
{'_id': ObjectId('573a139af29313caabcefcce'), 'plot': 'Adaption of the famous Oscar Wilde tale about a young American girl that helps a British ghost find rest and forgiveness.', 'genres': ['Family', 'Drama', 'Fantasy'], 'title': 'The Canterville Ghost', 'score': 5.909613132476807}
{'_id': ObjectId('573a13d8f29313caabda5dc1'), 'plot': 'The Little Ghost lives in the castle over looking a small town and awakens for precisely one hour after the clock strikes midnight. Follow him on this adventure to see his first sunrise ever!', 'genres': ['Family', 'Fantasy'], 'title': 'The Little Ghost', 'score': 5.367666244506836}
{'_id': ObjectId('573a13c0f29313caabd6139d'), 'plot': 'Renowned "ghost hunter", Carter Simms is paid to conduct a paranormal investigation of a supposedly haunted house. Along with a cameraman, a reporter, and a spiritual advocate, she embarks on a three night journey into terror.', 'genres': ['Horror', 'Thriller'], 'title': 'Death of a Ghost Hunter', 'score': 4.676314353942871}
{'_id': ObjectId('573a1398f29313caabcebf6f'), 'plot': 'After an accident leaves a young man dead, his spirit stays behind to warn his lover of impending danger, with the help of a reluctant psychic.', 'genres': ['Drama', 'Fantasy', 'Romance'], 'title': 'Ghost', 'score': 3.9638845920562744}
{'_id': ObjectId('573a13cdf29313caabd83c08'), 'plot': "A man tries to solve his lover's murder by communicating with her spirit through the help of a medium.", 'genres': ['Drama', 'Fantasy', 'Mystery'], 'title': 'Ghost', 'score': 3.9638845920562744}
{'_id': ObjectId('573a13cef29313caabd873a2'), 'plot': "A man tries to solve his lover's murder by communicating with her spirit through the help of a medium.", 'genres': ['Drama', 'Fantasy', 'Mystery'], 'title': 'Ghost', 'score': 3.9638845920562744}
{'_id': ObjectId('573a13c3f29313caabd6a149'), 'plot': 'What kind of scenes in a horror film scares you the most? When a ghost appears totally unexpectedly? When the main character does not see the ghost sneaking up behind him? When at the very ...', 'genres': ['Horror', 'Thriller'], 'title': 'Coming Soon', 'score': 3.526711940765381}
{'_id': ObjectId('573a1397f29313caabce7ea1'), 'plot': "Four successful elderly gentlemen, members of the Chowder Society, share a gruesome, 50-year old secret. When one of Edward Wanderley's twin sons dies in a bizarre accident, the group ...", 'genres': ['Drama', 'Horror', 'Thriller'], 'title': 'Ghost Story', 'score': 3.3177831172943115}
{'_id': ObjectId('573a13a4f29313caabd117df'), 'plot': 'Stunt motorcyclist Johnny Blaze gives up his soul to become a hellblazing vigilante, to fight against power hungry Blackheart, the son of the devil himself.', 'genres': ['Action', 'Fantasy', 'Thriller'], 'title': 'Ghost Rider', 'score': 3.3177831172943115}
{'_id': ObjectId('573a13a6f29313caabd185dc'), 'plot': 'A salvage crew that discovers a long-lost 1962 passenger ship floating lifeless in a remote region of the Bering Sea soon notices, as they prepare to tow it back to land, that "strange things" happen...', 'genres': ['Horror', 'Mystery'], 'title': 'Ghost Ship', 'score': 3.3177831172943115}

The movie documents in the results contain the query term ghost in the plot or title field and aren't in the Comedy genre. Atlas Search didn't return documents in the Comedy genre with the term ghost in the plot or title field because those documents didn't rank in the top 10 documents since the query reduced the score of those documents by 50%.

python compound-bury-results.csproj
{'_id': ObjectId('573a139af29313caabcefcce'), 'plot': 'Adaption of the famous Oscar Wilde tale about a young American girl that helps a British ghost find rest and forgiveness.', 'title': 'The Canterville Ghost', 'score': 5.909613132476807}
{'_id': ObjectId('573a13d8f29313caabda5dc1'), 'plot': 'The Little Ghost lives in the castle over looking a small town and awakens for precisely one hour after the clock strikes midnight. Follow him on this adventure to see his first sunrise ever!', 'title': 'The Little Ghost', 'score': 5.367666244506836}
{'_id': ObjectId('573a13c0f29313caabd6139d'), 'plot': 'Renowned "ghost hunter", Carter Simms is paid to conduct a paranormal investigation of a supposedly haunted house. Along with a cameraman, a reporter, and a spiritual advocate, she embarks on a three night journey into terror.', 'title': 'Death of a Ghost Hunter', 'score': 4.676314353942871}
{'_id': ObjectId('573a1398f29313caabcebf6f'), 'plot': 'After an accident leaves a young man dead, his spirit stays behind to warn his lover of impending danger, with the help of a reluctant psychic.', 'title': 'Ghost', 'score': 3.9638845920562744}
{'_id': ObjectId('573a13c3f29313caabd6a149'), 'plot': 'What kind of scenes in a horror film scares you the most? When a ghost appears totally unexpectedly? When the main character does not see the ghost sneaking up behind him? When at the very ...', 'title': 'Coming Soon', 'score': 3.526711940765381}
{'_id': ObjectId('573a1398f29313caabce912c'), 'plot': 'Three unemployed parapsychology professors set up shop as a unique ghost removal service.', 'title': 'Ghostbusters', 'score': 3.5241782665252686}
{'_id': ObjectId('573a139cf29313caabcf5a48'), 'plot': 'Casper, a ghost, teams up with Wendy, a witch, against an evil warlock.', 'title': 'Casper Meets Wendy', 'score': 3.5241782665252686}
{'_id': ObjectId('573a13bdf29313caabd58274'), 'plot': 'Banku, his mother, Anjali Sharma and father move in to their new house -- the Nath villa, unaware of the fact that the house is inhabited by a ghost. It is learnt the ghost is not too happy...', 'title': 'Bhoothnath', 'score': 3.4605300426483154}
{'_id': ObjectId('573a1397f29313caabce7ea1'), 'plot': "Four successful elderly gentlemen, members of the Chowder Society, share a gruesome, 50-year old secret. When one of Edward Wanderley's twin sons dies in a bizarre accident, the group ...", 'title': 'Ghost Story', 'score': 3.3177831172943115}
{'_id': ObjectId('573a1398f29313caabcebf79'), 'plot': 'Elliot Hopper is a widower with three children, he is currently working on a deal. It seems like his wife illness was very costly and this deal could put them out of the red. However he ...', 'title': 'Ghost Dad', 'score': 3.3177831172943115}

The movie documents in the results contain the query term ghost in the plot or title field and don't have the specified ObjectIds in the _id field. Atlas Search didn't return the documents with the specified ObjectsIds, even though they contain the query term ghost in the title field, because the query reduced the score of these documents by 50% and so, these documents didn't rank in the top 10 documents.

Continue Learning

To learn more about compound queries using Atlas Search, take Unit 9 of the Intro To MongoDB Course on MongoDB University. The 1.5 hour unit includes an overview of Atlas Search and lessons on creating Atlas Search indexes, running $search queries using compound operators, and grouping results using facet.

Back

How to Run an Atlas Search Compound Geo JSON Query

Next

Multilingual