/ /

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, utilice la 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 usar el term operador para especificar los términos de búsqueda. El term operador es obligatorio y, al usarlo con span operadores posicionales, debe ser el operador secundario 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

Puede usar los operadores posicionales para especificar la posición de los términos que desea buscar con el operador de término. Los operadores posicionales son de document tipo. Debe especificar al menos un operador posicional en su span consulta de operador. Los operadores posicionales pueden aceptar otros span operadores posicionales recursivamente.

Nota

Sobre los ejemplos

Los ejemplos en esta página utilizan la colección sample_mflix.movies. Si cargas los datos de ejemplo y creas un índice dinámico llamado default en la colección de películas , puedes ejecutar las siguientes $search consultas de muestra contra la colección. Las consultas de muestra usan la etapa $limit para limitar los resultados a 5 documentos y la etapa $project para excluir todos los campos, excepto el campo title en los resultados.

span toma los siguientes operadores posicionales opcionales.

`contains`

El contains operador posicional coincide con términos incluidos en otros términos. Puede usar operadores posicionales recursivamente o simplemente el operador de término 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 first operador posicional identifica la posición del término de búsqueda mediante un número específico. Puede especificar los términos de búsqueda mediante operadores posicionales recursivos o simplemente el operador de término. span encuentra documentos donde la posición del término de búsqueda es menor o igual que el 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 near operador posicional coincide con dos o más cláusulas que contienen el término de búsqueda cerca una de la otra. Puede especificar los términos de búsqueda utilizando una lista de operadores posicionales recursivamente o simplemente el operador de 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 or operador posicional coincide con dos o más cláusulas. Puede especificar los términos de búsqueda utilizando una lista de operadores posicionales recursivamente o simplemente el operador de término.

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 consulta de ejemplo utiliza span.or cláusulas para especificar dos consultas de operador de término que buscan documentos en los que el title campo tiene city countryo.

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 subtract operador posicional elimina las coincidencias que se superponen con otra. Puede especificar los términos de búsqueda mediante una lista de operadores posicionales recursivamente o simplemente el operador de término. La subtract cláusula puede utilizarse 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	])

span (MongoDB Search Operador)

Definición

Nota

Sintaxis

Nota

Operador de términos

Sintaxis

Campos

Operadores posicionales

Nota

Sobre los ejemplos

contains

Sintaxis

Campos

Ejemplo

first

Sintaxis

Campos

Ejemplo

near

Sintaxis

Campos

Ejemplo

or

Sintaxis

Campos

Ejemplo

subtract

Sintaxis

Campos

Ejemplo

`span` (MongoDB Search Operador)

`contains`

`first`

`near`

`or`

`subtract`