PostgreSQL - Função String
As funções de string do PostgreSQL são usadas principalmente para manipulação de string. A tabela a seguir detalha as funções de string importantes -
| S. No. | Nome e Descrição |
|---|---|
| 1 | ASCII () Retorna o valor numérico do caractere mais à esquerda |
| 2 | BIT_LENGTH () Retorna o comprimento do argumento em bits |
| 3 | CHAR_LENGTH () Retorna o número de caracteres no argumento |
| 4 | CHARACTER_LENGTH () Um sinônimo para CHAR_LENGTH () |
| 5 | CONCAT_WS () Retorna concatenar com separador |
| 6 | CONCAT () Retorna string concatenada |
| 7 | LCASE () Sinônimo de LOWER () |
| 8 | ESQUERDA() Retorna o número mais à esquerda de caracteres conforme especificado |
| 9 | COMPRIMENTO() Retorna o comprimento de uma string em bytes |
| 10 | MAIS BAIXO() Retorna o argumento em minúsculas |
| 11 | LPAD () Retorna o argumento da string, preenchido à esquerda com a string especificada |
| 12 | LTRIM () Remove espaços principais |
| 13 | MID () Retorna uma substring começando na posição especificada |
| 14 | POSIÇÃO() Um sinônimo para LOCATE () |
| 15 | CITAR() Escapa do argumento para uso em uma instrução SQL |
| 16 | REGEXP Correspondência de padrões usando expressões regulares |
| 17 | REPETIR() Repete uma string o número especificado de vezes |
| 18 | SUBSTITUIR() Substitui as ocorrências de uma string especificada |
| 19 | REVERTER() Inverta os caracteres em uma string |
| 20 | DIREITO() Retorna o número especificado de caracteres mais à direita |
| 21 | RPAD () Anexa a string o número especificado de vezes |
| 22 | RTRIM () Remove espaços à direita |
| 24 | SUBSTRING (), SUBSTR () Retorna a substring conforme especificado |
| 25 | APARAR() Remove espaços à esquerda e à direita |
| 26 | UCASE () Sinônimo de UPPER () |
| 27 | SUPERIOR() Converte para maiúsculas |
ASCII (str)
Retorna o valor numérico do caractere mais à esquerda da string str. Retorna 0 se str for uma string vazia. Retorna NULL se str for NULL. ASCII () funciona para caracteres com valores numéricos de 0 a 255.
testdb=# SELECT ASCII('2');
+---------------------------------------------------------+
| ASCII('2') |
+---------------------------------------------------------+
| 50 |
+---------------------------------------------------------+
1 row in set (0.00 sec)
testdb=# SELECT ASCII('dx');
+---------------------------------------------------------+
| ASCII('dx') |
+---------------------------------------------------------+
| 100 |
+---------------------------------------------------------+
1 row in set (0.00 sec)BIT_LENGTH (str)
Retorna o comprimento da string str em bits.
testdb=# SELECT BIT_LENGTH('text');
+---------------------------------------------------------+
| BIT_LENGTH('text') |
+---------------------------------------------------------+
| 32 |
+---------------------------------------------------------+
1 row in set (0.00 sec)CHAR_LENGTH (str)
Retorna o comprimento da string str, medido em caracteres. Um caractere multibyte conta como um único caractere. Isso significa que para uma string contendo cinco caracteres de dois bytes, LENGTH () retorna 10, enquanto CHAR_LENGTH () retorna 5.
testdb=# SELECT CHAR_LENGTH('text');
+---------------------------------------------------------+
| CHAR_LENGTH('text') |
+---------------------------------------------------------+
| 4 |
+---------------------------------------------------------+
1 row in set (0.00 sec)CHARACTER_LENGTH (str)
CHARACTER_LENGTH () é um sinônimo para CHAR_LENGTH ().
CONCAT (str1, str2, ...)
Retorna a string que resulta da concatenação dos argumentos. Pode ter um ou mais argumentos. Se todos os argumentos forem strings não binárias, o resultado será uma string não binária. Se os argumentos incluem cadeias binárias, o resultado é uma cadeia binária. Um argumento numérico é convertido em sua forma de string binária equivalente; se você quiser evitar isso, você pode usar uma conversão de tipo explícito, como neste exemplo -
testdb=# SELECT CONCAT('My', 'S', 'QL');
+---------------------------------------------------------+
| CONCAT('My', 'S', 'QL') |
+---------------------------------------------------------+
| MySQL |
+---------------------------------------------------------+
1 row in set (0.00 sec)CONCAT_WS (separador, str1, str2, ...)
CONCAT_WS () significa Concatenate With Separator e é uma forma especial de CONCAT (). O primeiro argumento é o separador para o resto dos argumentos. O separador é adicionado entre as strings a serem concatenadas. O separador pode ser uma string, assim como o resto dos argumentos. Se o separador for NULL, o resultado será NULL.
testdb=# SELECT CONCAT_WS(',','First name','Last Name' );
+---------------------------------------------------------+
| CONCAT_WS(',','First name','Last Name' ) |
+---------------------------------------------------------+
| First name, Last Name |
+---------------------------------------------------------+
1 row in set (0.00 sec)LCASE (str)
LCASE () é um sinônimo de LOWER ().
LEFT (str, len)
Retorna os caracteres len mais à esquerda da string str ou NULL se algum argumento for NULL.
testdb=# SELECT LEFT('foobarbar', 5);
+---------------------------------------------------------+
| LEFT('foobarbar', 5) |
+---------------------------------------------------------+
| fooba |
+---------------------------------------------------------+
1 row in set (0.00 sec)LENGTH (str)
Retorna o comprimento da string str, medido em bytes. Um caractere multibyte conta como bytes múltiplos. Isso significa que para uma string contendo cinco caracteres de dois bytes, LENGTH () retorna 10, enquanto CHAR_LENGTH () retorna 5.
testdb=# SELECT LENGTH('text');
+---------------------------------------------------------+
| LENGTH('text') |
+---------------------------------------------------------+
| 4 |
+---------------------------------------------------------+
1 row in set (0.00 sec)LOWER (str)
Retorna a string str com todos os caracteres alterados para minúsculas de acordo com o mapeamento do conjunto de caracteres atual.
testdb=# SELECT LOWER('QUADRATICALLY');
+---------------------------------------------------------+
| LOWER('QUADRATICALLY') |
+---------------------------------------------------------+
| quadratically |
+---------------------------------------------------------+
1 row in set (0.00 sec)LPAD (str, len, padstr)
Retorna a string str, preenchida à esquerda com a string padstr até um comprimento de caracteres len. Se str for maior do que len, o valor de retorno será reduzido para len caracteres.
testdb=# SELECT LPAD('hi',4,'??');
+---------------------------------------------------------+
| LPAD('hi',4,'??') |
+---------------------------------------------------------+
| ??hi |
+---------------------------------------------------------+
1 row in set (0.00 sec)LTRIM (str)
Retorna a string str com os caracteres de espaço iniciais removidos.
testdb=# SELECT LTRIM(' barbar');
+---------------------------------------------------------+
| LTRIM(' barbar') |
+---------------------------------------------------------+
| barbar |
+---------------------------------------------------------+
1 row in set (0.00 sec)MID (str, pos, len)
MID (str, pos, len) é sinônimo de SUBSTRING (str, pos, len).
POSIÇÃO (substr IN str)
POSITION (substr IN str) é um sinônimo para LOCATE (substr, str).
QUOTE_IDENT (string text), QUOTE_LITERAL (string text), QUOTE_LITERAL (valor qualquer elemento), QUOTE_NULLABLE (valor qualquer elemento)
Todas essas funções retornam a string fornecida adequadamente entre aspas para ser usada como um identificador em uma string de instrução SQL. Na função QUOTE_IDENT, as cotações são adicionadas apenas se necessário. Na função QUOTE_LITERAL, aspas simples e barras invertidas incorporadas são devidamente duplicadas. Se um valor for passado, force o valor fornecido para texto e, em seguida, coloque-o como literal. A função QUOTE_NULLABLE força o valor fornecido para texto e, a seguir, cita-o como literal; ou, se o argumento for nulo, retorna NULL.
A seguir estão os exemplos para todas essas funções -
testdb=# SELECT QUOTE_IDENT('Foo bar');
quote_ident
-------------
"Foo bar"
(1 row)
testdb=# SELECT QUOTE_LITERAL(E'O\'Reilly');
quote_literal
---------------
'O''Reilly'
(1 row)
testdb=# SELECT QUOTE_LITERAL(42.5);
quote_literal
---------------
'42.5'
(1 row)
testdb=# SELECT QUOTE_NULLABLE(42.5);
quote_nullable
----------------
'42.5'
(1 row)padrão expr REGEXP
A função REGEXP_MATCHES (string text, pattern text [, flags text]) executa uma correspondência de padrão de expr contra o padrão. Retorna 1 se expr corresponder a pat; caso contrário, retorna 0. Se expr ou pat for NULL, o resultado será NULL. REGEXP_MATCHES não faz distinção entre maiúsculas e minúsculas, exceto quando usado com strings binárias.
A função REGEXP_REPLACE (texto de string, texto de padrão, texto de substituição [, texto de sinalizadores]) substitui substring (s) correspondendo a uma expressão regular POSIX.
REGEXP_SPLIT_TO_ARRAY (texto de string, texto de padrão [, texto de sinalizadores]), Divida a string usando uma expressão regular POSIX como delimitador.
REGEXP_SPLIT_TO_TABLE (texto de string, texto de padrão [, texto de sinalizadores]), divide a string usando uma expressão regular POSIX como delimitador.
A seguir estão os exemplos para todas essas funções -
testdb=# SELECT REGEXP_MATCHES('ABCDEF','A%C%%');
regexp_matches
----------------
(0 rows)
testdb=# SELECT REGEXP_REPLACE('Thomas', '.[mN]a.', 'M');
regexp_replace
----------------
ThM
(1 row)
testdb=# SELECT REGEXP_SPLIT_TO_ARRAY('hello world', E'\\s+');
regexp_split_to_array
-----------------------
{hello,world}
(1 row)
testdb=# SELECT REGEXP_SPLIT_TO_TABLE('hello world', E'\\s+');
regexp_split_to_table
-----------------------
hello
world
(2 rows)REPETIR (str, contar)
Retorna uma string que consiste na string str repetidas vezes de contagem. Se a contagem for menor que 1, retorna uma string vazia. Retorna NULL se str ou count forem NULL.
testdb=# SELECT REPEAT('SQL', 3);
repeat
-----------
SQLSQLSQL
(1 row)REPLACE (str, from_str, to_str)
Retorna a string str com todas as ocorrências da string from_str substituídas pela string to_str. REPLACE () executa uma correspondência com distinção entre maiúsculas e minúsculas ao pesquisar from_str.
testdb=# SELECT REPLACE('www.mysql.com', 'w', 'Ww');
replace
------------------
WwWwWw.mysql.com
(1 row)REVERSE (str)
Retorna a string str com a ordem dos caracteres invertida.
testdb=# SELECT REVERSE('abcd');
reverse
---------
dcba
(1 row)DIREITO (str, len)
Retorna os caracteres len mais à direita da string str, ou NULL se algum argumento for NULL.
testdb=# SELECT RIGHT('foobarbar', 4);
right
-------
rbar
(1 row)RPAD (str, len, padstr)
Retorna a string str, preenchida à direita com a string padstr até um comprimento de caracteres len. Se str for maior do que len, o valor de retorno será reduzido para len caracteres.
testdb=# SELECT RPAD('hi',5,'?');
rpad
-------
hi???
(1 row)RTRIM (str)
Retorna a string str com os caracteres de espaço à direita removidos.
testdb=# SELECT RTRIM('barbar ');
rtrim
--------
barbar
(1 row)SUBSTRING (str, pos), SUBSTRING (str FROM pos), SUBSTRING (str, pos, len), SUBSTRING (str FROM pos FOR len)
Os formulários sem um argumento len retornam uma substring da string str começando na posição pos. Os formulários com um argumento len retornam uma substring len caracteres longos da string str, começando na posição pos. Os formulários que usam FROM são sintaxe SQL padrão. Também é possível usar um valor negativo para pos. Nesse caso, o início da substring são os caracteres pos do final da string, em vez do início. Um valor negativo pode ser usado para pos em qualquer uma das formas desta função.
testdb=# SELECT SUBSTRING('Quadratically',5);
substring
-----------
ratically
(1 row)
testdb=# SELECT SUBSTRING('foobarbar' FROM 4);
substring
-----------
barbar
(1 row)
testdb=# SELECT SUBSTRING('Quadratically',5,6);
substring
-----------
ratica
(1 row)TRIM ([{BOTH | LEADING | TRAILING} [remstr] FROM] str), TRIM ([remstr FROM] str)
Retorna a string str com todos os prefixos ou sufixos remstr removidos. Se nenhum dos especificadores BOTH, LEADING ou TRAILING for fornecido, BOTH será assumido. remstr é opcional e, se não for especificado, os espaços são removidos.
testdb=# SELECT TRIM(' bar ');
btrim
-------
bar
(1 row)
testdb=# SELECT TRIM(LEADING 'x' FROM 'xxxbarxxx');
ltrim
--------
barxxx
(1 row)
testdb=# SELECT TRIM(BOTH 'x' FROM 'xxxbarxxx');
btrim
-------
bar
(1 row)
testdb=# SELECT TRIM(TRAILING 'xyz' FROM 'barxxyz');
rtrim
-------
bar
(1 row)UCASE (str)
UCASE () é sinônimo de UPPER ().
SUPERIOR (str)
Retorna a string str com todos os caracteres alterados para maiúsculas de acordo com o mapeamento do conjunto de caracteres atual.
testdb=# SELECT UPPER('manisha');
upper
---------
MANISHA
(1 row)