span (MongoDB Search Operador)

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 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).

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

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

The following example query uses span.or clauses to specify two term operator queries that search for documents in which the title field has either city or 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.

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 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.