Menu Docs
Página inicial do Docs
/
Manual do MongoDB
/ / / /

$regex

Nesta página

  • Definição
  • Compatibilidade
  • Sintaxe
  • Comportamento
  • Exemplos

Observação

Esta página descreve os recursos de pesquisa de expressões regulares para implantações autogerenciadas (não Atlas). Para dados hospedados no MongoDB Atlas, o MongoDB oferece uma solução de Full Text Search melhorada, Atlas Search, que tem seu próprio operador $regex. Para obter mais informações, consulte $regex na documentação do Atlas Search.

$regex

Fornece capacidades de expressão regular para strings de correspondência de padrões em consultas.

Você pode utilizar o $regex para implantações hospedadas nos seguintes ambientes:

  • MongoDB Atlas: o serviço totalmente gerenciado para implantações do MongoDB na nuvem

  • MongoDB Enterprise: a versão autogerenciada e baseada em assinatura do MongoDB

  • MongoDB Community: uma versão com código disponível, de uso gratuito e autogerenciada do MongoDB

Para usar $regex, use uma das seguintes sintaxes:

{ <field>: { $regex: /pattern/, $options: '<options>' } }
{ "<field>": { "$regex": "pattern", "$options": "<options>" } }
{ <field>: { $regex: /pattern/<options> } }

Observação

A fim de usar $regex com mongodump, você deve colocar a query entre aspas simples ('{ ... }') para garantir que não interaja com seu ambiente shell.

A consulta deve estar no formato JSON v2 estendido (modo relaxado ou canônico/estrito), o que inclui posicionar os nomes de campo e operadores entre aspas. Por exemplo:

mongodump -d=sample_mflix -c=movies -q='{"year": {"$regex": "20"}}'

No MongoDB, você também pode usar objetos de expressão regular (ou seja, /pattern/) para especificar expressões regulares:

{ <field>: /pattern/<options> }

Para restrições sobre o uso de sintaxe específica, consulte Sintaxe $regex vs. /pattern/.

$options

As seguintes <options> estão disponíveis para uso com expressão regular.

Opção
Descrição
i
Insensibilidade a maiúsculas e minúsculas para corresponder maiúsculas e minúsculas. Para obter um exemplo, consulte Executar correspondência de expressão regular insensível a maiúsculas e minúsculas.
m

Para padrões que incluem âncoras (ou seja, ^ para o início, $ para o final), corresponde ao início ou ao final de cada linha de strings com valores de várias linhas. Sem esta opção, essas âncoras correspondem no início ou no final da string. Para obter um exemplo, consulte Correspondência multilinha para linhas que começam com um padrão especificado).

Se o padrão não contiver âncoras ou se o valor da string não tiver caracteres de nova linha (por exemplo, \n), a opção m não tem efeito.

x

Capacidade "estendida" para ignorar todos os caracteres de espaço em branco no padrão $regex, a menos que sejam evitados ou incluídos em uma classe de caracteres.

Além disso, ele ignora caracteres intermediários e inclui um caractere de cerquilha (#) não evitado e a próxima nova linha, para que você possa incluir comentários em padrões complicados. Isso se aplica apenas a caracteres de dados. Caracteres de espaço em branco nunca podem aparecer em sequências de caracteres especiais em um padrão.

A opção x não afeta o tratamento do caractere VT (ou seja, código 11).

s
Permite que o caractere de ponto (ou seja, .) corresponda a todos os caracteres, incluindo caracteres de nova linha. Para obter um exemplo, consulte Usar o caractere de ponto . para corresponder à nova linha.
u
Aceita Unicode. Essa sinalização é aceita, mas é redundante. O UTF é definido por padrão no operador $regex, tornando a opção u desnecessária.

Observação

O operador $regex não é compatível com o modificador de pesquisa global g.

Para incluir uma expressão regular em um operador de predicado de consulta $in, você só pode usar objetos de expressão regular JavaScript (/pattern/ ).

Por exemplo:

{ name: { $in: [ /^acme/i, /^ack/ ] } }

Não é possível usar expressões de operador $regex dentro de um operador $in.

Para incluir uma expressão regular em uma lista separada por vírgula de condições de consulta para o campo, utilize o operador $regex. Por exemplo:

{ name: { $regex: /acme.*corp/i, $nin: [ 'acmeblahcorp' ] } }
{ name: { $regex: /acme.*corp/, $options: 'i', $nin: [ 'acmeblahcorp' ] } }
{ name: { $regex: 'acme.*corp', $options: 'i', $nin: [ 'acmeblahcorp' ] } }

Para usar a opção x ou s, você deve usar a expressão do operador $regex com o operador $options. Por exemplo, para especificar as opções i e s, você deve utilizar $options para ambos:

{ name: { $regex: /acme.*corp/, $options: "si" } }
{ name: { $regex: 'acme.*corp', $options: "si" } }

Para usar funcionalidades suportadas por PCRE em uma expressão regular que não são suportadas no JavaScript, você deve usar o operador $regex e especificar a expressão regular como uma string.

Para corresponder strings insensíveis a maiúsculas e minúsculas:

  • "(?i)" inicia uma correspondência insensível a maiúsculas e minúsculas.

  • "(?-i)" encerra uma correspondência insensível a maiúsculas e minúsculas.

Por exemplo, a expressão regular "(?i)a(?-i)cme" corresponde a strings que:

  • Começam com "a" ou "A". Esta é uma correspondência insensível a maiúsculas e minúsculas.

  • Terminam com "cme". Esta é uma correspondência insensível a maiúsculas e minúsculas.

Estas strings correspondem ao exemplo de expressão regular:

  • "acme"

  • "Acme"

O exemplo a seguir usa o operador $regex para encontrar strings de campo name que correspondam à expressão regular "(?i)a(?-i)cme":

{ name: { $regex: "(?i)a(?-i)cme" } }

A partir da versão 6.1, o MongoDB usa a biblioteca PCRE2 (Perl Compatible Regular Expressions) para implementar a correspondência de padrões de expressões regulares. Para saber mais sobre PCRE2, consulte a documentação do PCRE.

O operador $not pode executar a operação lógica NOT em ambos:

  • Objetos de expressão regular (ou seja, /pattern/)

    Por exemplo:

    db.inventory.find( { item: { $not: /^p.*/ } } )
  • $regex expressões de operador

    Por exemplo:

    db.inventory.find( { item: { $not: { $regex: "^p.*" } } } )
    db.inventory.find( { item: { $not: { $regex: /^p.*/ } } } )

O uso e o desempenho do índice para consultas $regex variam e dependem se a consulta diferencia maiúsculas e minúsculas ou não.

Para consultas de expressões regulares que diferenciam maiúsculas de minúsculas, se existir um índice para o campo, o MongoDB compara a expressão regular com os valores no índice, o que pode ser mais rápido do que uma verificação de coleção.

Pode ocorrer otimização adicional se a expressão regular for uma "expressão de prefixo", o que significa que todas as possíveis correspondências começam com a mesma string. Isso permite que o MongoDB construa um "intervalo" a partir desse prefixo e corresponda apenas aos valores do índice que se enquadram nesse intervalo.

Uma expressão regular é uma "expressão de prefixo" se começar com um acento circunflexo (^) ou uma âncora esquerda (\A), seguido por uma string de símbolos simples. Por exemplo, o regex /^abc.*/ será otimizado fazendo a correspondência apenas com os valores do índice que começam com abc.

Além disso, embora /^a/, /^a.*/ e /^a.*$/ correspondam a strings equivalentes, eles têm características de desempenho diferentes. Todas estas expressões utilizam um índice se um índice apropriado existir; entretanto, /^a.*/ e /^a.*$/ são mais lentos. /^a/ pode parar a digitalização depois de combinar o prefixo.

Índices que não diferenciam maiúsculas de minúsculas normalmente não melhoram o desempenho de consultas $regex. A implementação $regex não reconhece agrupamentos e não pode utilizar índices que não diferenciam maiúsculas de minúsculas de forma eficiente.

Os exemplos nesta seção usam a seguinte coleção products:

db.products.insertMany( [
{ _id: 100, sku: "abc123", description: "Single line description." },
{ _id: 101, sku: "abc789", description: "First line\nSecond line" },
{ _id: 102, sku: "xyz456", description: "Many spaces before line" },
{ _id: 103, sku: "xyz789", description: "Multiple\nline description" },
{ _id: 104, sku: "Abc789", description: "SKU starts with A" }
] )

O exemplo a seguir corresponde a todos os documentos onde o campo sku é como "%789":

db.products.find( { sku: { $regex: /789$/ } } )

O exemplo é análogo à seguinte declaração SQL LIKE:

SELECT * FROM products
WHERE sku like "%789";

Saída de exemplo:

[
{ _id: 101, sku: 'abc789', description: 'First line\nSecond line' },
{ _id: 103, sku: 'xyz789', description: 'Multiple\nline description' },
{ _id: 104, sku: 'Abc789', description: 'SKU starts with A' }
]

O exemplo a seguir usa a opção i para fazer uma correspondência insensível a maiúsculas e minúsculas para documentos com o valor sku que começa com ABC.

db.products.find( { sku: { $regex: /^ABC/i } } )

Saída de exemplo:

[
{ _id: 100, sku: 'abc123', description: 'Single line description.' },
{ _id: 101, sku: 'abc789', description: 'First line\nSecond line' },
{ _id: 104, sku: 'Abc789', description: 'SKU starts with A' }
]

O exemplo seguinte utiliza a opção m para corresponder linhas começando com a letra S para strings de múltiplas linhas:

db.products.find( { description: { $regex: /^S/, $options: 'm' } } )

Saída de exemplo:

[
{ _id: 100, sku: 'abc123', description: 'Single line description.' },
{ _id: 101, sku: 'abc789', description: 'First line\nSecond line' },
{ _id: 104, sku: 'Abc789', description: 'SKU starts with A' }
]

Sem a opção m, o exemplo de resultado é:

[
{ _id: 100, sku: 'abc123', description: 'Single line description.' },
{ _id: 104, sku: 'Abc789', description: 'SKU starts with A' }
]

Se o padrão $regex não contiver uma âncora, o padrão corresponderá à string como um todo, como no seguinte exemplo:

db.products.find( { description: { $regex: /S/ } } )

Saída de exemplo:

[
{ _id: 100, sku: 'abc123', description: 'Single line description.' },
{ _id: 101, sku: 'abc789', description: 'First line\nSecond line' },
{ _id: 104, sku: 'Abc789', description: 'SKU starts with A' }
]

O exemplo a seguir usa a opção s para permitir o caractere de ponto (ou seja, .) para combinar todos os caracteres, incluindo a nova linha, bem como a opção i para realizar uma correspondência insensível a maiúsculas e minúsculas:

db.products.find( { description: { $regex: /m.*line/, $options: 'si' } } )

Saída de exemplo:

[
{ _id: 102, sku: 'xyz456', description: 'Many spaces before line' },
{ _id: 103, sku: 'xyz789', description: 'Multiple\nline description' }
]

Sem a opção s, o exemplo de resultado é:

[
{ _id: 102, sku: 'xyz456', description: 'Many spaces before line' }
]

O exemplo a seguir usa a opção x para ignorar os espaços em branco e os comentários, indicados por # e terminados em \n no padrão de correspondência:

var pattern = "abc #category code\n123 #item number"
db.products.find( { sku: { $regex: pattern, $options: "x" } } )

Saída de exemplo:

[
{ _id: 100, sku: 'abc123', description: 'Single line description.' }
]

O exemplo a seguir usa a expressão regular "(?i)a(?-i)bc" para corresponder às strings de campo sku que contêm:

  • "abc"

  • "Abc"

db.products.find( { sku: { $regex: "(?i)a(?-i)bc" } } )

Saída de exemplo:

[
{ _id: 100, sku: 'abc123', description: 'Single line description.' },
{ _id: 101, sku: 'abc789', description: 'First line\nSecond line' },
{ _id: 104, sku: 'Abc789', description: 'SKU starts with A' }
]

Novidades na versão 6.1.

Por padrão, certas opções de regex (como /b e /w) reconhecem somente caracteres ASCII. Isso pode causar resultados inesperados ao realizar combinações regex com caracteres UTF-8.

A partir do MongoDB 6.1, você pode especificar a opção de regex *UCP para corresponder aos caracteres UTF-8.

Importante

Desempenho da opção UCP

A opção *UCP resulta em consultas mais lentas do que aquelas sem a opção especificada, pois *UCP exige uma pesquisa de tabela de múltiplos estágios para executar a correspondência.

Por exemplo, considere os seguintes documentos em uma coleção songs:

db.songs.insertMany( [
{ _id: 0, "artist" : "Blue Öyster Cult", "title": "The Reaper" },
{ _id: 1, "artist": "Blue Öyster Cult", "title": "Godzilla" },
{ _id: 2, "artist" : "Blue Oyster Cult", "title": "Take Me Away" }
] )

A seguinte consulta de regex utiliza a opção \b em uma correspondência regex. A opção \b corresponde a um limite de palavra.

db.songs.find( { artist: { $regex: /\byster/ } } )

Saída de exemplo:

[
{ _id: 0, artist: 'Blue Öyster Cult', title: 'The Reaper' },
{ _id: 1, artist: 'Blue Öyster Cult', title: 'Godzilla' }
]

Os resultados anteriores são inesperados porque nenhuma das palavras nos campos artist retornados começa com a string correspondente (yster). O caractere Ö em documentos _id: 0 e _id: 1 é ignorado ao executar a correspondência porque é um caractere UTF-8.

O resultado esperado é que a consulta não retorne nenhum documento.

Para permitir que a consulta reconheça caracteres UTF-8, especifique a opção *UCP antes do padrão:

db.songs.find( { artist: { $regex: "(*UCP)/\byster/" } } )

A consulta anterior não retorna nenhum documento, que é o resultado esperado.

Dica

Caracteres de escape para padrões Regex

Ao especificar *UCP ou qualquer outra opção de expressão regular, certifique-se de usar os caracteres de escape corretos para seu shell ou driver.

Voltar

$mod