Menu Docs
Página inicial do Docs
/
MongoDB Atlas
/
Atlas Search
/
Tutoriais

Como executar queries compostas do Atlas Search com campos ponderados

Nesta página

  • Crie o índice do Atlas Search com Mapeamento Dinâmico
  • Executar uma query composta
  • Continuar aprendendo

Este tutorial descreve como criar um índice com mapeamento dinâmico na collection sample_mflix.movies . Ele mostra como executar queries compostas no campo year e alterar a pontuação utilizando constant, function e boost. Ele conduz você pelas seguintes etapas:

  1. Configure um índice do Atlas Search com mapeamento dinâmico para a coleção sample_mflix.movies.

  2. Executar queries do Atlas Search no campo year na collection sample_mflix.movies e alterar a pontuação usando uma palavra específica no campo title.

Antes de começar, certifique-se de que seu Atlas cluster atenda aos requisitos descritos nos Pré-requisitos.

Para criar um índice do Atlas Search, você deve ter acesso do Project Data Access Admin ou superior ao projeto.

Crie o índice do Atlas Search com Mapeamento Dinâmico

Nesta seção, você criará um índice do Atlas Search que utiliza mapeamento dinâmico para indexar os campos na collection sample_mflix.movies.

1

No Atlas, acesse a Clusters página do seu projeto.

  1. Se ainda não estiver exibido, selecione a organização que contém o projeto desejado no Menu Organizations na barra de navegação.

  2. Se ainda não estiver exibido, selecione o projeto desejado no menu Projects na barra de navegação.

  3. Se a página Clusters ainda não estiver exibida, clique em Database na barra lateral.

2

Acesse a página do Atlas Search do seu cluster.

Você pode acessar a página Atlas Search na barra lateral, o Data Explorer ou a página de detalhes do cluster.

  1. Na barra lateral, clique em Atlas Search sob o título Services .

  2. Na lista suspensa Select data source , selecione seu cluster e clique em Go to Atlas Search.

  1. Clique no botão Browse Collections para o seu cluster.

  2. Expanda o banco de dados e selecione a coleção.

  3. Clique na aba Search Indexes da collection.

  1. Clique no nome do cluster.

  2. Clique na aba Atlas Search.

3

Clique Create Search Index.

4

Selecione um Atlas Search Configuration Method Nexte clique .

  • Para uma experiência abada, selecione a Pesquisa Atlas Visual Editor.

  • Para editar a definição de índice bruto, selecione a Pesquisa Atlas JSON Editor.

5

Insira o Index Name e defina o Database and Collection.

  1. No campo Index Name, digite compound-query-custom-score-tutorial.

    Observação

    Se você nomear seu índice como default, não precisará especificar um parâmetro index ao usar o estágio do pipeline $search. Caso contrário, você deve especificar o nome do índice utilizando o parâmetro index.

  2. Na seção Database and Collection, localize o banco de dados sample_mflix e selecione a coleção movies.

6

Especifique uma definição de índice.

Você pode criar um índice de pesquisa do Atlas que utiliza mapeamentos dinâmicos ou mapeamentos estáticos. Para saber mais sobre mapeamentos dinâmicos e estáticos, consulte Mapeamentos estáticos e dinâmicos.

A seguinte definição de índice indexa dinamicamente os campos de tipos suportados na collection movies . Você pode usar o Visual Editor do Atlas Search ou o JSON Editor do Atlas Search na interface de usuário do Atlas para criar o índice.

Editor Visual

  1. Clique em Next.

  2. Revise a definição de índice "default" para a collection movies.

Editor JSON

  1. Clique em Next.

  2. Revise a definição do índice.

    A definição do seu índice deve ser semelhante a esta:

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

    A definição de índice acima indexa dinamicamente os campos de tipos suportados em cada documento na collection movies.

  3. Clique em Next.

7

Clique Create Search Index.

8

Feche a You're All Set! janela modal .

Uma janela modal é exibida para que você saiba que seu índice está construindo. Clique no botão Close.

9

Aguarde o índice para concluir a formação.

O índice deve levar cerca de um minuto para ser criado. Enquanto está se formando, a coluna Status mostra Build in Progress. Quando terminar de se formar, a coluna Status mostrará Active.

Executar uma query composta

➤ Use o menu suspenso Selecione a linguagem para definir a linguagem dos exemplos desta seção.

Você pode usar o operador composto para combinar dois ou mais operadores em uma única query. A cada documento que o Atlas Search retorna para sua query é atribuída uma pontuação com base na relevância, da pontuação mais alta para a mais baixa. O Atlas Search fornece um modelo de query composto de amostra com orientação. Para saber mais, consulte Ver modelo de orientação de query.

Nesta seção, você se conectará ao seu cluster do Atlas e executará as queries de amostra utilizando o operador composto nos campos title e year na collection sample_mflix.movies As queries de amostra utilizam uma pontuação personalizada para alterar a pontuação de relevância retornada pelo Atlas Search.

1

No Atlas, vá Clusters para a página do seu projeto.

  1. Se ainda não estiver exibido, selecione a organização que contém o projeto desejado no Menu Organizations na barra de navegação.

  2. Se ainda não estiver exibido, selecione o projeto desejado no menu Projects na barra de navegação.

  3. Se a página Clusters ainda não estiver exibida, clique em Database na barra lateral.

2

Acesse a página do Atlas Search do seu cluster.

Você pode acessar a página Atlas Search na barra lateral, o Data Explorer ou a página de detalhes do cluster.

  1. Na barra lateral, clique em Atlas Search sob o título Services .

  2. Na lista suspensa Select data source , selecione seu cluster e clique em Go to Atlas Search.

  1. Clique no botão Browse Collections para o seu cluster.

  2. Expanda o banco de dados e selecione a coleção.

  3. Clique na aba Search Indexes da collection.

  1. Clique no nome do cluster.

  2. Clique na aba Atlas Search.

3

Vá para Search Tester.

Clique no botão Query à direita do índice para consultar.

4

Visualizar e editar a sintaxe da consulta.

Clique em Edit Query para visualizar uma amostra de sintaxe de consulta padrão no formato JSON .

5

Execute as seguintes queries do Atlas Search com o compound operador na movies collection .

Copie e cole a seguinte consulta no Query Editor e, em seguida, clique no botão Search no Query Editor.

Os exemplos a seguir usam o operador compound com subqueries para pesquisar filmes entre os anos de 2013 e 2015 com o termo snow no campo title.

A seguinte query:

  • Utiliza as seguintes cláusulas do operador compound:

    • filter cláusula com o operador de faixa para procurar filmes entre os anos 2013 e 2015.

    • should a cláusula com o operador de texto para fazer query do termo snow no campo title e alterar score com a opção constant . A opção constant substitui todos os resultados de pontuação do termo de pesquisa por 5.

  • Especifica a opção highlight para retornar trechos de texto do campo title que correspondem à query. Os trechos contêm texto correspondente especificado com type: 'hit' e texto adjacente especificado com 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

Os primeiros quatro documentos dos resultados têm uma pontuação mais alta porque a cláusula should na query especifica uma preferência por documentos com snow no título. A cláusula should também altera a pontuação do termo de query snow usando a opção constant.

A seguinte query:

  • Utiliza as seguintes cláusulas do operador compound:

    • must cláusula com o operador de faixa para procurar filmes entre os anos 2013 e 2015.

    • should a cláusula com o operador de texto para fazer query do termo snow no campo title e alterar score com a opção boost . A opção boost multiplica a pontuação base nos resultados do termo de pesquisa por 2.

  • Especifica a opção highlight para retornar trechos de texto do campo title que correspondem à query. Os trechos contêm texto correspondente especificado com type: 'hit' e texto adjacente especificado com 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

Os primeiros quatro documentos dos resultados têm uma pontuação mais alta porque a cláusula should na query especifica uma preferência por documentos com snow no título. A cláusula should também altera a pontuação do termo de query snow usando a opção boost.

A seguinte query:

  • Usa as seguintes cláusulas do operador compound com a opção boost para priorizar alguns campos mais do que outros campos:

    • must cláusula com o operador de texto para priorizar o gênero comedy mais, seguido pelo termo snow no campo title . A opção boost aplica pesos aos campos.

    • should cláusula com o operador de faixa para procurar filmes entre os anos 2013 e 2015.

    Observação

    A opção boost aplica diferentes pesos aos campos para priorizar os campos.

[
  {
    $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

A seguinte query:

  • Utiliza as seguintes cláusulas do operador compound:

    • must cláusula com o operador de faixa para procurar filmes entre os anos 2013 e 2015.

    • should a cláusula com o operador de texto para fazer query do termo snow no campo title e alterar score com a opção function . A opção function adiciona o seguinte utilizando uma expressão aritmética:

      • A pontuação de relevância da consulta para o termo de pesquisa

      • O valor do campo numérico denominado imdb.rating ou o número 2 para os documentos que não têm o campo imdb.rating.

  • Especifica a opção highlight para retornar trechos de texto do campo title que correspondem à query. Os trechos contêm texto correspondente especificado com type: 'hit' e texto adjacente especificado com 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

Os primeiros quatro documentos dos resultados têm uma pontuação mais alta porque a cláusula should na query especifica uma preferência por documentos com snow no título. A cláusula should também altera a pontuação do termo de query snow usando a opção function.

6

Expanda os resultados da query.

O Search Tester pode não exibir todos os campos nos documentos que ele retorna. Para exibir todos os campos, incluindo o campo que você especifica no caminho da consulta, expanda o documento nos resultados.

1

Conecte-se ao seu cluster em mongosh.

Abra o mongosh em uma janela do terminal e conecte ao seu cluster. Para obter instruções detalhadas sobre a conexão, consulte Conectar via mongosh.

2

Use o sample_mflix banco de dados do .

Execute o seguinte comando no prompt mongosh:

use sample_mflix
3

Execute as seguintes queries do Atlas Search com o compound operador na movies collection .

Os exemplos a seguir usam o operador compound com subqueries para pesquisar filmes entre os anos de 2013 e 2015 com o termo snow no campo title.

Essa query usa os estágios de pipeline a seguir

  • $search para consultar a coleção. A query:

    • Utiliza as seguintes cláusulas do operador compound:

      • filter cláusula com o operador de faixa para procurar filmes entre os anos 2013 e 2015.

      • should a cláusula com o operador de texto para fazer query do termo snow no campo title e alterar score com a opção constant . A opção constant substitui todos os resultados de pontuação do termo de pesquisa por 5.

    • Especifica a opção highlight para retornar trechos de texto do campo title que correspondem à query. Os trechos contêm texto correspondente especificado com type: 'hit' e texto adjacente especificado com type: 'text'.

  • Estágio $limit para limitar a saída a 10 resultados.

  • $project estágio para:

    • Excluir todos os campos, exceto title e year

    • Adicionar um campo score

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" }
    }
  }
])

O Atlas Search retorna os seguintes resultados para 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: [] }
]

Os primeiros quatro documentos dos resultados têm uma pontuação mais alta porque a cláusula should na query especifica uma preferência por documentos com snow no título. A cláusula should também altera a pontuação do termo de query snow usando a opção constant.

Essa query usa os estágios de pipeline a seguir

  • $search para consultar a coleção. A query:

    • Utiliza as seguintes cláusulas do operador compound:

      • must cláusula com o operador de faixa para procurar filmes entre os anos 2013 e 2015.

      • should a cláusula com o operador de texto para fazer query do termo snow no campo title e alterar score com a opção boost . A opção boost multiplica a pontuação base nos resultados do termo de pesquisa por 2.

    • Especifica a opção highlight para retornar trechos de texto do campo title que correspondem à query. Os trechos contêm texto correspondente especificado com type: 'hit' e texto adjacente especificado com type: 'text'.

  • Estágio $limit para limitar a saída a 10 resultados.

  • $project estágio para:

    • Excluir todos os campos, exceto title e year

    • Adicionar um campo score

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" }
    }
  }
])

O Atlas Search retorna os seguintes resultados para 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: [] }
]

Os primeiros quatro documentos dos resultados têm uma pontuação mais alta porque a cláusula should na query especifica uma preferência por documentos com snow no título. A cláusula should também altera a pontuação do termo de query snow usando a opção boost.

Essa query usa os estágios de pipeline a seguir

  • $search para fazer query da collection. A query usa as seguintes cláusulas do operador compound com a opção boost para priorizar alguns campos mais do que outros campos:

    • must cláusula com o operador de texto para priorizar o gênero comedy mais, seguido pelo termo snow no campo title . A opção boost aplica pesos aos campos.

    • should cláusula com o operador de faixa para procurar filmes entre os anos 2013 e 2015.

    Observação

    A opção boost aplica diferentes pesos aos campos para priorizar os campos.

  • Estágio $limit para limitar a saída a 10 resultados.

  • $project estágio para:

    • Exclua todos os campos, exceto title, year e genres

    • Adicionar um campo score

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
    }
  ]

Essa query usa os estágios de pipeline a seguir

  • $search para consultar a coleção. A query:

    • Utiliza as seguintes cláusulas do operador compound:

      • must cláusula com o operador de faixa para procurar filmes entre os anos 2013 e 2015.

      • should a cláusula com o operador de texto para fazer query do termo snow no campo title e alterar score com a opção function . A opção function adiciona o seguinte utilizando uma expressão aritmética:

        • A pontuação de relevância da consulta para o termo de pesquisa

        • O valor do campo numérico denominado imdb.rating ou o número 2 para os documentos que não têm o campo imdb.rating.

    • Especifica a opção highlight para retornar trechos de texto do campo title que correspondem à query. Os trechos contêm texto correspondente especificado com type: 'hit' e texto adjacente especificado com type: 'text'.

  • Estágio $limit para limitar a saída a 10 resultados.

  • $project estágio para:

    • Excluir todos os campos, exceto title e year

    • Adicionar um campo score

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" }
    }
  }
])

O Atlas Search retorna os seguintes resultados para 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: [] }
]

Os primeiros quatro documentos dos resultados têm uma pontuação mais alta porque a cláusula should na query especifica uma preferência por documentos com snow no título. A cláusula should também altera a pontuação do termo de query snow usando a opção function.

1

Conecte-se ao seu cluster no MongoDB Compass.

Abra o MongoDB Compass e conecte-se ao cluster. Para obter instruções detalhadas sobre a conexão, consulte Conectar via Compass.

2

Utilize a movies coleção no sample_mflix banco de dados .

Na tela Database, clique no banco de dados sample_mflix e, em seguida, clique na coleção movies.

3

Execute uma query composta do Atlas Search que altere a pontuação usando a constant opção .

A query executa as seguintes tarefas:

  • Utiliza as seguintes cláusulas do operador compound:

    • filter cláusula com o operador de faixa para procurar filmes entre os anos 2013 e 2015.

    • should a cláusula com o operador de texto para fazer query do termo snow no campo title e alterar score com a opção constant . A opção constant substitui todos os resultados de pontuação do termo de pesquisa por 5.

  • Especifica a opção highlight para retornar trechos de texto do campo title que correspondem à query. Os trechos contêm texto correspondente especificado com type: 'hit' e texto adjacente especificado com type: 'text'.

  • Utiliza os seguintes estágios do pipeline:

    • Estágio $limit para limitar a saída a 10 resultados

    • $fase de projeto para:

      • Excluir todos os campos, exceto title e year

      • Adicionar dois campos denominados score e highlights

Para executar esta consulta no MongoDB Compass:

  1. Clique na aba Aggregations.

  2. Clique em Select... e, em seguida, configure cada um dos seguintes estágios do pipeline, selecionando o estágio no menu suspenso e adicionando a consulta para esse estágio. Clique em Add Stage para adicionar estágios adicionais.

    estágio do pipeline
    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" }
    }

    Se você habilitou o Auto Preview, o MongoDB Compass exibe os seguintes documentos ao lado do estágio de pipeline do $project :

    {
      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: [] }

    Os primeiros quatro documentos dos resultados têm uma pontuação mais alta porque a cláusula should na query especifica uma preferência por documentos com snow no título. A cláusula should também altera a pontuação do termo de query snow usando a opção constant.

4

Execute queries compostas do Atlas Search que alteram a pontuação usando a boost opção .

  1. Clique na aba Aggregations.

  2. Clique em Select... e, em seguida, configure cada um dos seguintes estágios do pipeline, selecionando o estágio no menu suspenso e adicionando a consulta para esse estágio. Clique em Add Stage para adicionar estágios adicionais.

    A consulta utiliza os seguintes estágios de pipeline:

    • $search para executar as seguintes tarefas:

      • Queries usando as seguintes cláusulas do operador compound :

        • must cláusula com o operador de faixa para procurar filmes entre os anos 2013 e 2015.

        • should a cláusula com o operador de texto para fazer query do termo snow no campo title e alterar score com a opção boost . A opção boost multiplica a pontuação base nos resultados do termo de pesquisa por 2.

      • Especifica a opção highlight para retornar trechos de texto do campo title que correspondem à query. Os trechos contêm texto correspondente especificado com type: 'hit' e texto adjacente especificado com type: 'text'.

    • Estágio $limit para limitar a saída a 10 resultados

    • $fase de projeto para:

      • Excluir todos os campos, exceto title e year

      • Adicionar dois campos denominados score e highlights

    estágio do pipeline
    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" }
    }

    Essa query usa os estágios de pipeline a seguir

    • $search para executar as seguintes tarefas:

      • Queries usando as cláusulas do operador compound com a opção boost para priorizar alguns campos mais do que outros campos:

        • must cláusula com o operador de texto para priorizar o gênero comedy mais, seguido pelo termo snow no campo title . A opção boost aplica pesos aos campos.

        • should cláusula com o operador de faixa para procurar filmes entre os anos 2013 e 2015.

        Observação

        A opção boost aplica diferentes pesos aos campos para priorizar os campos.

    • Estágio $limit para limitar a saída a 10 resultados

    • $fase de projeto para:

      • Excluir todos os campos, exceto title e year

      • Adicionar dois campos denominados score e highlights

    • must cláusula com o operador de texto para priorizar o gênero comedy mais, seguido pelo termo snow no campo title . A opção boost aplica pesos aos campos.

    • should cláusula com o operador de faixa para procurar filmes entre os anos 2013 e 2015.

    Observação

    A opção boost aplica diferentes pesos aos campos para priorizar os campos.

    estágio do pipeline
    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" }
    }

    Se você habilitou o Auto Preview, o MongoDB Compass exibe os seguintes documentos ao lado do estágio de pipeline do $project :

    {
      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: [] }

    Os primeiros quatro documentos dos resultados têm uma pontuação mais alta porque a cláusula should na query especifica uma preferência por documentos com snow no título. A cláusula should também altera a pontuação do termo de query snow usando a opção boost.

      [
        {
          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

Execute uma query composta do Atlas Search que altere a pontuação usando a function opção .

A consulta utiliza os seguintes estágios de pipeline:

  • $search estágio para executar as seguintes tarefas:

    • Queries usando as seguintes cláusulas do operador compound :

      • must cláusula com o operador de faixa para procurar filmes entre os anos 2013 e 2015.

      • should a cláusula com o operador de texto para fazer query do termo snow no campo title e alterar score com a opção function . A opção function adiciona o seguinte utilizando uma expressão aritmética:

        • A pontuação de relevância da consulta para o termo de pesquisa

        • O valor do campo numérico denominado imdb.rating ou o número 2 para os documentos que não têm o campo imdb.rating.

    • Especifica a opção highlight para retornar trechos de texto do campo title que correspondem à query. Os trechos contêm texto correspondente especificado com type: 'hit' e texto adjacente especificado com type: 'text'.

  • Estágio $limit para limitar a saída a 10 resultados

  • $fase de projeto para:

    • Excluir todos os campos, exceto title e year

    • Adicionar dois campos denominados score e highlights

Para executar esta consulta no MongoDB Compass:

  1. Clique na aba Aggregations.

  2. Clique em Select... e, em seguida, configure cada um dos seguintes estágios do pipeline, selecionando o estágio no menu suspenso e adicionando a consulta para esse estágio. Clique em Add Stage para adicionar estágios adicionais.

    estágio do pipeline
    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" }
    }

    Se você habilitou o Auto Preview, o MongoDB Compass exibe os seguintes documentos ao lado do estágio de pipeline do $project :

    {
      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: [] }

    Os primeiros quatro documentos dos resultados têm uma pontuação mais alta porque a cláusula should na query especifica uma preferência por documentos com snow no título. A cláusula should também altera a pontuação do termo de query snow usando a opção function.

1

Execute uma query composta do Atlas Search que altere a pontuação usando a constant opção .

  1. Crie um novo diretório chamado compound-constant-example e inicialize seu projeto com o comando dotnet new .

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

  2. Adicione o driver .NET/C# ao seu projeto como uma dependência.

    dotnet add package MongoDB.Driver

  3. Substitua o conteúdo do arquivo Program.cs pelo seguinte código.

    O exemplo de código executa as seguintes tarefas:

    • Importa pacotes e dependências do mongodb .

    • Estabelece uma ligação ao seu cluster Atlas.

    • Utiliza as seguintes cláusulas compostas para fazer query da collection:

      • filter cláusula com o operador de faixa para procurar filmes entre os anos 2013 e 2015.

      • should a cláusula com o operador de texto para fazer query do termo snow no campo title e alterar score com a opção constant . A opção constant substitui todos os resultados de pontuação do termo de pesquisa por 5.

    • Especifica a opção highlight para retornar trechos de texto do campo title que correspondem à query. Os trechos contêm texto correspondente especificado com type: 'hit' e texto adjacente especificado com type: 'text'.

    • Utiliza os seguintes estágios do pipeline:

      • Estágio $limit para limitar a saída a 10 resultados

      • $fase de projeto para:

        • Excluir todos os campos, exceto title e year

        • Adicionar dois campos denominados score e highlights

    • Itera sobre o cursor para imprimir os documentos que correspondem à consulta.

    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. Antes de executar o exemplo, substitua <connection-string> por sua cadeia de conexão do Atlas. Certifique-se de que sua cadeia de conexão inclui as credenciais do usuário do banco de dados. Para saber mais, consulte Conectar via Drivers.

  5. Compile e execute o arquivo Program.cs .

    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 }

    Os primeiros quatro documentos dos resultados têm uma pontuação mais alta porque a cláusula should na query especifica uma preferência por documentos com snow no título. A cláusula should também altera a pontuação do termo de query snow usando a opção constant.

2

Execute queries compostas do Atlas Search que alteram a pontuação usando a boost opção .

  1. Crie um novo diretório chamado compound-boost-example e inicialize seu projeto com o comando dotnet new .

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

  2. Adicione o driver .NET/C# ao seu projeto como uma dependência.

    dotnet add package MongoDB.Driver

  3. Substitua o conteúdo do arquivo Program.cs pelo seguinte código.

    O exemplo de código executa as seguintes tarefas:

    • Importa pacotes e dependências do mongodb .

    • Estabelece uma ligação ao seu cluster Atlas.

    • Itera sobre o cursor para imprimir os documentos que correspondem à consulta.

    A consulta utiliza os seguintes estágios de pipeline:

    • $search estágio para fazer query na collection. A query:

      • Utiliza as seguintes cláusulas do operador compound:

        • must cláusula com o operador de faixa para procurar filmes entre os anos 2013 e 2015.

        • should a cláusula com o operador de texto para fazer query do termo snow no campo title e alterar score com a opção boost . A opção boost multiplica a pontuação base nos resultados do termo de pesquisa por 2.

      Especifica a opção highlight para retornar trechos de texto do campo title que correspondem à query. Os trechos contêm texto correspondente especificado com type: 'hit' e texto adjacente especificado com type: 'text'.

    • Estágio $limit para limitar a saída a 10 resultados

    • $fase de projeto para:

      • Excluir todos os campos, exceto title e year

      • Adicionar dois campos denominados score e 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}

    Esta query usa as seguintes cláusulas do operador compound com a opção boost para priorizar alguns campos mais do que outros campos:

    • must cláusula com o operador de texto para priorizar o gênero comedy mais, seguido pelo termo snow no campo title . A opção boost aplica pesos aos campos.

    • should cláusula com o operador de faixa para procurar filmes entre os anos 2013 e 2015.

    Observação

    A opção boost aplica diferentes pesos aos campos para priorizar os campos.

    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. Antes de executar o exemplo, substitua <connection-string> por sua cadeia de conexão do Atlas. Certifique-se de que sua cadeia de conexão inclui as credenciais do usuário do banco de dados. Para saber mais, consulte Conectar via Drivers.

  5. Compile e execute o arquivo Program.cs .

    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 }

    Os primeiros quatro documentos dos resultados têm uma pontuação mais alta porque a cláusula should na query especifica uma preferência por documentos com snow no título. A cláusula should também altera a pontuação do termo de query snow usando a opção boost.

    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

Execute uma query composta do Atlas Search que altere a pontuação usando a function opção .

  1. Crie um novo diretório chamado compound-function-example e inicialize seu projeto com o comando dotnet new .

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

  2. Adicione o driver .NET/C# ao seu projeto como uma dependência.

    dotnet add package MongoDB.Driver

  3. Substitua o conteúdo do arquivo Program.cs pelo seguinte código.

    O exemplo de código executa as seguintes tarefas:

    • Importa pacotes e dependências do mongodb .

    • Estabelece uma ligação ao seu cluster Atlas.

    • Utiliza os seguintes estágios de pipeline para consultar a coleção:

      • must cláusula com o operador de faixa para procurar filmes entre os anos 2013 e 2015.

      • should a cláusula com o operador de texto para fazer query do termo snow no campo title e alterar score com a opção function . A opção function adiciona o seguinte utilizando uma expressão aritmética:

        • A pontuação de relevância da consulta para o termo de pesquisa

        • O valor do campo numérico denominado imdb.rating ou o número 2 para os documentos que não têm o campo imdb.rating.

    • Utiliza os seguintes estágios do pipeline:

      • Estágio $limit para limitar a saída a 10 resultados

      • $fase de projeto para:

        • Excluir todos os campos, exceto title e year

        • Adicionar dois campos denominados score e highlights

    • Especifica a opção highlight para retornar trechos de texto do campo title que correspondem à query. Os trechos contêm texto correspondente especificado com type: 'hit' e texto adjacente especificado com type: 'text'.

    • Itera sobre o cursor para imprimir os documentos que correspondem à consulta.

    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. Antes de executar o exemplo, substitua <connection-string> por sua cadeia de conexão do Atlas. Certifique-se de que sua cadeia de conexão inclui as credenciais do usuário do banco de dados. Para saber mais, consulte Conectar via Drivers.

  5. Compile e execute o arquivo Program.cs .

    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 }

    Os primeiros quatro documentos dos resultados têm uma pontuação mais alta porque a cláusula should na query especifica uma preferência por documentos com snow no título. A cláusula should também altera a pontuação do termo de query snow usando a opção function.

1

Execute uma query composta do Atlas Search que altere a pontuação usando a constant opção .

  1. Crie um arquivo denominado compound-constant-query.go.

  2. Copie e cole o exemplo de código no arquivo compound-constant-query.go.

    O exemplo de código executa as seguintes tarefas:

    • Importa pacotes e dependências do mongodb .

    • Estabelece uma ligação ao seu cluster Atlas.

    • Utiliza as seguintes cláusulas compostas para fazer query da collection:

      • filter cláusula com o operador de faixa para procurar filmes entre os anos 2013 e 2015.

      • should a cláusula com o operador de texto para fazer query do termo snow no campo title e alterar score com a opção constant . A opção constant substitui todos os resultados de pontuação do termo de pesquisa por 5.

    • Especifica a opção highlight para retornar trechos de texto do campo title que correspondem à query. Os trechos contêm texto correspondente especificado com type: 'hit' e texto adjacente especificado com type: 'text'.

    • Utiliza os seguintes estágios do pipeline:

      • Estágio $limit para limitar a saída a 10 resultados

      • $fase de projeto para:

        • Excluir todos os campos, exceto title e year

        • Adicionar dois campos denominados score e highlights

    • Itera sobre o cursor para imprimir os documentos que correspondem à consulta.

    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. Antes de executar o exemplo, substitua <connection-string> por sua cadeia de conexão do Atlas. Certifique-se de que sua cadeia de conexão inclui as credenciais do usuário do banco de dados. Para saber mais, consulte Conectar via Drivers.

  4. Execute o seguinte comando para consultar sua 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 []}]

    Os primeiros quatro documentos dos resultados têm uma pontuação mais alta porque a cláusula should na query especifica uma preferência por documentos com snow no título. A cláusula should também altera a pontuação do termo de query snow usando a opção constant.

2

Execute uma query composta do Atlas Search que altere a pontuação usando a boost opção .

  1. Crie um arquivo denominado compound-boost-query.go.

  2. Copie e cole o exemplo de código no arquivo compound-boost-query.go.

    Os exemplos de código executam as seguintes tarefas:

    • Importa pacotes e dependências do mongodb .

    • Estabelece uma ligação ao seu cluster Atlas.

    • Itera sobre o cursor para imprimir os documentos que correspondem à consulta.

    A consulta utiliza os seguintes estágios de pipeline:

    • $search estágio para fazer query na collection. A query:

      • Utiliza as seguintes cláusulas compound para fazer query da collection:

        • must cláusula com o operador de faixa para procurar filmes entre os anos 2013 e 2015.

        • should a cláusula com o operador de texto para fazer query do termo snow no campo title e alterar score com a opção boost . A opção boost multiplica a pontuação base nos resultados do termo de pesquisa por 2.

      • Especifica a opção highlight para retornar trechos de texto do campo title que correspondem à query. Os trechos contêm texto correspondente especificado com type: 'hit' e texto adjacente especificado com type: 'text'.

    • Estágio $limit para limitar a saída a 10 resultados

    • $fase de projeto para:

      • Excluir todos os campos, exceto title e year

      • Adicionar dois campos denominados score e 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}

    Essa query usa os estágios de pipeline a seguir

    • $search estágio para fazer query na collection. A query:

      • Usa as cláusulas do operador compound com a opção boost para priorizar alguns campos mais do que outros campos:

        • must cláusula com o operador de texto para priorizar o gênero comedy mais, seguido pelo termo snow no campo title . A opção boost aplica pesos aos campos.

        • should cláusula com o operador de faixa para procurar filmes entre os anos 2013 e 2015.

        Observação

        A opção boost aplica diferentes pesos aos campos para priorizar os campos.

    • Estágio $limit para limitar a saída a 10 resultados

    • $fase de projeto para:

      • Excluir todos os campos, exceto title e year

      • Adicionar dois campos denominados score e 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. Antes de executar o exemplo, substitua <connection-string> por sua cadeia de conexão do Atlas. Certifique-se de que sua cadeia de conexão inclui as credenciais do usuário do banco de dados. Para saber mais, consulte Conectar via Drivers.

  4. Execute o seguinte comando para consultar sua 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 []}]

    Os primeiros quatro documentos dos resultados têm uma pontuação mais alta porque a cláusula should na query especifica uma preferência por documentos com snow no título. A cláusula should também altera a pontuação do termo de query snow usando a opção boost.

    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

Execute uma query composta do Atlas Search que altere a pontuação usando a function opção .

  1. Crie um arquivo denominado compound-boost-query.go.

  2. Copie e cole o exemplo de código no arquivo compound-function-query.go.

    O exemplo de código executa as seguintes tarefas:

    • Importa pacotes e dependências do mongodb .

    • Estabelece uma ligação ao seu cluster Atlas.

    • Utiliza as seguintes cláusulas do operador compound:

      • must cláusula com o operador de faixa para procurar filmes entre os anos 2013 e 2015.

      • should a cláusula com o operador de texto para fazer query do termo snow no campo title e alterar score com a opção function . A opção function adiciona o seguinte utilizando uma expressão aritmética:

        • A pontuação de relevância da consulta para o termo de pesquisa

        • O valor do campo numérico denominado imdb.rating ou o número 2 para os documentos que não têm o campo imdb.rating.

    • Especifica a opção highlight para retornar trechos de texto do campo title que correspondem à query. Os trechos contêm texto correspondente especificado com type: 'hit' e texto adjacente especificado com type: 'text'.

    • Utiliza os seguintes estágios do pipeline:

      • Estágio $limit para limitar a saída a 10 resultados

      • $fase de projeto para:

        • Excluir todos os campos, exceto title e year

        • Adicionar dois campos denominados score e highlights

    • Itera sobre o cursor para imprimir os documentos que correspondem à consulta.

    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. Antes de executar o exemplo, substitua <connection-string> por sua cadeia de conexão do Atlas. Certifique-se de que sua cadeia de conexão inclui as credenciais do usuário do banco de dados. Para saber mais, consulte Conectar via Drivers.

  4. Execute o seguinte comando para consultar sua 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 []}]

    Os primeiros quatro documentos dos resultados têm uma pontuação mais alta porque a cláusula should na query especifica uma preferência por documentos com snow no título. A cláusula should também altera a pontuação do termo de query snow usando a opção function.

1

Certifique-se de que seu CLASSPATH contenha as seguintes bibliotecas.

junit
4.11 ou versão superior
mongodb-driver-sync
4.3.0 ou uma versão superior
slf4j-log4j12
1.7.30 ou uma versão superior
2

Execute uma query composta do Atlas Search que altere a pontuação usando a constant opção .

  1. Crie um arquivo denominado CompoundConstantQuery.java.

  2. Copie e cole o seguinte código no arquivo.

    O exemplo de código executa as seguintes tarefas:

    • Importa pacotes e dependências do mongodb .

    • Estabelece uma ligação ao seu cluster Atlas.

    • Utiliza as seguintes cláusulas compostas para fazer query da collection:

      • filter cláusula com o operador de faixa para procurar filmes entre os anos 2013 e 2015.

      • should a cláusula com o operador de texto para fazer query do termo snow no campo title e alterar score com a opção constant . A opção constant substitui todos os resultados de pontuação do termo de pesquisa por 5.

    • Especifica a opção highlight para retornar trechos de texto do campo title que correspondem à query. Os trechos contêm texto correspondente especificado com type: 'hit' e texto adjacente especificado com type: 'text'.

    • Utiliza os seguintes estágios do pipeline:

      • Estágio $limit para limitar a saída a 10 resultados

      • $fase de projeto para:

        • Excluir todos os campos, exceto title e year

        • Adicionar dois campos denominados score e highlights

    • Itera sobre o cursor para imprimir os documentos que correspondem à consulta.

    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}

    Observação

    Para executar o código de amostra em seu ambiente Maven, adicione o seguinte acima das declarações de importação em seu arquivo.

    package com.mongodb.drivers;

  3. Antes de executar o exemplo, substitua <connection-string> por sua cadeia de conexão do Atlas. Certifique-se de que sua cadeia de conexão inclui as credenciais do usuário do banco de dados. Para saber mais, consulte Conectar via Drivers.

  4. Compile e execute o arquivo CompoundConstantQuery.java .

    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": []}

    Os primeiros quatro documentos dos resultados têm uma pontuação mais alta porque a cláusula should na query especifica uma preferência por documentos com snow no título. A cláusula should também altera a pontuação do termo de query snow usando a opção constant.

3

Execute queries compostas do Atlas Search que alteram a pontuação usando a boost opção .

  1. Crie um arquivo denominado CompoundBoostQuery.java.

  2. Copie e cole o seguinte código no arquivo.

    O exemplo de código executa as seguintes tarefas:

    • Importa pacotes e dependências do mongodb .

    • Estabelece uma ligação ao seu cluster Atlas.

    • Itera sobre o cursor para imprimir os documentos que correspondem à consulta.

    A consulta utiliza os seguintes estágios de pipeline:

    • $search estágio para fazer query na collection. A query:

      • Utiliza as seguintes cláusulas do operador compound:

        • must cláusula com o operador de faixa para procurar filmes entre os anos 2013 e 2015.

        • should a cláusula com o operador de texto para fazer query do termo snow no campo title e alterar score com a opção boost . A opção boost multiplica a pontuação base nos resultados do termo de pesquisa por 2.

      Especifica a opção highlight para retornar trechos de texto do campo title que correspondem à query. Os trechos contêm texto correspondente especificado com type: 'hit' e texto adjacente especificado com type: 'text'.

    • Estágio $limit para limitar a saída a 10 resultados

    • $fase de projeto para:

      • Excluir todos os campos, exceto title e year

      • Adicionar dois campos denominados score e 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}

    Esta query usa as seguintes cláusulas do operador compound com a opção boost para priorizar alguns campos mais do que outros campos:

    • must cláusula com o operador de texto para priorizar o gênero comedy mais, seguido pelo termo snow no campo title . A opção boost aplica pesos aos campos.

    • should cláusula com o operador de faixa para procurar filmes entre os anos 2013 e 2015.

    Observação

    A opção boost aplica diferentes pesos aos campos para priorizar os campos.

    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}

    Observação

    Para executar o código de amostra em seu ambiente Maven, adicione o seguinte acima das declarações de importação em seu arquivo.

    package com.mongodb.drivers;

  3. Antes de executar o exemplo, substitua <connection-string> por sua cadeia de conexão do Atlas. Certifique-se de que sua cadeia de conexão inclui as credenciais do usuário do banco de dados. Para saber mais, consulte Conectar via Drivers.

  4. Compile e execute o arquivo CompoundBoostQuery.java .

    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": []}

    Os primeiros quatro documentos dos resultados têm uma pontuação mais alta porque a cláusula should na query especifica uma preferência por documentos com snow no título. A cláusula should também altera a pontuação do termo de query snow usando a opção boost.

    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

Execute uma query composta do Atlas Search que altere a pontuação usando a function opção .

  1. Crie um arquivo denominado CompoundFunctionQuery.java.

  2. Copie e cole o seguinte código no arquivo.

    O exemplo de código executa as seguintes tarefas:

    • Importa pacotes e dependências do mongodb .

    • Estabelece uma ligação ao seu cluster Atlas.

    • Utiliza os seguintes estágios de pipeline para consultar a coleção:

      • must cláusula com o operador de faixa para procurar filmes entre os anos 2013 e 2015.

      • should a cláusula com o operador de texto para fazer query do termo snow no campo title e alterar score com a opção function . A opção function adiciona o seguinte utilizando uma expressão aritmética:

        • A pontuação de relevância da consulta para o termo de pesquisa

        • O valor do campo numérico denominado imdb.rating ou o número 2 para os documentos que não têm o campo imdb.rating.

    • Utiliza os seguintes estágios do pipeline:

      • Estágio $limit para limitar a saída a 10 resultados

      • $fase de projeto para:

        • Excluir todos os campos, exceto title e year

        • Adicionar dois campos denominados score e highlights

    • Especifica a opção highlight para retornar trechos de texto do campo title que correspondem à query. Os trechos contêm texto correspondente especificado com type: 'hit' e texto adjacente especificado com type: 'text'.

    • Itera sobre o cursor para imprimir os documentos que correspondem à consulta.

    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}

    Observação

    Para executar o código de amostra em seu ambiente Maven, adicione o seguinte acima das declarações de importação em seu arquivo.

    package com.mongodb.drivers;

  3. Antes de executar o exemplo, substitua <connection-string> por sua cadeia de conexão do Atlas. Certifique-se de que sua cadeia de conexão inclui as credenciais do usuário do banco de dados. Para saber mais, consulte Conectar via Drivers.

  4. Compile e execute o arquivo CompoundFunctionQuery.java .

    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": []}

    Os primeiros quatro documentos dos resultados têm uma pontuação mais alta porque a cláusula should na query especifica uma preferência por documentos com snow no título. A cláusula should também altera a pontuação do termo de query snow usando a opção function.

1

Certifique-se de adicionar a seguinte dependência ao seu projeto.

mongodb-driver-kotlin-coroutine
4.10.0 ou uma versão superior
2

Execute uma query composta do Atlas Search que altere a pontuação usando a constant opção .

  1. Crie um arquivo denominado CompoundConstantQuery.kt.

  2. Copie e cole o seguinte código no arquivo.

    O exemplo de código executa as seguintes tarefas:

    • Importa pacotes e dependências do mongodb .

    • Estabelece uma ligação ao seu cluster Atlas.

    • Utiliza as seguintes cláusulas compostas para fazer query da collection:

      • filter cláusula com o operador de faixa para procurar filmes entre os anos 2013 e 2015.

      • should a cláusula com o operador de texto para fazer query do termo snow no campo title e alterar score com a opção constant . A opção constant substitui todos os resultados de pontuação do termo de pesquisa por 5.

    • Especifica a opção highlight para retornar trechos de texto do campo title que correspondem à query. Os trechos contêm texto correspondente especificado com type: 'hit' e texto adjacente especificado com type: 'text'.

    • Utiliza os seguintes estágios do pipeline:

      • Estágio $limit para limitar a saída a 10 resultados

      • $fase de projeto para:

        • Excluir todos os campos, exceto title e year

        • Adicionar dois campos denominados score e highlights

    • Imprime os documentos que correspondem à query da instância AggregateFlow.

    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. Antes de executar o exemplo, substitua <connection-string> por sua cadeia de conexão do Atlas. Certifique-se de que sua cadeia de conexão inclui as credenciais do usuário do banco de dados. Para saber mais, consulte Conectar via Drivers.

  4. Execute o arquivo CompoundConstantQuery.kt.

    Ao executar o programa CompoundConstantQuery.kt no seu IDE, ele imprime os seguintes documentos:

    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=[]}}

    Os primeiros quatro documentos dos resultados têm uma pontuação mais alta porque a cláusula should na query especifica uma preferência por documentos com snow no título. A cláusula should também altera a pontuação do termo de query snow usando a opção constant.

3

Execute queries compostas do Atlas Search que alteram a pontuação usando a boost opção .

  1. Crie um arquivo denominado CompoundBoostQuery.kt.

  2. Copie e cole o seguinte código no arquivo.

    O exemplo de código executa as seguintes tarefas:

    • Importa pacotes e dependências do mongodb .

    • Estabelece uma ligação ao seu cluster Atlas.

    • Imprime os documentos que correspondem à query da instância AggregateFlow.

    A consulta utiliza os seguintes estágios de pipeline:

    • $search estágio para fazer query na collection. A query:

      • Utiliza as seguintes cláusulas do operador compound:

        • must cláusula com o operador de faixa para procurar filmes entre os anos 2013 e 2015.

        • should a cláusula com o operador de texto para fazer query do termo snow no campo title e alterar score com a opção boost . A opção boost multiplica a pontuação base nos resultados do termo de pesquisa por 2.

      Especifica a opção highlight para retornar trechos de texto do campo title que correspondem à query. Os trechos contêm texto correspondente especificado com type: 'hit' e texto adjacente especificado com type: 'text'.

    • Estágio $limit para limitar a saída a 10 resultados

    • $fase de projeto para:

      • Excluir todos os campos, exceto title e year

      • Adicionar dois campos denominados score e 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}

    Esta query usa as seguintes cláusulas do operador compound com a opção boost para priorizar alguns campos mais do que outros campos:

    • must cláusula com o operador de texto para priorizar o gênero comedy mais, seguido pelo termo snow no campo title . A opção boost aplica pesos aos campos.

    • should cláusula com o operador de faixa para procurar filmes entre os anos 2013 e 2015.

    Observação

    A opção boost aplica diferentes pesos aos campos para priorizar os campos.

    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. Antes de executar o exemplo, substitua <connection-string> por sua cadeia de conexão do Atlas. Certifique-se de que sua cadeia de conexão inclui as credenciais do usuário do banco de dados. Para saber mais, consulte Conectar via Drivers.

  4. Execute o arquivo CompoundBoostQuery.kt.

    Ao executar o programa CompoundBoostQuery.kt no seu IDE, ele imprime os seguintes documentos:

    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=[]}}

    Os primeiros quatro documentos dos resultados têm uma pontuação mais alta porque a cláusula should na query especifica uma preferência por documentos com snow no título. A cláusula should também altera a pontuação do termo de query snow usando a opção boost.

    Ao executar o programa CompoundBoostQuery.kt no seu IDE, ele imprime os seguintes documentos:

    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

Execute uma query composta do Atlas Search que altere a pontuação usando a function opção .

  1. Crie um arquivo denominado CompoundFunctionQuery.kt.

  2. Copie e cole o seguinte código no arquivo.

    O exemplo de código executa as seguintes tarefas:

    • Importa pacotes e dependências do mongodb .

    • Estabelece uma ligação ao seu cluster Atlas.

    • Utiliza os seguintes estágios de pipeline para consultar a coleção:

      • must cláusula com o operador de faixa para procurar filmes entre os anos 2013 e 2015.

      • should a cláusula com o operador de texto para fazer query do termo snow no campo title e alterar score com a opção function . A opção function adiciona o seguinte utilizando uma expressão aritmética:

        • A pontuação de relevância da consulta para o termo de pesquisa

        • O valor do campo numérico denominado imdb.rating ou o número 2 para os documentos que não têm o campo imdb.rating.

    • Utiliza os seguintes estágios do pipeline:

      • Estágio $limit para limitar a saída a 10 resultados

      • $fase de projeto para:

        • Excluir todos os campos, exceto title e year

        • Adicionar dois campos denominados score e highlights

    • Especifica a opção highlight para retornar trechos de texto do campo title que correspondem à query. Os trechos contêm texto correspondente especificado com type: 'hit' e texto adjacente especificado com type: 'text'.

    • Imprime os documentos que correspondem à query da instância AggregateFlow.

    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. Antes de executar o exemplo, substitua <connection-string> por sua cadeia de conexão do Atlas. Certifique-se de que sua cadeia de conexão inclui as credenciais do usuário do banco de dados. Para saber mais, consulte Conectar via Drivers.

  4. Execute o arquivo CompoundFunctionQuery.kt.

    Ao executar o programa CompoundFunctionQuery.kt no seu IDE, ele imprime os seguintes documentos:

    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=[]}}

    Os primeiros quatro documentos dos resultados têm uma pontuação mais alta porque a cláusula should na query especifica uma preferência por documentos com snow no título. A cláusula should também altera a pontuação do termo de query snow usando a opção function.

1

Execute uma query composta do Atlas Search que altere a pontuação usando a constant opção .

  1. Crie um arquivo denominado compound-constant-query.js.

  2. Copie e cole o exemplo de código no arquivo compound-constant-query.js.

    O exemplo de código executa as seguintes tarefas:

    • Importa mongodb, o driver do Node.js da MongoDB.

    • Cria uma instância da classe MongoClient para estabelecer uma conexão com seu cluster do Atlas.

    • Utiliza as seguintes cláusulas compostas para fazer query da collection:

      • filter cláusula com o operador de faixa para procurar filmes entre os anos 2013 e 2015.

      • should a cláusula com o operador de texto para fazer query do termo snow no campo title e alterar score com a opção constant . A opção constant substitui todos os resultados de pontuação do termo de pesquisa por 5.

    • Especifica a opção highlight para retornar trechos de texto do campo title que correspondem à query. Os trechos contêm texto correspondente especificado com type: 'hit' e texto adjacente especificado com type: 'text'.

    • Utiliza os seguintes estágios do pipeline:

      • Estágio $limit para limitar a saída a 10 resultados

      • $fase de projeto para:

        • Excluir todos os campos, exceto title e year

        • Adicionar dois campos denominados score e highlights

    • Itera sobre o cursor para imprimir os documentos que correspondem à consulta.

    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. Antes de executar o exemplo, substitua <connection-string> por sua cadeia de conexão do Atlas. Certifique-se de que sua cadeia de conexão inclui as credenciais do usuário do banco de dados. Para saber mais, consulte Conectar via Drivers.

  4. Execute o seguinte comando para consultar sua 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":[]}'

    Os primeiros quatro documentos dos resultados têm uma pontuação mais alta porque a cláusula should na query especifica uma preferência por documentos com snow no título. A cláusula should também altera a pontuação do termo de query snow usando a opção constant.

2

Execute uma query composta do Atlas Search que altere a pontuação usando a boost opção .

  1. Crie um arquivo denominado compound-boost-query.js.

  2. Copie e cole o exemplo de código no arquivo compound-boost-query.js.

    O exemplo de código executa as seguintes tarefas:

    • Importa mongodb, o driver do Node.js da MongoDB.

    • Cria uma instância da classe MongoClient para estabelecer uma conexão com seu cluster do Atlas.

    • Itera sobre o cursor para imprimir os documentos que correspondem à consulta.

    A consulta utiliza os seguintes estágios de pipeline:

    • $search estágio para fazer query na collection. A query:

      • Utiliza as seguintes cláusulas do operador compound:

        • must cláusula com o operador de faixa para procurar filmes entre os anos 2013 e 2015.

        • should a cláusula com o operador de texto para fazer query do termo snow no campo title e alterar score com a opção boost . A opção boost multiplica a pontuação base nos resultados do termo de pesquisa por 2.

      • Especifica a opção highlight para retornar trechos de texto do campo title que correspondem à query. Os trechos contêm texto correspondente especificado com type: 'hit' e texto adjacente especificado com type: 'text'.

    • Estágio $limit para limitar a saída a 10 resultados

    • $fase de projeto para:

      • Excluir todos os campos, exceto title e year

      • Adicionar dois campos denominados score e 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);

    A consulta utiliza os seguintes estágios de pipeline:

    • $search estágio para fazer query na collection. A query:

      • Usa as seguintes cláusulas do operador compound com a opção boost para priorizar alguns campos mais do que outros campos:

        • must cláusula com o operador de texto para priorizar o gênero comedy mais, seguido pelo termo snow no campo title . A opção boost aplica pesos aos campos.

        • should cláusula com o operador de faixa para procurar filmes entre os anos 2013 e 2015.

        Observação

        A opção boost aplica diferentes pesos aos campos para priorizar os campos.

      • Estágio $limit para limitar a saída a 10 resultados

      • $fase de projeto para:

        • Excluir todos os campos, exceto title e year

        • Adicionar dois campos denominados score e 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. Antes de executar o exemplo, substitua <connection-string> por sua cadeia de conexão do Atlas. Certifique-se de que sua cadeia de conexão inclui as credenciais do usuário do banco de dados. Para saber mais, consulte Conectar via Drivers.

  4. Execute o seguinte comando para consultar sua 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":[]}'

    Os primeiros quatro documentos dos resultados têm uma pontuação mais alta porque a cláusula should na query especifica uma preferência por documentos com snow no título. A cláusula should também altera a pontuação do termo de query snow usando a opção boost.

    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

Execute uma query composta do Atlas Search que altere a pontuação usando a function opção .

  1. Crie um arquivo denominado compound-function-query.js.

  2. Copie e cole o exemplo de código no arquivo compound-function-query.js.

    O exemplo de código executa as seguintes tarefas:

    • Importa mongodb, o driver do Node.js da MongoDB.

    • Cria uma instância da classe MongoClient para estabelecer uma conexão com seu cluster do Atlas.

    • Utiliza as seguintes cláusulas compostas para fazer query da collection:

      • must cláusula com o operador de faixa para procurar filmes entre os anos 2013 e 2015.

      • should a cláusula com o operador de texto para fazer query do termo snow no campo title e alterar score com a opção function . A opção function adiciona o seguinte utilizando uma expressão aritmética:

        • A pontuação de relevância da consulta para o termo de pesquisa

        • O valor do campo numérico denominado imdb.rating ou o número 2 para os documentos que não têm o campo imdb.rating.

    • Especifica a opção highlight para retornar trechos de texto do campo title que correspondem à query. Os trechos contêm texto correspondente especificado com type: 'hit' e texto adjacente especificado com type: 'text'.

    • Utiliza os seguintes estágios do pipeline:

      • Estágio $limit para limitar a saída a 10 resultados

      • $fase de projeto para:

        • Excluir todos os campos, exceto title e year

        • Adicionar dois campos denominados score e highlights

    • Itera sobre o cursor para imprimir os documentos que correspondem à consulta.

    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. Antes de executar o exemplo, substitua <connection-string> por sua cadeia de conexão do Atlas. Certifique-se de que sua cadeia de conexão inclui as credenciais do usuário do banco de dados. Para saber mais, consulte Conectar via Drivers.

  4. Execute o seguinte comando para consultar sua 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":[]}'

    Os primeiros quatro documentos dos resultados têm uma pontuação mais alta porque a cláusula should na query especifica uma preferência por documentos com snow no título. A cláusula should também altera a pontuação do termo de query snow usando a opção function.

1

Execute uma query composta do Atlas Search que altere a pontuação usando a constant opção .

  1. Crie um arquivo denominado compound-constant-query.py.

  2. Copie e cole o exemplo de código no arquivo compound-constant.py.

    O seguinte exemplo de código:

    • Importa pymongo, o driver Python do MongoDB e o módulo dns , que é necessário para conectar pymongo a Atlas usando uma connection string de lista de sementes de DNS .

    • Cria uma instância da classe MongoClient para estabelecer uma conexão com seu cluster do Atlas.

    • Utiliza as seguintes cláusulas compostas para fazer query da collection:

      • filter cláusula com o operador de faixa para procurar filmes entre os anos 2013 e 2015.

      • should a cláusula com o operador de texto para fazer query do termo snow no campo title e alterar score com a opção constant . A opção constant substitui todos os resultados de pontuação do termo de pesquisa por 5.

    • Especifica a opção highlight para retornar trechos de texto do campo title que correspondem à query. Os trechos contêm texto correspondente especificado com type: 'hit' e texto adjacente especificado com type: 'text'.

    • Utiliza os seguintes estágios do pipeline:

      • Estágio $limit para limitar a saída a 10 resultados

      • $fase de projeto para:

        • Excluir todos os campos, exceto title e year

        • Adicionar dois campos denominados score e highlights

    • Itera sobre o cursor para imprimir os documentos que correspondem à consulta.

    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. Antes de executar o exemplo, substitua <connection-string> por sua cadeia de conexão do Atlas. Certifique-se de que sua cadeia de conexão inclui as credenciais do usuário do banco de dados. Para saber mais, consulte Conectar via Drivers.

  4. Execute o seguinte comando para consultar sua 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}

    Os primeiros quatro documentos dos resultados têm uma pontuação mais alta porque a cláusula should na query especifica uma preferência por documentos com snow no título. A cláusula should também altera a pontuação do termo de query snow usando a opção constant.

2

Execute uma query composta do Atlas Search que altere a pontuação usando a boost opção .

  1. Crie um arquivo denominado compound-boost-query.py.

  2. Copie e cole o exemplo de código no arquivo compound-boost-query.py.

    O seguinte exemplo de código:

    • Importa pymongo, o driver Python do MongoDB e o módulo dns , que é necessário para conectar pymongo a Atlas usando uma connection string de lista de sementes de DNS .

    • Cria uma instância da classe MongoClient para estabelecer uma conexão com seu cluster do Atlas.

    • Itera sobre o cursor para imprimir os documentos que correspondem à consulta.

    A consulta utiliza os seguintes estágios de pipeline:

    • $search estágio para fazer query na collection. A query:

      • Utiliza as seguintes cláusulas do operador compound:

        • must cláusula com o operador de faixa para procurar filmes entre os anos 2013 e 2015.

        • should a cláusula com o operador de texto para fazer query do termo snow no campo title e alterar score com a opção boost . A opção boost multiplica a pontuação base nos resultados do termo de pesquisa por 2.

        • Especifica a opção highlight para retornar trechos de texto do campo title que correspondem à query. Os trechos contêm texto correspondente especificado com type: 'hit' e texto adjacente especificado com type: 'text'.

    • Estágio $limit para limitar a saída a 10 resultados

    • $fase de projeto para:

      • Excluir todos os campos, exceto title e year

      • Adicionar dois campos denominados score e 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)

    A consulta utiliza os seguintes estágios de pipeline:

    • $search estágio para fazer query da collection. A query usa as seguintes cláusulas do operador compound com a opção boost para priorizar alguns campos mais do que outros campos:

      • must cláusula com o operador de texto para priorizar o gênero comedy mais, seguido pelo termo snow no campo title . A opção boost aplica pesos aos campos.

      • should cláusula com o operador de faixa para procurar filmes entre os anos 2013 e 2015.

      Observação

      A opção boost aplica diferentes pesos aos campos para priorizar os campos.

    • Estágio $limit para limitar a saída a 10 resultados.

    • $project estágio para:

      • Exclua todos os campos, exceto title, year e genres

      • Adicione um campo chamado 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. Antes de executar o exemplo, substitua <connection-string> por sua cadeia de conexão do Atlas. Certifique-se de que sua cadeia de conexão inclui as credenciais do usuário do banco de dados. Para saber mais, consulte Conectar via Drivers.

  4. Execute o seguinte comando para consultar sua 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}

    Os primeiros quatro documentos dos resultados têm uma pontuação mais alta porque a cláusula should na query especifica uma preferência por documentos com snow no título. A cláusula should também altera a pontuação do termo de query snow usando a opção boost.

    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

Execute uma query composta do Atlas Search que altere a pontuação usando a function opção .

  1. Crie um arquivo denominado compound-function-query.py.

  2. Copie e cole o exemplo de código no arquivo compound-function-query.py.

    O seguinte exemplo de código:

    • Importa pymongo, o driver Python do MongoDB e o módulo dns , que é necessário para conectar pymongo a Atlas usando uma connection string de lista de sementes de DNS .

    • Cria uma instância da classe MongoClient para estabelecer uma conexão com seu cluster do Atlas.

    • Utiliza as seguintes cláusulas compostas para fazer query da collection:

      • must cláusula com o operador de faixa para procurar filmes entre os anos 2013 e 2015.

      • should a cláusula com o operador de texto para fazer query do termo snow no campo title e alterar score com a opção function . A opção function adiciona o seguinte utilizando uma expressão aritmética:

        • A pontuação de relevância da consulta para o termo de pesquisa

        • O valor do campo numérico denominado imdb.rating ou o número 2 para os documentos que não têm o campo imdb.rating.

    • Especifica a opção highlight para retornar trechos de texto do campo title que correspondem à query. Os trechos contêm texto correspondente especificado com type: 'hit' e texto adjacente especificado com type: 'text'.

    • Utiliza os seguintes estágios do pipeline:

      • Estágio $limit para limitar a saída a 10 resultados

      • $fase de projeto para:

        • Excluir todos os campos, exceto title e year

        • Adicionar dois campos denominados score e highlights

    • Itera sobre o cursor para imprimir os documentos que correspondem à consulta.

    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. Antes de executar o exemplo, substitua <connection-string> por sua cadeia de conexão do Atlas. Certifique-se de que sua cadeia de conexão inclui as credenciais do usuário do banco de dados. Para saber mais, consulte Conectar via Drivers.

  4. Execute o seguinte comando para consultar sua 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}

    Os primeiros quatro documentos dos resultados têm uma pontuação mais alta porque a cláusula should na query especifica uma preferência por documentos com snow no título. A cláusula should também altera a pontuação do termo de query snow usando a opção function.

Continuar aprendendo

Para saber mais sobre queries compostas usando o Atlas Search, faça a unidade 9 do curso Introdução ao MongoDB na Universidade MongoDB. O 1. A unidade 5 horas inclui uma visão geral do Atlas Search e lições sobre a criação de índices do Atlas Search, a execução de queries $search usando operadores compostos e o agrupamento de resultados usando faceta.

Voltar

Como executar um

Próximo

Multilíngue

Nesta página