span (Operador de búsqueda de MongoDB)

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:

Ejemplo

La siguiente consulta de ejemplo utiliza span.contains para buscar documentos en los que el término train aparece con los términos great y robbery, donde great y robbery pueden estar hasta 5 posiciones separados 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 little con) dentro de los términos great y robbery (especificados big con). Si establece spanToReturn en la línea 6 innercomo, MongoDB Search devuelve los mismos documentos porque el término train (especificado little con) aparece dentro de los términos great y robbery (especificados big con).

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:

Ejemplo

Las siguientes consultas de ejemplo utilizan span.first para buscar documentos en los que la cadena 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 la segunda palabra del 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' }
]

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' }
]

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:

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.

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:

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.

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:

Ejemplo

La siguiente consulta de ejemplo utiliza span.subtract para buscar documentos cuyo campo title contenga las palabras father y son, en cualquier orden, con una separación de 3 palabras. Excluye cualquier documento donde 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 que está dentro del criterio exclude de la consulta.