Classificar resultados do Atlas Search

Uso

Para classificar seus resultados de Atlas Search, você deve fazer o seguinte:

1. Crie um índice do Atlas Search nos campos para classificar os resultados.

   Para classificar em campos boolean, date, number, UUID, e objectId , use mapeamentos dinâmicos ou estáticos. Para classificar campos de string, você deve usar mapeamentos estáticos para indexar o campo como o tipo token.

2. Crie e execute sua query com a opção sort nos campos que você definiu no índice para classificação. Para saber mais, consulte Sintaxe.

Comportamento

sort: {score: {$meta: "searchScore", order: 1}}

sort: {score: {$meta: "searchScore"}, lastUpdated: 1}

sort: {score: {$meta: "searchScore"}}

[4, [1, [8,5], 9], 2]

4, 1, 8, 5, 9, 2

Considerações

Limitações

• Você não pode classificar em campos do tipo embeddedDocuments.

• Você não pode utilizar a opção sort com o operador obsoleto knnBeta.

Compatibilidade

O Atlas é compatível com queries de classificação não fragmentadas em todas as versões principais e secundárias do MongoDB 5.0 e posteriores. As queries de classificação fragmentadas estão disponíveis em todas as versões principais da versão 6.0 e em todas as versões principais e secundárias da versão 7.0 e posterior. Se você usar sort em clusters fragmentados do Atlas executando o MongoDB v5.0 e anteriores, o Atlas Search retornará um erro.

Definição de Índice

As consultas de exemplo nesta página usam o sample_mflix.movies, o sample_airbnb.listingsAndReviewou uma coleção personalizada. Se você criar os seguintes índices nessas coleções, poderá executar as consultas de amostra em relação aos campos indexados.

1
{
2
  "mappings": {
3
    "dynamic": true,
4
    "fields": {
5
      "awards": {
6
        "dynamic": false,
7
        "fields": {
8
          "wins": [
9
            {
10
              "type": "number"
11
            },
12
            {
13
              "type": "numberFacet"
14
            }
15
          ]
16
        },
17
        "type": "document"
18
      },
19
      "released": [
20
        {
21
          "type": "date"
22
        },
23
        {
24
          "type": "dateFacet"
25
        }
26
      ],
27
      "title": [{
28
        "type": "token"
29
      }, {
30
        "type": "string"
31
      }]
32
    }
33
  }
34
}

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

db.users.insertMany([
  {
    "_id": 0,
    "a": UUID("1a324de2-e34b-c87e-f2a1-42ce37ad74ed"),
    "b": "hello",
    "c": ObjectId("507f1f77bcf86cd799439011")
  },
  {
    "_id": 1,
    "a": UUID("3b241101-e2bb-4255-8caf-4136c566a962"),
    "b": "hello",
    "c": true
  },
  {
    "_id": 2,
    "a": UUID("dee11d4e-63c6-4d90-983c-5c9f1e79e96c"),
    "b": "hello",
    "c": "foo"
  },
  {
    "_id": 3,
    "b": "hello",
    "c": UUID("3be11d4e-62cb-4e95-9a3c-5c9f1e56c732")
  },
  {
    "_id": 4,
    "a": UUID("d3c12e1c-c36e-25ed-7c3e-1e7f1e53c752"),
    "b": "hello",
    "c": null
  }
])

1
{
2
  "mappings": {
3
    "dynamic": true,
4
    "fields": {
5
      "c": [
6
       { "type": "token" },
7
       { "type": "uuid" },
8
       { "type": "objectId" },
9
       { "type": "boolean" }
10
      ]
11
    }
12
  }
13
}

Pesquisa e classificação de data

A query a seguir no namespace sample_mflix.movies usa o estágio $search para fazer o seguinte:

• Pesquise filmes lançados entre 01 de janeiro de 2010 e 01 de janeiro de 2015 usando o operador de intervalo .

• Classifique os resultados em ordem decrescente da data de lançamento usando a opção sort.

A query usa o estágio $limit para limitar a saída a 5 documentos. Ele também usa o estágio $project para omitir todos os campos, exceto title e released nos resultados.

db.movies.aggregate([
  {
    "$search": {
      "range": {
        "path": "released",
        "gt": ISODate("2010-01-01T00:00:00.000Z"),
        "lt": ISODate("2015-01-01T00:00:00.000Z")
      },
      "sort": {
        "released": -1
      }
    }
  },
  {
    "$limit": 5
  },
  {
    "$project": {
      "_id": 0,
      "title": 1,
      "released": 1
    }
  }
])

[
  {
    title: 'Cold in July',
    released: ISODate("2014-12-31T00:00:00.000Z")
  },
  {
    title: 'The Gambler',
    released: ISODate("2014-12-31T00:00:00.000Z")
  },
  {
    title: 'Force Majeure',
    released: ISODate("2014-12-30T00:00:00.000Z")
  },
  {
    title: 'LFO',
    released: ISODate("2014-12-27T00:00:00.000Z")
  },
  {
    title: 'Peace After Marriage',
    released: ISODate('2014-12-26T00:00:00.000Z')
  }
]

Pesquisa e classificação de números

A query a seguir no namespace sample_mflix.movies usa o estágio $search para fazer o seguinte:

• Procure filmes que ganharam prêmios.

• Classifique os resultados em ordem decrescente usando a opção sort.

A query usa o estágio $limit para limitar a saída a 5 documentos. Ele também usa o estágio $project para omitir todos os campos, exceto title e awards.wins nos resultados.

db.movies.aggregate([
  {
    "$search": {
       "range": {
         "path": "awards.wins",
         "gt": 3
      },
      "sort": {
        "awards.wins": -1
      }
    }
  },
  {
    "$limit": 5
  },
  {
    "$project": {
      "_id": 0,
      "title": 1,
      "awards.wins": 1
    }
  }
])

[
  { title: '12 Years a Slave', awards: { wins: 267 } },
  { title: 'Gravity', awards: { wins: 231 } },
  { title: 'Gravity', awards: { wins: 231 } },
  {
    title: 'Birdman: Or (The Unexpected Virtue of Ignorance)',
    awards: { wins: 210 }
  },
  { title: 'Boyhood', awards: { wins: 185 } },
]

Pesquisa e classificação de strings

A query a seguir no namespace sample_mflix.movies usa o estágio $search para fazer o seguinte:

• Procure filmes que tenham o termo country no título.

• Classifique os resultados em ordem crescente usando a opção sort.

A query usa o estágio $limit para limitar a saída a 5 documentos. Ele também utiliza o estágio $project para fazer o seguinte:

• Omitir todos os campos exceto title nos resultados.

• Adicione um campo denominado score.

db.movies.aggregate([
  {
    "$search": {
      "text": {
        "path": "title",
        "query": "country"
      },
      "sort": {
        "title": 1
      }
    }
  },
  {
    "$limit": 5
  },
  {
    "$project": {
      "_id": 0,
      "title": 1,
      "score": { "$meta": "searchScore" }
    }
  }
])

[
  { title: 'A Country Called Home', score: 2.536633253097534 },
  { title: 'A Month in the Country', score: 2.258953094482422 },
  { title: 'A Quiet Place in the Country', score: 2.0360684394836426 },
  { title: 'A Sunday in the Country', score: 2.258953094482422 },
  { title: 'Another Country', score: 3.3635599613189697 }
]

Ordenar por ObjectId

A consulta a seguir usa o operador de intervalo para pesquisar o campo released na coleção sample_mflix.movies para filmes lançados entre 2015-01-01 e 2015-12-31. Ele classifica os resultados pelo campo _id , que contém o valor do tipo ObjectId, em ordem decrescente.

db.movies.aggregate([
  {
    "$search": {
      "range": {
        "path": "released",
        "gt": ISODate("2015-01-01T00:00:00.000Z"),
        "lt": ISODate("2015-12-31T00:00:00.000Z")
      },
      "sort": {
        "_id": -1
      }
    }
  },
  {
    "$limit": 5
  },
  {
    "$project": {
      "_id": 1,
      "title": 1,
      "released": 1,
      "score": { "$meta": "searchScore" }
    }
  }
])

[
  {
    _id: ObjectId('573a13fbf29313caabdedf31'),
    title: 'No Home Movie',
    released: ISODate('2015-08-10T00:00:00.000Z'),
    score: 1
  },
  {
    _id: ObjectId('573a13fbf29313caabdedf30'),
    title: 'Our Loved Ones',
    released: ISODate('2015-08-12T00:00:00.000Z'),
    score: 1
  },
  {
    _id: ObjectId('573a13faf29313caabded406'),
    title: 'The Red Spider',
    released: ISODate('2015-11-20T00:00:00.000Z'),
    score: 1
  },
  {
    _id: ObjectId('573a13faf29313caabded1d6'),
    title: 'The Laundryman',
    released: ISODate('2015-07-11T00:00:00.000Z'),
    score: 1
  },
  {
    _id: ObjectId('573a13faf29313caabdecaf3'),
    title: 'Right Now, Wrong Then',
    released: ISODate('2015-09-01T00:00:00.000Z'),
    score: 1
  }
]

Ordenar por UUID

A query a seguir pesquisa o termo hello no campo b na coleção users. A query ordena os resultados pelo campo a, que contém dados polimórficos (para demonstrar a ordem de classificação), em ordem crescente.

db.users.aggregate([
  {
    "$search": {
      "text": {
        "path": "b",
        "query": "hello"
      },
      "sort": {
        "a": 1
      }
    }
  },
  {
    "$project": {
      "_id": 1,
      "a": 1,
      "score": { "$meta": "searchScore" }
    }
  }
])

[
  { _id: 3, score: 0.039550621062517166 },
  {
    _id: 0,
    a: UUID('1a324de2-e34b-c87e-f2a1-42ce37ad74ed'),
    score: 0.039550621062517166
  },
  {
    _id: 1,
    a: UUID('3b241101-e2bb-4255-8caf-4136c566a962'),
    score: 0.039550621062517166
  },
  {
    _id: 4,
    a: UUID('d3c12e1c-c36e-25ed-7c3e-1e7f1e53c752'),
    score: 0.039550621062517166
  },
  {
    _id: 2,
    a: UUID('dee11d4e-63c6-4d90-983c-5c9f1e79e96c'),
    score: 0.039550621062517166
  }
]

Ordenar por valor nulo

A seguinte query pesquisa o campo b para a string hello na coleção users usando o operador texto. A query classifica os resultados pelo campo a em ordem crescente.

db.users.aggregate([
  {
    "$search": {
      "text": {
        "path": "b",
        "query": "hello"
      },
      "sort": {
        "c": 1
      }
    }
  },
  {
    "$project": {
      "_id": 1,
      "c": 1,
      "score": { "$meta": "searchScore" }
    }
  }
])

[
  { _id: 4, c: null, score: 0.039550621062517166 },
  { _id: 2, c: 'foo', score: 0.039550621062517166 },
  {
    _id: 3,
    c: UUID('3be11d4e-62cb-4e95-9a3c-5c9f1e56c732'),
    score: 0.039550621062517166
  },
  {
    _id: 0,
    c: ObjectId('507f1f77bcf86cd799439011'),
    score: 0.039550621062517166
  },
  { _id: 1, c: true, score: 0.039550621062517166 }
]

O Atlas Search retorna todos os documentos, mas a ordenação dos documentos com "_id": 2 e "_id": 4 é aleatória porque o Atlas Search trata os ausentes e os nulos da mesma forma ao classificar. Para mais detalhes, consulte a ordem de classificação do MongoDB para classificar dados de diferentes tipos de BSON.

Ordenar por booleano

A query a seguir pesquisa a coleção de propriedades sample_airbnb.listingsAndReviews em Portugal e classifica os resultados em ordem decrescente pelo campo boolean is_location_exact.

A query usa o estágio $limit para limitar a saída a 5 documentos. Ela também usa o estágio $project para omitir todos os campos, exceto name, property_type, address.country e address.location.is_location_exact nos resultados.

1
db.listingsAndReviews.aggregate([
2
  {
3
    "$search": {
4
      "text": {
5
        "path": "address.country",
6
        "query": "Portugal"
7
      },
8
      "sort": {
9
        "address.location.is_location_exact": -1,
10
      }
11
    }
12
  },
13
  {
14
    "$limit": 5
15
  },
16
  {
17
    "$project": {
18
      "_id": 0,
19
      "name": 1,
20
      "property_type": 1,
21
      "address.country": 1,
22
      "address.location.is_location_exact": 1
23
    }
24
  }
25
])

1
[
2
  {
3
    name: 'BBC OPORTO 4X2',
4
    property_type: 'Apartment',
5
    address: { country: 'Portugal', location: { is_location_exact: true } }
6
  },
7
  {
8
    name: 'Heroísmo IV',
9
    property_type: 'Apartment',
10
    address: { country: 'Portugal', location: { is_location_exact: true } }
11
  },
12
  {
13
    name: 'Spacious and well located apartment',
14
    property_type: 'Apartment',
15
    address: { country: 'Portugal', location: { is_location_exact: true } }
16
  },
17
  {
18
    name: 'Renovated Classic Design Studio with Sun Room',
19
    property_type: 'Apartment',
20
    address: { country: 'Portugal', location: { is_location_exact: true } }
21
  },
22
  {
23
    name: "O'Porto Studio | Historic Center",
24
    property_type: 'Loft',
25
    address: { country: 'Portugal', location: { is_location_exact: true } }
26
  }
27
]

Nos resultados anteriores, o valor de is_location_exact é true para os documentos porque, em uma classificação decrescente, o Atlas Search classifica os valores true acima dos valores false . Se você fizer uma classificação ascendente mudando o valor na linha 9 da query anterior para 1, o Atlas Search classificará os documentos com false valores maiores que true valores e retornará os seguintes documentos:

[
  {
    name: 'Ribeira Charming Duplex',
    property_type: 'House',
    address: { country: 'Portugal', location: { is_location_exact: false } }
  },
  {
    name: 'Be Happy in Porto',
    property_type: 'Loft',
    address: { country: 'Portugal', location: { is_location_exact: false } }
  },
  {
    name: 'Downtown Oporto Inn (room cleaning)',
    property_type: 'Hostel',
    address: { country: 'Portugal', location: { is_location_exact: false } }
  },
  {
    name: 'A Casa Alegre é um apartamento T1.',
    property_type: 'Apartment',
    address: { country: 'Portugal', location: { is_location_exact: false } }
  },
  {
    name: 'FloresRooms 3T',
    property_type: 'Apartment',
    address: { country: 'Portugal', location: { is_location_exact: false } }
  }
]

Pesquisa e classificação composta

A seguinte query utiliza o estágio $search para fazer o seguinte:

• Procure por filmes que tenham o termo dance no título, com preferência por filmes que ganharam 2 ou mais prêmios e foram lançados após 01 de janeiro de 1990.

• Classifique os resultados pelo número de prêmios em ordem decrescente, depois pelo título do filme em ordem crescente e, em seguida, pela data de lançamento em ordem decrescente.

A query usa o estágio $limit para limitar a saída a 10 documentos. Ele também utiliza o estágio $project para fazer o seguinte:

• Omitir todos os campos exceto title, released e awards.wins nos resultados.

• Adicione um campo denominado score.

db.movies.aggregate([
  {
    "$search": {
      "compound": {
        "must": [{
          "text": {
            "path": "title",
            "query": "dance"
          }
        }],
        "should": [{
          "range": {
            "path": "awards.wins",
            "gte": 2
          }
        }, {
          "range": {
            "path": "released",
            "gte": ISODate("1990-01-01T00:00:00.000Z")
          }
        }]
      },
      "sort": {
        "awards.wins": -1,
        "title": 1,
        "released": -1
      }
    }
  },
  {
    "$limit": 10
  },
  {
    "$project": {
      "_id": 0,
      "title": 1,
      "released": 1,
      "awards.wins": 1,
      "score": { "$meta": "searchScore" }
    }
  }
])

[
  {
    title: 'Shall We Dance?',
    released: ISODate("1997-07-11T00:00:00.000Z"),
    awards: { wins: 57 },
    score: 4.9811458587646484
  },
  {
    title: 'Shall We Dance?',
    released: ISODate("1997-07-11T00:00:00.000Z"),
    awards: { wins: 57 },
    score: 4.9811458587646484
  },
  {
    title: 'War Dance',
    released: ISODate("2008-11-01T00:00:00.000Z"),
    awards: { wins: 11 },
    score: 5.466421127319336
  },
  {
    title: 'Dance with the Devil',
    released: ISODate("1997-10-31T00:00:00.000Z"),
    awards: { wins: 6 },
    score: 4.615056037902832
  },
  {
    title: 'Save the Last Dance',
    released: ISODate("2001-01-12T00:00:00.000Z"),
    awards: { wins: 6 },
    score: 4.615056037902832
  },
  {
    title: 'Dance with a Stranger',
    released: ISODate("1985-08-09T00:00:00.000Z"),
    awards: { wins: 4 },
    score: 3.615056037902832
  },
  {
    title: 'The Baby Dance',
    released: ISODate("1998-08-23T00:00:00.000Z"),
    awards: { wins: 4 },
    score: 4.981145858764648
  },
  {
    title: 'Three-Step Dance',
    released: ISODate("2004-02-19T00:00:00.000Z"),
    awards: { wins: 4 },
    score: 4.981145858764648
  },
  {
    title: "Cats Don't Dance",
    released: ISODate("1997-03-26T00:00:00.000Z"),
    awards: { wins: 3 },
    score: 4.981145858764648
  },
  {
    title: 'Dance Me Outside',
    released: ISODate("1995-03-10T00:00:00.000Z"),
    awards: { wins: 3 },
    score: 4.981145858764648
  }
]

Pesquisa e classificação de facets

A seguinte query utiliza o estágio $search para fazer o seguinte:

• Pesquise filmes lançados entre 01 de janeiro de 2010 e 01 de janeiro de 2015 usando o operador de intervalo .

• Conte o número de filmes que ganharam os prêmios 1, 5, 10 e 15.

• Obtenha uma contagem do número de filmes lançados em 2010-01-01, 2011-01-01, 2012-01-01, 2013-01-01, 2014-01-01 e 2015-01-01.

• Classifique os resultados em ordem decrescente da data de lançamento usando a opção sort.

A query utiliza o estágio $limit para fazer o seguinte:

• Limite a saída para 5 documentos no campo docs saída.

• Limite a saída ao documento 1 no campo de saída meta.

Ele utiliza o estágio $project para omitir todos os campos, exceto os campos awards.wins, released e title .

Ele também usa o estágio $replaceWith para incluir os resultados de metadados armazenados na variável $$SEARCH_META no campo de saída meta e o estágio $set para adicionar o campo meta aos resultados.

db.movies.aggregate([
  {
    "$search": {
      "facet": {
        "operator": {
          "range": {
            "path": "released",
            "gt": ISODate("2010-01-01T00:00:00.000Z"),
            "lt": ISODate("2015-01-01T00:00:00.000Z")
          }
        },
        "facets": {
          "awardsFacet": {
            "type": "number",
            "path": "awards.wins",
            "boundaries" : [1,5,10,15]
          },
          "releasedFacet" : {
            "type" : "date",
            "path" : "released",
            "boundaries" : [ISODate("2010-01-01T00:00:00.000Z"), ISODate("2011-01-01T00:00:00.000Z"), ISODate("2012-01-01T00:00:00.000Z"), ISODate("2013-01-01T00:00:00.000Z"), ISODate("2014-01-01T00:00:00.000Z"), ISODate("2015-01-01T00:00:00.000Z")]
          }
        }
      },
      "sort": {
        "released": -1
      }
    }
  },
  {
    "$facet": {
      "docs": [
        { "$limit": 5 },
        { "$project":
          {
            "_id": 0,
            "title": 1,
            "released": 1,
            "awards.wins": 1
          }
        }
      ],
      "meta": [
        {"$replaceWith": "$$SEARCH_META"},
        {"$limit": 1}
      ]
    }
  },
  {
    "$set": {
      "meta": {
        "$arrayElemAt": ["$meta", 0]
      }
    }
  }
])

[
  {
    docs: [
      {
        title: 'Cold in July',
        released: ISODate("2014-12-31T00:00:00.000Z"),
        awards: { wins: 1 }
      },
      {
        title: 'The Gambler',
        released: ISODate("2014-12-31T00:00:00.000Z"),
        awards: { wins: 7 }
      },
      {
        title: 'Force Majeure',
        released: ISODate("2014-12-30T00:00:00.000Z"),
        awards: { wins: 31 }
      },
      {
        title: 'LFO',
        released: ISODate("2014-12-27T00:00:00.000Z"),
        awards: { wins: 3 }
      },
      {
        title: 'Peace After Marriage',
        released: ISODate('2014-12-26T00:00:00.000Z'),
        awards: { wins: 5 }
      }
    ],
    meta: {
      count: { lowerBound: Long("4821") },
        facet: {
          releasedFacet: {
            buckets: [
              {
                _id: ISODate("2010-01-01T00:00:00.000Z"),
                count: Long("857")
              },
              {
                _id: ISODate("2011-01-01T00:00:00.000Z"),
                count: Long("909")
              },
              {
                _id: ISODate("2012-01-01T00:00:00.000Z"),
                count: Long("903")
              },
              {
                _id: ISODate("2013-01-01T00:00:00.000Z"),
                count: Long("1063")
              },
              {
                _id: ISODate("2014-01-01T00:00:00.000Z"),
                count: Long("1089")
              }
            ]
          },
          awardsFacet: {
            buckets: [
              { _id: 1, count: Long("2330") },
              { _id: 5, count: Long("604") },
              { _id: 10, count: Long("233") }
            ]
          }
        }
      }
    }
  }
]

Classificar por pontuação

Os exemplos a seguir demonstram como classificar os resultados pela pontuação dos documentos nos resultados. Os exemplos demonstram como executar as seguintes ações:

• Recupere os documentos de pontuação mais baixa primeiro classificando os resultados em ordem crescente.

• Classifique os resultados por pontuação em ordem decrescente e, para resultados com pontuações idênticas, classifique arbitrariamente.

• Classifique os resultados por pontuação e para resultados com pontuações idênticas, classifique utilizando um campo exclusivo.

db.movies.aggregate([
  {
    "$search": {
      "text": {
        "path": "title",
        "query": "story"
      },
      "sort": {score: {$meta: "searchScore", order: 1}}
    }
  },
  {
    "$limit": 5
  },
  {
    "$project": {
      "_id": 0,
      "title": 1,
      "score": {$meta: "searchScore"}
    }
  }
])

[
  {
    title: 'Do You Believe in Miracles? The Story of the 1980 U.S. Hockey Team',
    score: 0.8674521446228027
  },
  {
    title: 'Once in a Lifetime: The Extraordinary Story of the New York Cosmos',
    score: 0.9212141036987305
  },
  {
    title: 'The Source: The Story of the Beats and the Beat Generation',
    score: 0.9820802211761475
  },
  {
    title: 'If These Knishes Could Talk: The Story of the NY Accent',
    score: 0.9820802211761475
  },
  {
    title: 'Dream Deceivers: The Story Behind James Vance vs. Judas Priest',
    score: 1.051558256149292
  }
]

db.movies.aggregate([
  {
    "$search": {
      "text": {
        "path": "title",
        "query": "summer"
      },
      "sort": {score: {$meta: "searchScore"}}
    }
  },
  {
    "$limit": 5
  },
  {
    "$project": {
      "_id": 1,
      "title": 1,
      "score": {$meta: "searchScore"}
    }
  }
])

[
  {
    _id: ObjectId("573a1398f29313caabcea21e"),
    title: 'Summer',
    score: 3.5844719409942627
  },
  {
    _id: ObjectId("573a13a6f29313caabd18eca"),
    title: 'Summer Things',
    score: 3.000213623046875
  },
  {
    _id: ObjectId("573a13b8f29313caabd4c1d0"),
    title: 'Summer Palace',
    score: 3.000213623046875
  },
  {
    _id: ObjectId("573a1394f29313caabcde8e8"),
    title: 'Summer Stock',
    score: 3.000213623046875
  },
  {
    _id: ObjectId("573a13acf29313caabd284fa"),
    title: 'Wolf Summer',
    score: 3.000213623046875
  }
]

db.movies.aggregate([
  {
    "$search": {
      "text": {
        "path": "title",
        "query": "prince"
      },
      "sort": {score: {$meta: "searchScore"}, "released": 1}
    }
  },
  {
    "$limit": 5
  },
  {
    "$project": {
      "_id": 0,
      "title": 1,
      "released": 1,
      "score": {$meta: "searchScore"}
    }
  }
])

[
  {
    title: 'Prince',
    released: ISODate("2015-08-14T00:00:00.000Z"),
    score: 4.168826103210449
  },
  {
    title: 'Prince Avalanche',
    released: ISODate("2013-09-19T00:00:00.000Z"),
    score: 3.4893198013305664
  },
  {
    title: 'The Prince',
    released: ISODate("2014-08-22T00:00:00.000Z"),
    score: 3.4893198013305664
  },
  {
    title: 'Prince of Foxes',
    released: ISODate("1949-12-23T00:00:00.000Z"),
    score: 3.0002830028533936
 },
  {
    title: 'The Oil Prince',
    released: ISODate("1966-01-01T00:00:00.000Z"),
    score: 3.0002830028533936
  }
]