Join us at MongoDB.local London on 7 May to unlock new possibilities for your data. Use WEB50 to save 50%.
Register now >
Docs Menu
Docs Home
/ /
Operadores y coleccionistas
Docs Home
/ /
Referencia de query
/
Operadores y coleccionistas
Docs Home
/
Desarrollo
/
Buscar
/
Query e índices
/
Referencia de query
/
Operadores y coleccionistas

moreLikeThis Operador

moreLikeThis Limitaciones de operador

No puedes utilizar el operador moreLikeThis para consultar valores no literales. Para buscar valores que no sean de tipo string, puedes combinar una query moreLikeThis con una cerca, rango, o cualquier otro operador en una query compuesta.

No puedes usar el operador moreLikeThis dentro del embeddedDocument para consultar documentos en un arreglo.

Definición

moreLikeThis

El operador moreLikeThis regresa documentos similares a los documentos de entrada. El operador moreLikeThis te permite compilar funcionalidades para tus aplicaciones que muestran resultados similares o alternativos basados en uno o más documentos dados.

Comportamiento

Cuando ejecutas una moreLikeThis query, MongoDB Search realiza estas acciones:

  • Extrae un número limitado de términos más representativos en función de los documentos de entrada que especifique en la opción like del operador.

  • Crea una query de disyunción (OR) para encontrar documentos similares basados en los términos más representativos y devuelve sus resultados.

El moreLikeThis operador busca documentos similares utilizando el analizador especificado en la configuración del índice. Si omite el analizador en la definición del índice, el moreLikeThis operador utiliza el analizador estándar predeterminado. Si especifica varios analizadores, el moreLikeThis operador ejecuta el texto de entrada en cada analizador, busca y devuelve resultados para todos.

Para ver la disyunción (OR) que MongoDB Search construye para encontrar documentos similares, utiliza explain con tu query del operador moreLikeThis.

Uso

Antes de que puedas ejecutar la query del operador moreLikeThis, te recomendamos recuperar uno o más documentos de entrada. Para recuperar los documentos de entrada, puedes hacer una de las siguientes acciones:

  • Ejecute una consulta, como por ejemplo find(), o cualquier otra consulta MQL para buscar DocumentosBSON.

  • Ejecute cualquier canal de agregación que devuelva documentos BSON.

  • Utiliza cualquier otra fuente de documentos en tu aplicación.

Una vez que hayas identificado los documentos de entrada, puedes pasarlos al operador moreLikeThis.

Cuando se ejecuta una consulta de operador moreLikeThis, MongoDB Search devuelve el documento de entrada original en los resultados de la consulta. Para omitir el documento de entrada de los resultados de la query, utilizar el operador moreLikeThis en una consulta operador compuesto y excluir el documento de entrada por su _id utilizando el operador equals en la cláusula mustNot.

Sintaxis

moreLikeThis tiene la siguiente sintaxis:

 {
   "$search": {
     "index": index name, // optional, defaults to "default"
     "moreLikeThis": {
       "like": [
         {
           <"field-name">: <"field-value">,
           ...
         },
         ...
       ],
       "score": <options>
     }
   }
 }

opciones

moreLikeThis utiliza la siguiente opción para construir una query:

Campo
Tipo
Descripción
Necesidad

like

un documento BSON o un arreglo de documentos

Uno o más documentos BSON que MongoDB Search utiliza para extraer términos representativos para consultas.

Requerido

score

Objeto

Puntuación para asignar a los resultados de búsqueda coincidentes. Puedes modificar la puntuación por defecto usando las siguientes opciones:

  • boostMultiplica la puntuación resultante por el número dado.

  • constant:reemplace la puntuación del resultado con el número dado.

  • function: reemplaza el resultado de la puntuación con la expresión dada.

Para obtener información sobre cómo usar score en tu query, consulta Calificación de los Documentos en los Resultados.

Cuando se consultan valores en arreglos, MongoDB Search asigna mayores puntuaciones si más valores en el arreglo coinciden con la query.

Opcional

Ejemplos

Los ejemplos utilizan la colección movies en la base de datos de sample_mflix. Cada ejemplo en esta sección utiliza una definición de índice diferente para demostrar distintas funcionalidades del operador.

Antes de ejecutar las queries de ejemplo en el clúster, cargá los datos de muestra en el clúster y creá el índice sugerido. Para obtener más información sobre cómo crear un índice de MongoDB Search usando la Interfaz de Usuario, la API o la CLI, consulte Administrar índices de MongoDB Search. Las definiciones del índice usan el nombre default.

Si se nombra el índice default, no se necesita especificar un parámetro index en la etapa de la $search pipeline. Si se asigna un nombre personalizado al índice, se debe especificar este nombre en el parámetro index.

Ejemplo 1: Un solo documento con varios campos

El siguiente ejemplo utiliza el moreLikeThis operador para buscar documentos similares a varios valores de campo. En este ejemplo, la definición de índice contiene asignaciones dinámicas para indexar dinámicamente todos los tipos de campo indexables dinámicamente en la colección. La definición de índice para la sample_mflix.movies colección debería ser similar a la siguiente.

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

Ejemplo

La siguiente query busca películas que sean similares al título de la película de entrada "The Godfather" y al género de película de entrada "acción". Incluye una $limit etapa para limitar los resultados a 5 y una $project etapa para excluir todos los campos excepto title, released y genres.

1db.movies.aggregate([
2  {
3    "$search": {
4    moreLikeThis: {
5     like:
6      {
7        "title": "The Godfather",
8        "genres": "action"
9      }
10    }
11   }
12  },
13  { "$limit": 5},
14  {
15    $project: {
16      "_id": 0,
17      "title": 1,
18      "released": 1,
19      "genres": 1
20    }
21  }
22])
[
 { genres: [ 'Comedy', 'Drama', 'Romance' ], title: 'Godfather' },
 {
  genres: [ 'Crime', 'Drama' ],
  title: 'The Godfather',
  released: ISODate("1972-03-24T00:00:00.000Z")
 },
 {
  genres: [ 'Crime', 'Drama' ],
  title: 'The Godfather: Part II',
  released: ISODate("1974-12-20T00:00:00.000Z")
 },
 {
  genres: [ 'Crime', 'Drama' ],
  title: 'The Godfather: Part III',
  released: ISODate("1990-12-26T00:00:00.000Z")
 },
 {
  genres: [ 'Action' ],
  title: 'The Defender',
  released: ISODate("1994-07-28T00:00:00.000Z")
 }
]

Los resultados de búsqueda de MongoDB contienen películas similares al título de película ingresado "El Padrino" y al género de película ingresado "acción".

Ejemplo 2: Documento de entrada excluido en los resultados

El siguiente ejemplo utiliza find() para identificar un documento de entrada y luego utiliza el operador moreLikeThis para buscar documentos similares. Para este ejemplo, la definición del índice utiliza mapeos estáticos para indexar únicamente los campos title, genres y _id.

1{
2  "mappings": {
3    "dynamic": false,
4    "fields": {
5      "title": {
6        "type": "string"
7      },
8      "genres": {
9        "type": "string"
10      },
11      "_id": {
12        "type": "objectId"
13      }
14    }
15  }
16}

Ejemplo

La siguiente consulta find() busca la película titulada "El Padrino" y almacena el resultado en movie. Especifica que los resultados solo deben contener los campos title y genres de los documentos coincidentes. Tenga en cuenta que, por defecto, el comando find () siempre devuelve el campo _id, cuyo valor podría variar en su clúster.

movie = db.movies.find( { title: "The Godfather" }, { genres: 1, title: 1} ).toArray()
[
 {
  _id: ObjectId("573a1396f29313caabce4a9a"),
  genres: [ 'Crime', 'Drama' ],
  title: 'The Godfather'
 }
]

La siguiente consulta utiliza un operador compuesto con el operador moreLikeThis para consultar los campos title y genres, y el operador equals para excluir el documento de entrada utilizando las siguientes cláusulas:

  • La cláusula must para consultar películas similares a la película almacenada en movie.

  • La cláusula mustNot para excluir el documento de entrada de los resultados por su valor _id. Ten en cuenta que el valor de _id utilizado en la query coincide con el valor de _id en los resultados de la query anterior find().

La query limita la salida a 5 resultados. La consulta utiliza una etapa $project para incluir los campos _id, title, released y genres en los resultados.

Nota

Antes de ejecutar esta consulta, reemplaza el valor del campo _id de la línea 13 por el valor del campo _id en tus resultados de consulta.

1db.movies.aggregate([
2  {
3    "$search": {
4       "compound":{
5          "must":[{
6            "moreLikeThis": {
7              "like": movie
8            }
9          }],
10          "mustNot":[{
11            "equals": {
12               "path": "_id",
13               "value": ObjectId ("573a1396f29313caabce4a9a")
14            }
15          }]
16         }
17       }
18     },
19{"$limit": 5},
20{
21 "$project": {
22   "_id": 1,
23   "title": 1,
24   "released": 1,
25   "genres": 1
26  }
27 }
28])
[
 {
  _id: ObjectId("573a13acf29313caabd27afc"),
  genres: [ 'Comedy', 'Drama', 'Romance' ],
  title: 'Godfather'
 },
 {
  _id: ObjectId("573a1396f29313caabce557f"),
  genres: [ 'Crime', 'Drama' ],
  title: 'The Godfather: Part II',
  released: ISODate("1974-12-20T00:00:00.000Z")
 },
 {
  _id: ObjectId("573a1398f29313caabcebf7b"),
  genres: [ 'Crime', 'Drama' ],
  title: 'The Godfather: Part III',
  released: ISODate("1990-12-26T00:00:00.000Z")
 },
 {
  _id: ObjectId("573a1399f29313caabceed8d"),
  genres: [ 'Action' ],
  title: 'The Defender',
  released: ISODate("1994-07-28T00:00:00.000Z")
 },
 {
  _id: ObjectId("573a139af29313caabcef2a0"),
  genres: [ 'Action' ],
  title: 'The Enforcer',
  released: ISODate("1995-03-02T00:00:00.000Z")
 }
]

Los resultados de MongoDB Search incluyen documentos similares al término de búsqueda The Godfather en el género action. Sin embargo, los resultados no incluyen el documento que se excluyó por su _id, que es ObjectId("573a1396f29313caabce4a9a").

Ejemplo 3: Varios analizadores

El siguiente ejemplo utiliza find() para identificar los documentos de entrada y, a continuación, utiliza el moreLikeThis operador para buscar documentos similares. En este ejemplo, la definición del índice utiliza asignaciones estáticas para indexar los campos de la sample_mflix.movies colección con diferentes analizadores. La definición del índice:

  • Configura un índice en los campos _id, title y genres.

  • Analiza el campo title utilizando el analizador lucene.standard y un analizador alternativo llamado keywordAnalyzer que emplea el analizador lucene.keyword.

  • Analiza y busca los campos utilizando el analizador lucene.english.

1{
2  "mappings": {
3    "dynamic": false,
4    "fields": {
5      "title": {
6        "type": "string",
7        "analyzer": "lucene.standard",
8        "multi": {
9          "keywordAnalyzer": {
10            "type": "string",
11            "analyzer": "lucene.keyword"
12          }
13        }
14      },
15      "genres": {
16        "type": "string"
17      },
18      "_id": {
19        "type": "objectId"
20      }
21    }
22  },
23  "analyzer": "lucene.english"
24}

Ejemplo

La siguiente consulta find() recupera las películas tituladas "Alicia en el País de las Maravillas" y almacena los resultados en movie. Especifica que los resultados solo deben contener los campos title y genres de los documentos coincidentes. Tenga en cuenta que, por defecto, el comando find() siempre devuelve el campo _id, cuyo valor podría variar en su clúster.

movie = db.movies.find( { title: "Alice in Wonderland" }, { genres: 1, title: 1} ).toArray
[
  {
   _id: ObjectId("573a1394f29313caabcde9ef"),
   plot: 'Alice stumbles into the world of Wonderland. Will she get home? Not if the Queen of Hearts has her way.',
   title: 'Alice in Wonderland'
  },
  {
   _id: ObjectId("573a1398f29313caabce963d"),
   plot: 'Alice is in Looking Glass land, where she meets many Looking Glass creatures and attempts to avoid the Jabberwocky, a monster that appears due to her being afraid.',
   title: 'Alice in Wonderland'
  },
  {
   _id: ObjectId("573a1398f29313caabce9644"),
   plot: 'Alice is in Looking Glass land, where she meets many Looking Glass creatures and attempts to avoid the Jabberwocky, a monster that appears due to her being afraid.',
   title: 'Alice in Wonderland'
  },
  {
   _id: ObjectId("573a139df29313caabcfb504"),
   plot: `The wizards behind The Odyssey (1997) and Merlin (1998) combine Lewis Carroll's "Alice in Wonderland" and "Through the Looking Glass" into a two-hour special that just gets curiouser and curiouser.`,
   title: 'Alice in Wonderland'
  },
  {
   _id: ObjectId("573a13bdf29313caabd5933b"),
   plot: "Nineteen-year-old Alice returns to the magical world from her childhood adventure, where she reunites with her old friends and learns of her true destiny: to end the Red Queen's reign of terror.",
   title: 'Alice in Wonderland'
  }
]

El siguiente ejemplo usa un operador compuesto para query los campos title y genres utilizando las siguientes cláusulas:

  • La cláusula should utiliza el operador moreLikeThis para buscar documentos similares al documento movie. Tenga en cuenta que el campo title se analiza con los analizadores lucene.standard y lucene.keyword.

  • La cláusula mustNot especifica que uno de los documentos de entrada, especificado por su valor _id, no debe incluirse en los resultados.

La query limita la lista de resultados a 10 documentos. La consulta utiliza una etapa $project para incluir los campos _id, title y genres en los resultados.

Ejemplo

1db.movies.aggregate([
2{
3   $search: {
4     "compound": {
5       "should": [{
6          "moreLikeThis": {
7             "like": movie
8          }
9       }],
10     "mustNot": [
11     {
12     "equals": {
13     "path": "_id",
14      "value": ObjectId ("573a1394f29313caabcde9ef")
15    }
16   }]
17 }
18  }
19  },
20 { $limit: 10 },
21          {
22 $project: {
23     "title": 1,
24     "genres": 1,
25     "_id": 1
26   }
27  }
28 ])
[
  {
   _id: ObjectId("573a1398f29313caabce963d"),
   genres: [ 'Adventure', 'Family', 'Fantasy' ],
   title: 'Alice in Wonderland'
  },
  {
   _id: ObjectId("573a1398f29313caabce9644"),
   genres: [ 'Adventure', 'Family', 'Fantasy' ],
   title: 'Alice in Wonderland'
  },
  {
   _id: ObjectId("573a139df29313caabcfb504"),
   genres: [ 'Adventure', 'Comedy', 'Family' ],
   title: 'Alice in Wonderland'
  },
  {
   _id: ObjectId("573a13bdf29313caabd5933b"),
   genres: [ 'Adventure', 'Family', 'Fantasy' ],
   title: 'Alice in Wonderland'
  },
  {
   _id: ObjectId("573a1396f29313caabce3e7e"),
   genres: [ 'Comedy', 'Drama' ],
   title: 'Alex in Wonderland'
  },
  {
   _id: ObjectId("573a13bdf29313caabd5a44b"),
   genres: [ 'Drama' ],
   title: 'Phoebe in Wonderland'
  },
  {
   _id: ObjectId("573a139af29313caabcf0e23"),
   genres: [ 'Documentary' ],
   title: 'Wonderland'
  },
  {
   _id: ObjectId("573a139ef29313caabcfcebc"),
   genres: [ 'Drama' ],
   title: 'Wonderland'
  },
  {
   _id: ObjectId("573a13a0f29313caabd03dab"),
   genres: [ 'Drama' ],
   title: 'Wonderland'
  },
  {
   _id: ObjectId("573a13abf29313caabd2372a"),
   genres: [ 'Crime', 'Drama', 'Mystery' ],
   title: 'Wonderland'
  }
]

La siguiente consulta utiliza explain con la consulta anterior para mostrar la disyunción (OR) que MongoDB Search construye para encontrar documentossimilares.

db.movies.explain("queryPlanner").aggregate([
 {
   $search: {
     "compound": {
       "should": [{
          "moreLikeThis": {
             "like": [{
                "title": "Alice in Wonderland"
             }]
          }
       }],
     "mustNot": [
     {
     "equals": {
     "path": "_id",
      "value": ObjectId ("573a1394f29313caabcde9ef")
    }
   }]
 }
  }
  },
{ $limit: 10 },
          {
$project: {
     "title": 1,
     "genres": 1,
     "_id": 1
   }
 }
])
{
 explainVersion: '1',
   stages: [
     {
      '$_internalSearchMongotRemote': {
         mongotQuery: {
         compound: {
         should: [
          {
            moreLikeThis: { like: [ { title: 'Alice in Wonderland' } ] }
          }
         ],
         mustNot: [
          {
            equals: {
              path: '_id',
              value: ObjectId("573a1394f29313caabcde9ef")
            }
          }
         ]
      }
     },
     explain: {
      type: 'BooleanQuery',
        args: {
         must: [],
         mustNot: [
           {
             path: 'compound.mustNot',
             type: 'ConstantScoreQuery',
             args: {
               query: {
               type: 'TermQuery',
             args: {
                path: '_id',
                value: '[57 3a 13 94 f2 93 13 ca ab cd e9 ef]'
               }
              }
            }
           }
         ],
         should: [
          {
            path: 'compound.should',
            type: 'BooleanQuery',
            args: {
             must: [],
             mustNot: [],
             should: [
              {
               type: 'TermQuery',
               args: { path: 'title', value: 'in' }
              },
              {
                type: 'TermQuery',
                args: {
                  path: 'title.keywordAnalyzer',
                  value: 'Alice in Wonderland'
                }
               },
              {
                type: 'TermQuery',
                args: { path: 'title', value: 'wonderland' }
              },
              {
                type: 'TermQuery',
                args: { path: 'title', value: 'alice' }
              }
             ],
             filter: [],
              minimumShouldMatch: 0
             }
            }
          ],
            filter: [],
             minimumShouldMatch: 0
            }
           }
          }
         },
 { '$_internalSearchIdLookup': {} },
 { '$limit': Long("10") },
 { '$project': { _id: true, title: true, genres: true } }
  ],
 serverInfo: {
 ...
 },
 serverParameters: {
 ...
 },
 command: {
   aggregate: 'movies',
     pipeline: [
       {
        '$search': {
           compound: {
             should: [
               {
                 moreLikeThis: { like: [ { title: 'Alice in Wonderland' } ] }
               }
             ],
             mustNot: [
              {
                equals: {
                  path: '_id',
                  value: ObjectId("573a1394f29313caabcde9ef")
                }
              }
             ]
           }
          }
        },
  { '$limit': 10 },
  { '$project': { title: 1, genres: 1, _id: 1 } }
  ],
  cursor: {},
  '$db': 'sample_mflix'
  },
  ok: 1,
  '$clusterTime': {
  clusterTime: Timestamp({ t: 1659133479, i: 1 }),
  signature: {
     hash: Binary(Buffer.from("865d9ef1187ae1a74c4a0da1e29882aebcf2be7c", "hex"), 0),
     keyId: Long("7123262728533180420")
  }
 },
 operationTime: Timestamp({ t: 1659133479, i: 1 })
 }

Volver

knnBeta (Obsoleto)

Next

near

En esta página