/ /

Referencia de query

Operadores y coleccionistas

Operadores y coleccionistas

`moreLikeThis` Operador

`moreLikeThis` Limitaciones de operador

No se puede utilizar el operador moreLikeThis para consultar valores no-cadena. Para buscar valores non-string, puedes combinar una moreLikeThis query con un operador cercano, rango, o cualquier otro operador en una compound query.

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 especifiques 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 operador moreLikeThis realiza una búsqueda de documentos similares utilizando el analizador que se especifica en la configuración del índice. Si omite el analizador en la definición del índice, el operador moreLikeThis utiliza el analizador estándar por defecto. Si se especifican varios analizadores, el operador moreLikeThis ejecuta el texto de entrada a través de cada analizador, realiza la búsqueda y devuelve resultados para todos los analizadores.

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:

Ejecutar una query, como find() u otra query MQL para encontrar documentos BSON.
Ejecute cualquier pipeline 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 query.	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: `boost`Multiplica la puntuación resultante por el número dado. `constant`: reemplazar la puntuación del resultado por 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 operador moreLikeThis para encontrar documentos que sean similares a múltiples valores de campo. Para este ejemplo, la definición del índice contiene mapeos dinámicos para indexar dinámicamente todos los tipos de campo indexables dinámicamente en la colección. Su definición de índice para la colección sample_mflix.movies 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.

1 db.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 query find() encuentra la película con el título "El Padrino" y almacena el resultado dentro de movie. Especifica que los resultados deben contener únicamente los campos title y genres para los documentos coincidentes. Tenga en cuenta que, por defecto, el comando find () siempre devuelve el campo _id, cuyo valor podría ser diferente 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 hacer queries sobre 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.

1 db.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 luego usa un operador moreLikeThis para encontrar documentos similares. En este ejemplo, la definición del índice utiliza mapeos estáticos para indexar los campos en la colección sample_mflix.movies 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 usando 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 find() query recupera las películas con el título "Alíce en el país de las maravillas" y almacena los resultados en movie. Especifica que los resultados deben contener únicamente los campos title y genres para los documentos coincidentes. Tenga en cuenta que, por defecto, el comando find() siempre devuelve el campo _id, cuyo valor podría ser diferente 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 en 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

1 db.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 query usa explicar con la consulta anterior para mostrar la disyunción (O) que MongoDB Search construye para encontrar documentos similares.

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)

near

1	db.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	])

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	}

1	db.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	])

1	db.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	])

moreLikeThis Operador

moreLikeThis Limitaciones de operador

Definición

Comportamiento

Uso

Sintaxis

opciones

Ejemplos

Ejemplo 1: Un solo documento con varios campos

Ejemplo

Ejemplo 2: Documento de entrada excluido en los resultados

Ejemplo

Nota

Ejemplo 3: Varios analizadores

Ejemplo

Ejemplo

`moreLikeThis` Operador

`moreLikeThis` Limitaciones de operador