/ /

Referencia de query

Operadores y coleccionistas

Operadores y coleccionistas

`span` (MongoDB Search Operador)

Definición

Nota

El operador span ha quedado obsoleto. En su lugar, usa el frase.

span

El operador span encuentra coincidencias de búsqueda de texto dentro de regiones de un campo de texto. Puedes usarlo para encontrar cadenas que estén cerca unas de otras en grados especificados de precisión. El operador span es más intensivo a nivel computacional que otros operadores, porque las consultas deben rastrear la información posicional.

span es un operador a nivel de término, lo que significa que el campo query no está analizado. Los operadores de nivel de término funcionan bien con el Analizador de palabras clave porque el campo query se trata como un solo término, incluyendo caracteres especiales.

span las query no se clasifican por puntuación.

Sintaxis

span tiene la siguiente sintaxis:

{
   $search: {
     "index": <index name>, // optional, defaults to "default"
     "span": {
       "term" | <positional-operator>": {
         <operator-specification>
       }
     }
   }
}

Nota

span las consultas de búsqueda no pueden usar el operador compuesto.

Operador de términos

Puede utilizar el operador term para especificar los términos a buscar. Se requiere el operador term y cuando lo utilices con span posicional operadores, debe ser el elemento hijo más interno de los operadores posicionales.

Sintaxis

El operador term tiene la siguiente sintaxis:

"term": {
  "path": "<path-to-field>",
  "query": "<terms-to-search>"
}

Campos

El operador term toma los siguientes campos:

Opción	Tipo	¿Requerido?	Descripción
`path`	string	Sí	Campo indexado para buscar.
`query`	string	Sí	Término o frase para búsqueda.

Operadores posicionales

Puedes usar los operadores posicionales para especificar la posición de los términos que deseas buscar con el operador término. Los operadores posicionales son de tipo document. Debe especificar al menos un operador posicional en su query del operador span. Los operadores posicionales pueden tomar otros span operadores posicionales, de manera recursiva.

Nota

Sobre los ejemplos

The examples on this page use the sample_mflix.movies collection. If you load the sample data and create a dynamic index named default on the movies collection , you can run the following $search sample queries against the collection. The sample queries use the $limit stage to limit the results to 5 documents and the $project stage to exclude all fields except the title field in the results.

span toma los siguientes operadores posicionales opcionales.

`contains`

El operador posicional contains coincide con términos que están contenidos dentro de otros términos. Puedes usar operadores posicionales recursivamente o simplemente el operador de términos dentro de contains para especificar los términos de búsqueda.

Sintaxis

El operador posicional contains tiene la siguiente sintaxis:

{
  "$search": {
    "span": {
      "contains": {
        "spanToReturn": "inner"|"outer",
        "little": { <positional-or-term-operator-specification> },
        "big": { <positional-or-term-operator-specification> }
      }
    }
  }
}

Campos

El operador posicional contains toma los siguientes campos:

Campos

Tipo

¿Requerido?

Descripción

big

Documento

Sí

Uno o varios operadores posicionales especificados recursivamente o sólo el operador término. En la siguiente tabla se muestra el tipo de query que span ejecuta para big en función del valor de spanToReturn.

`outer`	`span` coincide con términos de `big` que contienen al menos un término de `little`.
`inner`	`span` coincide términos de `little` que están dentro de términos de `big`.

little

Documento

Sí

Uno o varios operadores posicionales especificados recursivamente o sólo el operador término. En la siguiente tabla se muestra el tipo de query que span ejecuta para little en función del valor de spanToReturn.

`inner`	`span` coincide términos de `little` que están dentro de términos de `big`.
`outer`	`span` coincide con términos de `big` que contienen al menos un término de `little`.

score

Documento

Puntuación para aplicar a los resultados de esta búsqueda.

spanToReturn

string

Sí

Tipo de query a ejecutar y resultados coincidentes a devolver. El valor puede ser uno de los siguientes:

inner - para ejecutar una consulta dentro de que coincida con los términos de little que están dentro de los términos de big
outer - para ejecutar una consulta contiene que coincida con términos de big que contenga al menos un término de little

Ejemplo

La siguiente query de ejemplo utiliza span.contains para encontrar documentos en los que el término train aparece con los términos great y robbery, donde great y robbery pueden estar separados hasta por 5 posiciones en el campo title.

1 db.movies.aggregate([
2   {
3     "$search": {
4       "span": {
5         "contains": {
6           "spanToReturn": "outer",
7           "little": {
8             "term": {
9               "path": "title",
10               "query": "train"
11             }
12           },
13           "big": {
14             "near": {
15               "clauses": [
16                 {
17                   "term": {
18                     "path": "title",
19                     "query": "great"
20                   }
21                 },
22                 {
23                   "term": {
24                     "path": "title",
25                     "query": "robbery"
26                   }
27                 }
28               ],
29               "slop": 5
30             }
31           }
32         }
33       }
34     }
35   },
36   {
37     "$limit": 5
38   },
39   {
40     "$project": {
41       "_id": 0,
42       "title": 1
43     }
44   }
45 ])

[
  { title: 'The Great Train Robbery' },
  { title: 'The Great Train Robbery' },
  { title: "The Great St. Trinian's Train Robbery" }
]

MongoDB Search devuelve documentos que contienen el término train (especificado usando el little) dentro de los términos great y robbery (especificados usando el big). Si se configura spanToReturn en la línea 6 como inner, MongoDB Search devuelve los mismos documentos porque el término train (especificado mediante little) aparece dentro de los términos great y robbery (especificados mediante big).

`first`

El operador posicional first identifica la posición del término de búsqueda utilizando un número especificado. Puede especificar los términos de búsqueda utilizando operadores posicionales de manera recursiva, o simplemente el operador término. span coincide con los documentos donde la posición del término de búsqueda es menor o igual al número especificado.

Sintaxis

El operador posicional first tiene la siguiente sintaxis:

{
  "$search": {
    "span": {
      "first": {
        "endPositionLte": <term-position>,
        "operator": { <span-positional-or-term-operator-specification> },
        "score": { <score-options> }
      }
    }
  }
}

Campos

El operador posicional first toma los siguientes campos:

Opción	Tipo	¿Requerido?	Descripción
`endPositionLte`	Int	no	Número que especifica la posición del término de búsqueda. Si especificas una búsqueda de varios términos, el último término debe ser menor o igual a este valor. Si se omite, el valor por defecto es `3`.
`operator`	Documento	Sí	Documento que contiene las operadores posicionales o las opciones del operador término.
`score`	Documento	no	Puntuación para aplicar a los resultados de esta búsqueda.

Ejemplo

Las siguientes consultas de ejemplo utilizan span.first para encontrar documentos en los que la string especificada aparece en el campo title. El parámetro endPositionLte tiene un valor de 2, lo que significa que el término de búsqueda especificado con el operador term debe ser la primera o segunda palabra en el campo.

1 db.movies.aggregate([
2   {
3     "$search": {
4       "span": {
5         "first": {
6           "endPositionLte": 2,
7           "operator": {
8             "term": {
9               "path": "title",
10               "query": "dance"
11             }
12           }
13         }
14       }
15     }
16   },
17   {
18     "$limit": 5
19   },
20   {
21     "$project": {
22       "_id": 0,
23       "title": 1
24     }
25   }
26 ])

[
  { title: 'Dance Program' },
  { title: 'Slam Dance' },
  { title: 'Last Dance' },
  { title: 'War Dance' },
  { title: 'Delhi Dance' }
]

MongoDB Search devuelve los documentos que contienen la palabra de búsqueda dance en la primera o segunda posición del campo title.

1 db.movies.aggregate([
2   {
3     "$search": {
4       "span": {
5         "first": {
6           "endPositionLte": 2,
7           "operator": {
8             "or": {
9               "clauses": [
10                 { "term": { "path": "title", "query": "man" } },
11                 { "term": { "path": "title", "query": "woman" } }
12               ]
13             }
14           }
15         }
16       }
17     }
18   },
19   {
20     "$limit": 5
21   },
22   {
23     "$project": {
24       "_id": 0,
25       "title": 1
26     }
27   }
28 ])

[
  { title: "Everybody's Woman" },
  { title: 'Marked Woman' },
  { title: 'Wonder Man' },
  { title: 'Designing Woman' },
  { title: 'Watermelon Man' }
]

MongoDB Search devuelve documentos que contienen la palabra de búsqueda man o woman en la primera o segunda posición del campo title. MongoDB Search no devuelve ambos términos de búsqueda en el mismo title porque el ejemplo incluye el operador or clauses para especificar los términos de búsqueda.

`near`

El operador posicional near coincide con dos o más cláusulas que contienen el término de búsqueda cerca unas de otras. Puedes especificar los términos de búsqueda utilizando una lista de operadores posicionales recursivamente o simplemente el operador término.

Sintaxis

El operador posicional near tiene la siguiente sintaxis:

{
  "$search": {
    "span": {
      "near": {
        "clauses": [
          { <span-positional-or-term-operator-specification> },
          ...
        ],
        "slop": <distance-number>,
        "inOrder": true|false
      }
    }
  }
}

Campos

El operador posicional near toma los siguientes campos:

Campo	Tipo	¿Requerido?	Descripción
`clauses`	arreglo de documentos	Sí	Las cláusulas de rango deben estar cerca una de la otra. Las cláusulas no pueden estar vacías. Cada documento contiene `span` posicionales o simplemente las opciones del operador término.
`inOrder`	booleano	no	Indicador que especifica si la búsqueda de términos en las cláusulas debe realizarse en el orden especificado y no debe superponerse. El valor puede ser uno de los siguientes: `true` - buscar términos en las cláusulas en el orden especificado, sin superposiciones `false` - buscar términos en las cláusulas en cualquier orden Si se omite, es por defecto `false`.
`score`	Documento	no	Puntuación para aplicar a los resultados de esta búsqueda.
`slop`	entero	no	Distancia permitida entre términos en las cláusulas. Los valores más bajos permiten una menor distancia posicional entre los términos y los valores más altos permiten una mayor distancia entre las palabras para satisfacer la query. La opción por defecto es `0`, lo que significa que las palabras en las distintas cláusulas deben ser adyacentes para ser consideradas como una coincidencia.

Ejemplo

La siguiente query de ejemplo usa span.near para buscar documentos en los que las cadenas prince y pauper se encuentren cercanas entre sí. El parámetro inOrder está establecido en false, por lo que los términos de búsqueda pueden estar en cualquier orden. El parámetro slop está establecido en 4, por lo que los términos de búsqueda pueden estar separados por hasta solo 4 palabras.

1 db.movies.aggregate([
2   {
3     "$search" : {
4       "span": {
5         "near": {
6           "clauses": [
7             { "term": { "path": "title", "query": "prince" } },
8             { "term": { "path": "title", "query": "pauper" } }
9           ],
10           "slop": 4,
11           "inOrder": false
12         }
13       }
14     }
15   },
16   {
17     "$limit": 5
18   },
19   {
20     "$project": {
21       "_id": 0,
22       "title": 1
23     }
24   }
25 ])

[ { title: 'The Prince and the Pauper' } ]

MongoDB Search devuelve un documento que contiene las palabras de búsqueda prince y pauper, separadas por menos de cuatro palabras, en el campo title.

`or`

El operador posicional or coincide con cualquiera de dos o más cláusulas. Se pueden especificar los términos de búsqueda utilizando una lista de operadores posicionales de forma recursiva o simplemente el operador de términos.

Sintaxis

El operador posicional or tiene la siguiente sintaxis:

{
  "$search": {
    "span": {
      "or": {
        "clauses": [
          { <span-positional-or-term-operator-specification> },
          ...
        ],
        "score": { <scoring-options> }
      }
    }
  }
}

Campos

El operador posicional or toma los siguientes campos:

Opción	Tipo	¿Requerido?	Descripción
`clauses`	arreglo de documentos	Sí	Cláusulas de alcance que especifican los términos de búsqueda. Una de las condiciones debe coincidir, y las condiciones no pueden estar vacías. Cada documento debe contener `span` operadores posicionales especificados recursivamente o simplemente las opciones del operador término.
`score`	Documento	no	Puntuación para aplicar a los resultados de esta búsqueda.

Ejemplo

La siguiente query de ejemplo utiliza cláusulas span.or para especificar dos queries del operador de términos que buscan documentos en los que el campo title tiene city o country.

1 db.movies.aggregate([
2   {
3     "$search" : {
4       "span": {
5         "or": {
6           "clauses": [
7             { "term": { "path": "title", "query": "city" } },
8             { "term": { "path": "title", "query": "country" } }
9           ],
10         }
11       }
12     }
13   },
14   {
15     "$limit": 5
16   },
17   {
18     "$project": {
19       "_id": 0,
20       "title": 1
21     }
22   }
23 ])

[
  { title: 'Country' },
  { title: 'City Lights' },
  { title: 'King & Country' },
  { title: 'Fat City' },
  { title: 'Atlantic City' }
]

MongoDB Search devuelve los documentos que contienen las palabras de búsqueda city o country en el campo title, pero no ambas en el mismo title.

`subtract`

El operador posicional subtract remueve las coincidencias que se superponen a otra coincidencia. Puedes especificar los términos de búsqueda usando una lista de operadores posicionales de forma recursiva o solo el operador término. La cláusula subtract se puede usar para excluir ciertas cadenas de los resultados de búsqueda.

Sintaxis

El operador posicional subtract tiene la siguiente sintaxis:

{
  "$search": {
    "span": {
      "subtract": {
        "include": { <span-positional-or-term-operator-specification> },
        "exclude": { <span-positional-or-term-operator-specification> }
      }
    }
  }
}

Campos

El operador posicional subtract toma los siguientes campos:

Opción	Tipo	¿Requerido?	Descripción
`exclude`	Documento	Sí	documento que especifica las coincidencias de términos o frases que se deben remover y que se superponen con las coincidencias de términos o frases especificadas en el campo `include`. Puedes especificar el término o frase utilizando cualquier operador posicional de intervalo y el operador término.
`include`	Documento	Sí	Documento que especifica la coincidencia de términos que se incluirán mediante cualquier operador posicional o simplemente el operador de término.
`score`	Documento	no	Puntuación para aplicar a los resultados de esta búsqueda.

Ejemplo

La siguiente query de ejemplo utiliza span.subtract para buscar documentos en los que el campo title contenga las palabras father y son, en cualquier orden, a una distancia máxima de 3 palabras entre sí. Excluye cualquier documento en el que la palabra like aparezca entre father y son.

1 db.movies.aggregate([
2   {
3     "$search" : {
4       "span": {
5         "subtract": {
6           "include": {
7             "near": {
8               "clauses": [
9                 { "term": { "path": "title", "query": "father" } },
10                 { "term": { "path": "title", "query": "son" } }
11               ],
12               "inOrder": false,
13               "slop": 3
14             }
15           },
16           "exclude": { "term": { "path": "title", "query": "like" } }
17         }
18       }
19     }
20   },
21   {
22     "$limit": 5
23   },
24   {
25     "$project": {
26       "_id": 0,
27       "title": 1
28     }
29   }
30 ])

[
  { title: 'Father, Son & Holy Cow' },
  { title: 'My Father and My Son' },
  { title: 'Jimmy Rosenberg: The Father, the Son & the Talent' }
]

MongoDB Search no devuelve el documento con el título Like Father Like Son porque, aunque el campo title incluye las palabras father y son, también tiene like entre ellas, lo cual está en el criterio exclude de la query.

Volver

regex

text

1	db.movies.aggregate([
2	{
3	"$search": {
4	"span": {
5	"contains": {
6	"spanToReturn": "outer",
7	"little": {
8	"term": {
9	"path": "title",
10	"query": "train"
11	}
12	},
13	"big": {
14	"near": {
15	"clauses": [
16	{
17	"term": {
18	"path": "title",
19	"query": "great"
20	}
21	},
22	{
23	"term": {
24	"path": "title",
25	"query": "robbery"
26	}
27	}
28	],
29	"slop": 5
30	}
31	}
32	}
33	}
34	}
35	},
36	{
37	"$limit": 5
38	},
39	{
40	"$project": {
41	"_id": 0,
42	"title": 1
43	}
44	}
45	])

1	db.movies.aggregate([
2	{
3	"$search" : {
4	"span": {
5	"near": {
6	"clauses": [
7	{ "term": { "path": "title", "query": "prince" } },
8	{ "term": { "path": "title", "query": "pauper" } }
9	],
10	"slop": 4,
11	"inOrder": false
12	}
13	}
14	}
15	},
16	{
17	"$limit": 5
18	},
19	{
20	"$project": {
21	"_id": 0,
22	"title": 1
23	}
24	}
25	])