regex (MongoDB Search Operador)

Caracteres reservados

Los siguientes caracteres están reservados como operadores cuando se usan en expresiones regulares:

. ? + * | { } [ ] ( ) < > " \ @ #

Para utilizar cualquiera de los caracteres anteriores literalmente en una expresión de coincidencia, antepóngale un carácter \.

Cuando uses el carácter de escape en mongosh o con un driver, debes utilizar una barra invertida double antes del carácter de escape.

"*\\**"

"*\\\*"

Operadores compatibles

Operadores no compatibles

regex no admite operadores de anclaje. Por ejemplo, estos operadores no son compatibles:

• ^y que corresponde al inicio de una línea.

• $coincide con el final de una línea.

Para que coincida con un término, la expresión regular debe coincidir con toda la string.

Definición del índice

La siguiente definición de índice indexa el campo title en la colección movies con el Analizador de palabras clave:

1
{
2
  "mappings": {
3
    "fields": {
4
      "title": {
5
        "analyzer": "lucene.keyword",
6
        "type": "string"
7
      },
8
      "genres": {
9
        "type": "token"
10
      }
11
    }
12
  }
13
}

Posición del término

El siguiente ejemplo utiliza la expresión regular .* para encontrar títulos de películas que contengan el término summer en cualquier lugar del title y retorna el número de películas que cumplen con el criterio en cada género.

1
db.movies.aggregate([
2
  {
3
    "$searchMeta": {
4
      "facet": {
5
        "operator": {
6
          "regex": {
7
            "path": "title",
8
            "query": ".*summer.*"
9
          }
10
        },
11
        "facets": {
12
          "genresFacet": {
13
            "type": "string",
14
            "path": "genres"
15
          }
16
        }
17
      }
18
    }
19
  }
20
])

[
  {
    count: { lowerBound: Long('6') },
    facet: {
      genresFacet: {
        buckets: [
          { _id: 'Comedy', count: Long('5') },
          { _id: 'Fantasy', count: Long('3') },
          { _id: 'Romance', count: Long('3') },
          { _id: 'Drama', count: Long('2') },
          { _id: 'Horror', count: Long('1') },
          { _id: 'Mystery', count: Long('1') }
        ]
      }
    }
  }
]

The following example searches all title fields for movie titles that end with the word Seattle. The (.*) regular expression matches any number of characters.

1
db.movies.aggregate([
2
  {
3
    "$search": {
4
        "regex": {
5
          "path": "title",
6
          "query": "(.*) Seattle"
7
        }
8
    }
9
  },
10
  {
11
    $project: {
12
        "_id": 0,
13
        "title": 1
14
    }
15
  }
16
])

[ { title: 'Sleepless in Seattle' }, { title: 'Battle in Seattle' } ]

Rango de números

El siguiente ejemplo utiliza la expresión regular [0-9]{2} (.){4}s para encontrar títulos de películas que empiezan con un número de dos dígitos seguido de un espacio y terminan con una palabra de cinco letras que termina en s.

1
db.movies.aggregate([
2
  {
3
    "$search": {
4
        "regex": {
5
          "path": "title",
6
          "query": "[0-9]{2} (.){4}s"
7
        }
8
    }
9
  },
10
  {
11
    $project: {
12
        "_id": 0,
13
        "title": 1
14
    }
15
  }
16
])

[
  { title: '20 Dates' },
  { title: '25 Watts' },
  { title: '21 Grams' },
  { title: '13 Lakes' },
  { title: '18 Meals' },
  { title: '26 Years' },
  { title: '99 Homes' },
  { title: '45 Years' }
]

Frase de varias palabras

El siguiente ejemplo utiliza la expresión regular .*Toy Story.* para encontrar todos los títulos de películas que contengan la frase Toy Story. Debido a que el campo de búsqueda utiliza el analizador de palabras clave, la expresión regular coincide con la frase exactamente como está almacenada, incluido el espacio entre palabras.

1
db.movies.aggregate([
2
  {
3
    "$search": {
4
        "regex": {
5
          "path": "title",
6
          "query": ".*Toy Story.*"
7
        }
8
    }
9
  },
10
  {
11
    $project: {
12
        "_id": 0,
13
        "title": 1
14
    }
15
  }
16
])

[
  { title: 'Toy Story' },
  { title: 'Toy Story 2' },
  { title: 'Toy Story 3' },
  { title: 'Toy Story of Terror' },
  { title: 'Toy Story That Time Forgot' }
]

Arreglo de cadenas

El siguiente ejemplo utiliza un arreglo de expresiones regulares para encontrar títulos de películas que coincidan con cualquiera de los patrones especificados. La query encuentra títulos que terminan con Seattle o contienen Toy Story.

1
db.movies.aggregate([
2
  {
3
    "$search": {
4
        "regex": {
5
          "path": "title",
6
          "query": ["(.*) Seattle", ".*Toy Story.*"]
7
        }
8
    }
9
  },
10
  {
11
    $project: {
12
        "_id": 0,
13
        "title": 1
14
    }
15
  }
16
])

[
  { title: 'Sleepless in Seattle' },
  { title: 'Toy Story' },
  { title: 'Toy Story 2' },
  { title: 'Toy Story 3' },
  { title: 'Battle in Seattle' },
  { title: 'Toy Story of Terror' },
  { title: 'Toy Story That Time Forgot' }
]

Búsqueda que distingue entre mayúsculas y minúsculas

El siguiente ejemplo demuestra la coincidencia que distingue entre mayúsculas y minúsculas. Debido a que el índice utiliza el analizador lucene.keyword, el cual conserva la capitalización original de cada valor indexado, la query debe coincidir con el caso exacto de los títulos almacenados. La query .*Sleepless.* coincide con Sleepless in Seattle, pero .*sleepless.* no arroja resultados.

1
db.movies.aggregate([
2
  {
3
    "$search": {
4
        "regex": {
5
          "path": "title",
6
          "query": ".*sleepless.*"
7
        }
8
    }
9
  },
10
  {
11
    $project: {
12
        "_id": 0,
13
        "title": 1
14
    }
15
  }
16
])

<no results>