string LIKE pattern [ESCAPE escape-character]
string NOT LIKE pattern [ESCAPE escape-character]

A expressão LIKE retorna verdade se a string (cadeia de caracteres) corresponder ao pattern (padrão) fornecido. (Como esperado, a expressão NOT LIKE retorna falso se LIKE retornar verdade, e vice-versa. Uma expressão equivalente é NOT (string LIKE pattern).)

Se pattern não contiver sinais de porcentagem ou sublinhados, então o padrão representa apenas a própria cadeia de caracteres; Neste caso, LIKE funciona como o operador de igualdade. Um sublinhado (_) em pattern representa (corresponde a) qualquer um único caractere; o sinal de porcentagem (%) corresponde a qualquer sequência de zero ou mais caracteres.

Alguns exemplos:

'abc' LIKE 'abc'    → true
'abc' LIKE 'a%'     → true
'abc' LIKE '_b_'    → true
'abc' LIKE 'c'      → false

A correspondência de padrões LIKE oferece suporte a sequências de ordenação (collations) não determinísticas. (veja a Seção 23.2.2.4), tais como sequências de ordenação que não diferenciam letras maiúsculas de minúsculas ou sequências de ordenação que, por exemplo, ignoram a pontuação. Assim, com uma sequência de ordenação que não diferencia letras maiúsculas de minúsculas, seria possível ter:

'AbC' LIKE 'abc' COLLATE case_insensitive    → true
'AbC' LIKE 'a%' COLLATE case_insensitive     → true

Com sequências de ordenação que ignoram certos caracteres ou, em geral, que consideram cadeias de caracteres de comprimentos diferentes como iguais, a semântica pode se tornar um pouco mais complexa. Considere estes exemplos:

'.foo.' LIKE 'foo' COLLATE ign_punct    → true
'.foo.' LIKE 'f_o' COLLATE ign_punct    → true
'.foo.' LIKE '_oo' COLLATE ign_punct    → false

O funcionamento da correspondência consiste em particionar o padrão em sequências de caracteres curinga e sequências sem curinga (os curingas sendo _ e %). Por exemplo, o padrão f_o é particionado em f, _, o, o padrão _oo é particionado em _, oo. A cadeia de caracteres de entrada corresponde ao padrão se puder ser particionada de forma que os caracteres curinga correspondam a um caractere ou a qualquer número de caracteres, respectivamente, e as partições sem curinga sejam iguais sob a sequência de ordenação aplicável. Portanto, por exemplo, '.foo.' LIKE 'f_o' COLLATE ign_punct é verdade porque é possível particionar .foo. em .f, o, o. e então '.f' = 'f' COLLATE ign_punct, 'o' corresponde ao caractere curinga _, e 'o.' = 'o' COLLATE ign_punct. Mas '.foo.' LIKE '_oo' COLLATE ign_punct é falso porque .foo. não pode ser particionado de forma que o primeiro caractere seja qualquer caractere e o restante da cadeia de caracteres seja igual a oo. (Note que o caractere curinga de um único caractere sempre corresponde exatamente a um caractere, independentemente da sequência de ordenação. Portanto, neste exemplo _ corresponderia ao ., mas o restante da cadeia de caracteres de entrada não corresponderia ao restante do padrão.)

A correspondência de padrões LIKE sempre abrange toda a cadeia de caracteres. Portanto, se for desejado encontrar uma sequência em qualquer ponto de uma cadeia de caracteres, o padrão deve começar e terminar por um sinal de porcentagem.

Para corresponder a um caractere de sublinhado ou a um sinal de porcentagem sem corresponder a outros caracteres, o respectivo caractere em pattern deve ser precedido pelo caractere de escape. O caractere de escape padrão é a contrabarra, mas pode ser escolhido um caractere diferente usando a cláusula ESCAPE. Para corresponder ao próprio caractere de escape, devem ser escritos dois caracteres de escape.

Também é possível selecionar nenhum caractere de escape escrevendo ESCAPE ''. Isto desativa efetivamente o mecanismo de escape, tornando impossível desativar o significado especial dos caracteres de sublinhado e porcentagem no padrão.

De acordo com o padrão SQL, omitir `ESCAPE` significa não haver caractere de escape (em vez de tornar a contrabarra o padrão), e um valor ESCAPE de comprimento zero não é permitido. O comportamento do PostgreSQL neste aspecto é, portanto, ligeiramente fora do padrão.

Pode ser usada a palavra-chave ILIKE em vez de LIKE para tornar a correspondência não sensível a letras maiúsculas e minúsculas, de acordo com a localidade ativa. (Mas isto não oferece suporte a sequências de ordenação não determinísticas.) Isto não está no padrão SQL, sendo uma extensão do PostgreSQL.

O operador ~~ é equivalente a LIKE, e ~~* corresponde a ILIKE. Também existem os operadores !~~ e !~~* que representam NOT LIKE e NOT ILIKE, respectivamente. Todos estes operadores são específicos do PostgreSQL. Podem ser encontrados estes nomes de operadores na saída do comando EXPLAIN e em locais semelhantes, uma vez que o analisador sintático traduz efetivamente LIKE e outros operadores para estes operadores.

As frases LIKE, ILIKE, NOT LIKE e NOT ILIKE são geralmente tratadas como operadores na sintaxe do PostgreSQL; por exemplo, podem ser usadas ​​em construções expressão operador ANY ( subconsulta), embora a cláusula ESCAPE não possa ser incluída neste caso. Em alguns casos obscuros, pode ser necessário usar os nomes dos operadores subjacentes.

Veja também o operador começa-por ^@ e a função starts_with() correspondente, que são úteis nos casos em que basta encontrar o início de uma cadeia de caracteres.

string SIMILAR TO pattern [ESCAPE escape-character]
string NOT SIMILAR TO pattern [ESCAPE escape-character]

O operador SIMILAR TO retorna verdade ou falso dependendo se o padrão corresponde à cadeia de caracteres fornecida. É semelhante ao LIKE, exceto por interpretar o padrão usando a definição de expressão regular do SQL. As expressões regulares SQL são um cruzamento curioso entre a notação do LIKE e a notação de expressão regular comum (POSIX).

Como o LIKE, o operador SIMILAR TO é bem-sucedido apenas se o padrão corresponder a toda cadeia de caracteres; isto é diferente do comportamento comum de expressão regular, onde o padrão pode corresponder a qualquer parte da cadeia de caracteres. Também como o LIKE, SIMILAR TO usa _ e % como caracteres curinga denotando qualquer um único caractere e qualquer cadeia de caracteres, respectivamente (são comparáveis ao . e .* nas expressões regulares POSIX).

Além destas facilidades pegas emprestadas do LIKE, SIMILAR TO aceita estes meta caracteres de correspondência de padrões pegos emprestados das expressões regulares POSIX: ^[61]

Note que o ponto (.) não é um meta caractere para SIMILAR TO.

Assim como no LIKE, uma contrabarra desativa o significado especial de qualquer um desses meta caracteres. Pode ser especificado um caractere de escape diferente usando ESCAPE, ou a capacidade de escape pode ser desativada escrevendo ESCAPE ''.

De acordo com o padrão SQL, omitir `ESCAPE` significa não haver caractere de escape (em vez de tornar a contrabarra o padrão), e um valor ESCAPE de comprimento zero não é permitido. O comportamento do PostgreSQL neste aspecto é, portanto, ligeiramente fora do padrão.

Outra extensão fora do padrão é que o caractere de escape seguido por uma letra ou dígito fornece acesso às sequências de escape definidas para expressões regulares POSIX; veja a Tabela 9.20, a Tabela 9.21 e a Tabela 9.22 abaixo.

Alguns exemplos:

'abc' SIMILAR TO 'abc'          → true
'abc' SIMILAR TO 'a'            → false
'abc' SIMILAR TO '%(b|d)%'      → true
'abc' SIMILAR TO '(b|c)%'       → false
'-abc-' SIMILAR TO '%\mabc\M%'  → true
'xabcy' SIMILAR TO '%\mabc\M%'  → false

A função substring com três parâmetros permite a extração de uma sub-cadeia de caracteres que corresponde a um padrão de expressão regular SQL. A função pode ser escrita segundo a sintaxe SQL padrão:

substring(string similar pattern escape escape-character)

ou usando a agora obsoleta sintaxe do SQL:1999:

substring(string from pattern for escape-character)

ou como uma função comum de três argumentos:

substring(string, pattern, escape-character)

Assim como acontece com SIMILAR TO, o padrão especificado deve corresponder a toda cadeia de caracteres, caso contrário a função falha e retorna nulo. Para indicar a parte do padrão para a qual a sub-cadeia de caracteres correspondente é de interesse, o padrão deve conter duas ocorrências do caractere de escape seguido por aspas ("). O texto que corresponde à parte do padrão entre estes separadores é retornado quando a correspondência é bem-sucedida.

Na verdade, os separadores escape-aspas dividem o padrão da função substring em três expressões regulares independentes; por exemplo, uma barra vertical (|) em qualquer uma das três seções afeta apenas esta seção. Além disso, a primeira e a terceira destas expressões regulares são definidas para corresponder a menor quantidade possível de texto, não a maior, quando houver qualquer ambiguidade sobre o quanto da cadeia de caracteres corresponde a qual padrão. (Na linguagem POSIX, a primeira e a terceira expressões regulares são forçadas a não serem vorazes - non-greedy.)

Como extensão ao padrão SQL, o PostgreSQL permite a existência de apenas um separador escape-aspas, caso onde a terceira expressão regular é considerada vazia; ou nenhum separador, caso onde a primeira e a terceira expressões regulares são consideradas vazias.

Alguns exemplos com #" delimitando a cadeia de caracteres a ser retornada:

substring('foobar' similar '%#"o_b#"%' escape '#')   → oob
substring('foobar' similar '#"o_b#"%' escape '#')    → NULL

A Tabela 9.16 lista os operadores disponíveis para correspondência de padrões usando expressões regulares POSIX ^[62].

As expressões regulares POSIX fornecem um meio mais poderoso para correspondência de padrões que os operadores LIKE e SIMILAR TO. Muitas ferramentas Unix, como egrep, sed e awk usam uma linguagem de correspondência de padrões semelhante à descrita aqui.

Uma expressão regular é uma sequência de caracteres que é uma definição abreviada de um conjunto de caracteres (um conjunto regular). Diz-se que uma cadeia de caracteres corresponde a uma expressão regular, se for membro do conjunto regular descrito pela expressão regular. Assim como no LIKE, os caracteres do padrão correspondem exatamente aos caracteres da cadeia de caracteres, a menos que sejam caracteres especiais na linguagem de expressão regular — porém, expressões regulares usam caracteres especiais diferentes do LIKE. Ao contrário dos padrões do LIKE, uma expressão regular pode corresponder a qualquer lugar dentro da cadeia de caracteres, a menos que a expressão regular seja explicitamente ancorada no início ou no fim da cadeia de caracteres.

Alguns exemplos:

'abcd' ~ 'bc'     → true
'abcd' ~ 'a.c'    → true  — o ponto corresponde a qualquer caractere
'abcd' ~ 'a.*d'   → true  — * repete o elemento de padrão anterior
'abcd' ~ '(b|x)'  → true  — | significa OR, para o grupo entre parênteses
'abcd' ~ '^a'     → true  — ^ ancora no início da cadeia de caracteres
'abcd' ~ '^(b|c)' → false — coresponderia, exceto pela ancoragem

A linguagem de padrões POSIX está descrita com muito mais detalhes abaixo. ^[63]

A função substring com dois parâmetros, substring(string from pattern), permite a extração de uma sub-cadeia de caracteres que corresponde a um padrão de expressão regular POSIX. A função retorna nulo caso não haja correspondência, caso contrário retorna a primeira parte do texto que corresponde ao padrão. Mas se o padrão contiver parênteses, retorna a parte do texto que corresponde à primeira subexpressão entre parênteses (aquela cujo parêntese esquerdo vem primeiro). Podem ser colocados parênteses ao redor de toda a expressão, se for desejado usar parênteses dentro da expressão sem acionar esta exceção. Se for necessário usar parênteses no padrão antes da subexpressão que se deseja extrair, então consulte os parênteses sem captura descritos abaixo.

Alguns exemplos:

substring('foobar' from 'o.b')     → oob
substring('foobar' from 'o(.)b')   → o

A função regexp_count conta o número de ocorrências de uma expressão regular POSIX em uma cadeia de caracteres. Possui a sintaxe regexp_count(string, pattern [, start [, flags ]]). pattern é procurado na string, normalmente a partir do início da cadeia de caracteres, mas se for fornecido o parâmetro start, então irá começar a partir deste índice de caractere. O parâmetro flags é uma cadeia de caracteres de texto opcional contendo zero ou mais sinalizadores de uma única letra que alteram o comportamento da função. Por exemplo, incluir i em flags especifica a correspondência que não diferencia letras maiúsculas de minúsculas. Os sinalizadores aceitos estão descritos na Tabela 9.24.

Alguns exemplos:

regexp_count('ABCABCAXYaxy', 'A.')          → 3
regexp_count('ABCABCAXYaxy', 'A.', 1, 'i')  → 4

A função regexp_instr retorna a posição inicial ou final da N-ésima correspondência de um padrão de expressão regular POSIX em uma cadeia de caracteres, ou zero se não houver tal correspondência. Possui a sintaxe regexp_instr(string, pattern [, start [, N [, endoption [, flags [, subexpr ]]]]]). pattern é procurado na string, normalmente a partir do início da cadeia de caracteres, mas se for fornecido o parâmetro start, então irá começar a partir deste índice de caractere. Se for especificado N será localizada a N-ésima correspondência do padrão, caso contrário será localizada a primeira correspondência. Se o parâmetro endoption for omitido ou especificado como zero, a função irá retornar a posição do primeiro caractere da correspondência. Caso contrário, endoption deverá ser um, e a função irá retornar a posição do caractere seguinte à correspondência. O parâmetro flags é uma cadeia de caracteres de texto opcional contendo zero ou mais sinalizadores de uma única letra que alteram o comportamento da função. Os sinalizadores aceitos estão descritos na Tabela 9.24. Para um padrão que contenha subexpressões entre parênteses, subexpr é um número inteiro que indica qual subexpressão é de interesse: o resultado identifica a posição da sub-cadeia de caracteres que corresponde àquela subexpressão. As subexpressões são numeradas na ordem dos parênteses iniciais. Quando subexpr é omitido ou é zero, o resultado identifica a posição de toda a correspondência, independentemente das subexpressões entre parênteses.

Alguns exemplos:

regexp_instr('number of your street, town zip, FR',
             '[^,]+', 1, 2)
    → 23
regexp_instr(string=>'ABCDEFGHI',
             pattern=>'(c..)(...)',
             start=>1, "N"=>1,
             endoption=>0,
             flags=>'i',
             subexpr=>2)
    → 6

A função regexp_like verifica se ocorre alguma correspondência com um padrão de expressão regular POSIX em uma cadeia de caracteres, retornando um valor booleano verdade ou falso. Possui a sintaxe regexp_like(string, pattern [, flags ]). O parâmetro flags é uma cadeia de caracteres de texto opcional contendo zero ou mais sinalizadores de uma única letra que alteram o comportamento da função. Os sinalizadores aceitos estão descritos na Tabela 9.24. Esta função irá produzir os mesmos resultados que o operador ~ se não for especificado nenhum sinalizador. Se for especificado apenas o sinalizador i, esta função irá produzir os mesmos resultados que o operador ~*.

Alguns exemplos:

regexp_like('Hello World', 'world')       → false
regexp_like('Hello World', 'world', 'i')  → true

A função regexp_match retorna uma matriz de texto contendo as sub-cadeias de caracteres capturadas, resultantes da primeira correspondência entre um padrão de expressão regular POSIX e uma cadeia de caracteres. Possui a sintaxe regexp_match(string, pattern [, flags ]). Se não houver correspondência, o resultado será NULL. Se for encontrada uma correspondência e o pattern não contiver subexpressões entre parênteses, o resultado será uma matriz de texto de elemento único contendo a sub-cadeia de caracteres que corresponde a todo o padrão. Se for encontrada uma correspondência e o pattern contiver subexpressões entre parênteses, o resultado será uma matriz de texto cujo n-ésimo elemento será a sub-cadeia de caracteres que corresponde à n-ésima subexpressão entre parênteses de pattern (sem contar os parênteses “não capturáveis”; veja os detalhes abaixo). O parâmetro flags é uma cadeia de caracteres de texto opcional contendo zero ou mais sinalizadores de uma única letra que alteram o comportamento da função. Os sinalizadores com suporte (exceto o g) estão descritos na Tabela 9.24.

Alguns exemplos:

SELECT regexp_match('foobarbequebaz', 'bar.*que');

 regexp_match
--------------
 {barbeque}
(1 linha)

SELECT regexp_match('foobarbequebaz', '(bar)(beque)');

 regexp_match
--------------
 {bar,beque}
(1 linha)

SELECT (regexp_match('foobarbequebaz', 'bar.*que'))[1];

 regexp_match
--------------
 barbeque
(1 linha)

A função regexp_matches retorna um conjunto de matrizes de texto contendo as sub-cadeias de caracteres capturadas resultantes da correspondência do padrão da expressão regular POSIX com a cadeia de caracteres. Possui a mesma sintaxe da função regexp_match. Esta função não retorna nenhuma linha caso não haja correspondência, retorna uma linha se houver correspondência e o sinalizador g não for especificado, ou retorna N linhas se houver N correspondências e o sinalizador g for especificado. Cada linha retornada é uma matriz de texto contendo toda a sub-cadeia de caracteres que corresponde ao padrão, ou as sub-cadeias de caracteres que correspondem às subexpressões entre parênteses do pattern, exatamente como descrito acima para a função regexp_match. A função regexp_matches aceita todos os sinalizadores descritos na Tabela 9.24, mais o sinalizador g, que a sinaliza o retorno de todas as correspondências, e não apenas a primeira.

Alguns exemplos:

SELECT regexp_matches('foo', 'not there');

 regexp_matches
----------------
(0 linha)

SELECT regexp_matches('foobarbequebazilbarfbonk', '(b[^b]+)(b[^b]+)', 'g');

 regexp_matches
----------------
 {bar,beque}
 {bazil,barf}
(2 linhas)

SELECT col1, (SELECT regexp_matches(col2, '(bar)(beque)')) FROM tab;

A função regexp_replace fornece a substituição por um novo texto para sub-cadeias de caracteres que correspondem a padrões de expressão regular POSIX. Possui a sintaxe regexp_replace(string, pattern, replacement [, flags ]) ou regexp_replace(string, pattern, replacement, start [, N [, flags ]]). A cadeia de caracteres de origem (string) é retornada sem alterações quando não há correspondência com o padrão (pattern). Caso haja uma correspondência, a cadeia de caracteres string será retornada com a cadeia de caracteres replacement substituída pela sub-cadeia de caracteres correspondente. A cadeia de caracteres replacement pode conter \n, onde n varia de 1 a 9, para indicar que a sub-cadeia de caracteres de origem que corresponde a n-ésima subexpressão entre parênteses do padrão deve ser inserida, e pode conter \& para indicar que deve ser inserida a sub-cadeia de caracteres que corresponde a todo o padrão. Deve ser escrito \\ se for necessário inserir uma contrabarra no no texto de substituição. pattern é procurado na string, normalmente a partir do início da cadeia de caracteres, mas se for fornecido o parâmetro start, então irá começar a partir deste índice de caractere. Por padrão, apenas a primeira correspondência do padrão é substituída. Se N for especificado e for maior que zero, então será substituída a N-ésima correspondência do padrão. Se o sinalizador g for fornecido, ou se N for especificado e for zero, todas as correspondências na posição start ou após ela serão substituídas. (O sinalizador g é ignorado quando N é especificado.) O parâmetro flags é uma cadeia de caracteres de texto opcional contendo zero ou mais sinalizadores de uma única letra que alteram o comportamento da função. Os sinalizadores aceitos (exceto o g) estão descritos na Tabela 9.24.

Alguns exemplos:

regexp_replace('foobarbaz', 'b..', 'X')
    → fooXbaz
regexp_replace('foobarbaz', 'b..', 'X', 'g')
    → fooXX
regexp_replace('foobarbaz', 'b(..)', 'X\1Y', 'g')
    → fooXarYXazY
regexp_replace('A PostgreSQL function', 'a|e|i|o|u', 'X', 1, 0, 'i')
    → X PXstgrXSQL fXnctXXn
regexp_replace(string=>'A PostgreSQL function',
               pattern=>'a|e|i|o|u',
               replacement=>'X',
               start=>1,
               "N"=>3,
               flags=>'i')
    → A PostgrXSQL function

A função regexp_split_to_table divide uma cadeia de caracteres usando um padrão de expressão regular POSIX como delimitador. Possui a sintaxe regexp_split_to_table( string, pattern [, flags ]). Se não houver correspondência com o pattern, a função retorna a string. Se houver pelo menos uma correspondência, para cada correspondência a função retorna o texto do final da última correspondência (ou do início da cadeia de caracteres) até o início da correspondência. Quando não há mais correspondências, a função retorna o texto do final da última correspondência até o final da cadeia de caracteres. O parâmetro flags é uma cadeia de caracteres de texto opcional contendo zero ou mais sinalizadores de uma única letra que alteram o comportamento da função. A função regexp_split_to_table aceita os sinalizadores descritos na Tabela 9.24.

A função regexp_split_to_array se comporta da mesma maneira que a função regexp_split_to_table, exceto pela função regexp_split_to_array retornar seus resultados como uma matriz de text. Possui a sintaxe regexp_split_to_array( string, pattern [, flags ]). Os parâmetros são os mesmos da função regexp_split_to_table.

Alguns exemplos:

SELECT foo
    FROM regexp_split_to_table(
             'the quick brown fox jumps over the lazy dog',
             '\s+') AS foo;

  foo
-------
 the
 quick
 brown
 fox
 jumps
 over
 the
 lazy
 dog
(9 linhas)

SELECT regexp_split_to_array(
             'the quick brown fox jumps over the lazy dog',
             '\s+');

             regexp_split_to_array
-----------------------------------------------
 {the,quick,brown,fox,jumps,over,the,lazy,dog}
(1 linha)

SELECT foo
    FROM regexp_split_to_table(
             'the quick brown fox',
             '\s*') AS foo;

 foo
-----
 t
 h
 e
 q
 u
 i
 c
 k
 b
 r
 o
 w
 n
 f
 o
 x
(16 linhas)

Como o último exemplo demonstra, as funções de divisão de expressões regulares ignoram correspondências de comprimento zero que ocorrem no início ou no final da cadeia de caracteres ou imediatamente após uma correspondência anterior. Isto contraria a definição estrita de correspondência de expressões regulares implementada pelas outras funções de expressões regulares, mas geralmente é o comportamento mais conveniente na prática. Outros sistemas de software, como o Perl, usam definições semelhantes.

A função regexp_substr retorna a sub-cadeia de caracteres que corresponde a um padrão de expressão regular POSIX, ou NULL se não houver correspondência. Possui a sintaxe regexp_substr(string, pattern [, start [, N [, flags [, subexpr ]]]]). pattern é procurado na string, normalmente a partir do início da cadeia de caracteres, mas se for fornecido o parâmetro start, então irá começar a partir deste índice de caractere. Se N for especificado, então será retornada a N-ésima correspondência do padrão, caso contrário, será retornada a primeira correspondência. O parâmetro flags é uma cadeia de caracteres de texto opcional contendo zero ou mais sinalizadores de uma única letra que alteram o comportamento da função. Os sinalizadores aceitos (exceto o g) estão descritos na Tabela 9.24. Para um padrão que contenha subexpressões entre parênteses, subexpr é um número inteiro indicando qual subexpressão é de interesse: o resultado é a sub-cadeia de caracteres que corresponde àquela subexpressão. As subexpressões são numeradas na ordem dos parênteses iniciais. Quando subexpr é omitido ou zero, o resultado é a correspondência completa, independentemente das subexpressões entre parênteses.

Alguns exemplos:

regexp_substr('number of your street, town zip, FR', '[^,]+', 1, 2)
    → town zip
regexp_substr('ABCDEFGHI', '(c..)(...)', 1, 1, 'i', 2)
    → FGH

SELECT regexp_substr('!@#123_xyz$%456', '[[:word:]]+');

 regexp_substr
---------------
 123_xyz
(1 linha)

SELECT regexp_substr('!@#123_xyz$%456', '[[:alpha:]]+');

 regexp_substr
---------------
 xyz
(1 linha)

SELECT SUBSTRING('XY1234Z', 'Y*([0-9]{1,3})');
→ 123
SELECT SUBSTRING('XY1234Z', 'Y*?([0-9]{1,3})');
→ 1

SELECT regexp_match('abc01234xyz', '(.*)(\d+)(.*)');
→ {abc0123,4,xyz}

SELECT regexp_match('abc01234xyz', '(.*?)(\d+)(.*)');
→ {abc,0,""}

SELECT regexp_match('abc01234xyz', '(?:(.*?)(\d+)(.*)){1,1}');
→ {abc,01234,xyz}