O Amazon Redshift não permitirá mais a criação de UDFs do Python a partir do Patch 198. As UDFs do Python existentes continuarão a funcionar normalmente até 30 de junho de 2026. Para ter mais informações, consulte a [publicação de blog ](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/). # Função REGEXP\$1SUBSTR Retorna os caracteres de uma string ao procurar por um padrão de expressão regular. REGEXP\$1SUBSTR é semelhante a função [Função SUBSTRING](r_SUBSTRING.md), mas permite que você pesquise uma string quanto a um padrão de expressão regular. Se a função não conseguir corresponder a expressão regular com nenhum caractere na string, ela retornará uma string vazia. Para ter mais informações sobre expressões regulares, consulte [Operadores POSIX](pattern-matching-conditions-posix.md) e [Expressão regular](https://en.wikipedia.org/wiki/Regular_expression) na Wikipédia. ## Sintaxe ``` REGEXP_SUBSTR( source_string, pattern [, position [, occurrence [, parameters ] ] ] ) ``` ## Argumentos *source\$1string* Uma expressão de string a ser pesquisada. *Padrão* Um literal de string UTF-8 que representa um padrão de expressão regular. Para obter mais informações, consulte [Operadores POSIX](pattern-matching-conditions-posix.md). *position* Um inteiro positivo que indica a posição em *source\$1string* para começar a pesquisar. A posição é baseada no número de caracteres, e não bytes, de forma que caracteres multibyte são contados como caracteres simples. O padrão é 1. Se a *posição* for menor que 1, a pesquisa começará no primeiro caractere da *source\$1string*. Se *position* for maior que o número de caracteres na *source\$1string*, o resultado será uma string vazia (""). *occurrence* Um inteiro positivo que indica qual ocorrência do padrão usar. REGEXP\$1SUBSTR ignora as primeiras correspondências de *occurrence* -1. O padrão é 1. Se a *ocorrência* for menor que 1 ou maior que o número de caracteres em *source\$1string*, a pesquisa será ignorada e o resultado será vazio. *parameters* Uma ou mais literais de sequências que indicam como a função corresponde o padrão. Os valores possíveis são os seguintes: + c – Executa a correspondência diferenciando maiúsculas e minúsculas. O padrão é usar a correspondência diferenciando maiúsculas e minúsculas. + i – Executa a correspondência sem diferenciar maiúsculas de minúsculas. + e – Extrai uma subsequência usando uma subexpressão. Se o *padrão* incluir uma subexpressão, REGEXP\$1SUBSTR corresponderá uma subsequência usando a primeira subexpressão em *padrão*. Uma subexpressão é uma expressão dentro do padrão que está entre parênteses. Por exemplo, para o padrão `'This is a (\\w+)'` faz correspondência com a primeira expressão com a string `'This is a '` seguida por uma palavra. Em vez de retornar o *padrão*, REGEXP\$1SUBSTR com o parâmetro `e` retorna somente a string dentro da subexpressão. REGEXP\$1SUBSTR considera apenas a primeira subexpressão. As subexpressões adicionais são ignoradas. Se o padrão não tiver uma subexpressão, REGEXP\$1SUBSTR ignorará o parâmetro 'e'. + p — Interpreta o padrão com o dialeto de expressão regular compatível com Perl (PCRE - Perl Compatible Regular Expression). Para ter mais informações sobre PCRE, consulte [Perl Compatible Regular Expressions](https://en.wikipedia.org/wiki/Perl_Compatible_Regular_Expressions) na Wikipédia. ## Tipo de retorno VARCHAR ## Exemplos O seguinte exemplo retorna a porção de um endereço de e-mail entre o caractere @ e a extensão de domínio. Os dados de `users` consultados são dos dados de amostra do Amazon Redshift. Para obter mais informações, consulte [Banco de dados de exemplo](c_sampledb.md). ``` SELECT email, regexp_substr(email,'@[^.]*') FROM users ORDER BY userid LIMIT 4; email | regexp_substr -----------------------------------------------+-------------------------- Suspendisse.tristique@nonnisiAenean.edu | @nonnisiAenean amet.faucibus.ut@condimentumegetvolutpat.ca | @condimentumegetvolutpat sed@lacusUtnec.ca | @lacusUtnec Cum@accumsan.com | @accumsan ``` O exemplo a seguir retorna a porção da entrada correspondente à primeira ocorrência da string `FOX` com a correspondência sem diferenciar letras maiúsculas de minúsculas. ``` SELECT regexp_substr('the fox', 'FOX', 1, 1, 'i'); regexp_substr --------------- fox ``` O exemplo a seguir retorna a porção da entrada correspondente à segunda ocorrência da string `FOX` usando a correspondência que não diferencia letras maiúsculas de minúsculas. O resultado é vazio (não nulo, tamanho 0) porque não há uma segunda ocorrência. ``` SELECT regexp_substr('the fox', 'FOX', 1, 2, 'i'); regexp_substr --------------- ``` O exemplo a seguir retorna a primeira parte da entrada que começa com letras minúsculas. Isso é funcionalmente idêntico à mesma instrução SELECT sem o parâmetro `c`. ``` SELECT regexp_substr('THE SECRET CODE IS THE LOWERCASE PART OF 1931abc0EZ.', '[a-z]+', 1, 1, 'c'); regexp_substr --------------- abc ``` O exemplo a seguir usa um padrão escrito no dialeto PCRE para localizar palavras contendo pelo menos um número e uma letra minúscula. Ele usa o operador `?=`, que tem uma conotação específica look-ahead em PCRE. Este exemplo retorna a parte da entrada correspondente à segunda palavra. ``` SELECT regexp_substr('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 2, 'p'); regexp_substr --------------- a1234 ``` O exemplo a seguir usa um padrão escrito no dialeto PCRE para localizar palavras contendo pelo menos um número e uma letra minúscula. Ele usa o operador `?=`, que tem uma conotação específica look-ahead em PCRE. Este exemplo retorna a parte da entrada correspondente à segunda palavra, mas difere do exemplo anterior na medida em que usa a correspondência sem diferenciar maiúsculas de minúsculas. ``` SELECT regexp_substr('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 2, 'ip'); regexp_substr --------------- A1234 ``` O exemplo a seguir usa uma subexpressão para encontrar a segunda string correspondente ao padrão `'this is a (\\w+)'` usando a correspondência que não diferencia letras maiúsculas de minúsculas. Ele retorna a subexpressão dentro dos parênteses. ``` SELECT regexp_substr( 'This is a cat, this is a dog. This is a mouse.', 'this is a (\\w+)', 1, 2, 'ie'); regexp_substr --------------- dog ```