Esta seção descreve as funções e operadores disponíveis para examinar e manipular valores cadeia de caracteres. Neste contexto, cadeia de caracteres inclui todos os valores dos tipos character, character varying e text. A menos que seja dito o contrário, todas as funções relacionadas abaixo trabalham com todos estes tipos, mas se deve tomar cuidado com os efeitos em potencial do preenchimento automático quando for utilizado o tipo character. De modo geral, as funções descritas nesta seção também trabalham com dados de tipos que não são cadeias de caracteres, convertendo estes dados primeiro na representação de cadeia de caracteres. Algumas funções também existem em forma nativa para os tipos cadeia de bits.
O SQL define algumas funções para cadeias de caracteres com uma sintaxe especial, onde certas palavras chave, em vez de vírgulas, são utilizadas para separar os argumentos. Os detalhes estão na Tabela 9-6. Estas funções também são implementadas utilizando a sintaxe regular de chamada de função (Consulte a Tabela 9-7).
Tabela 9-6. Funções e operadores SQL para cadeias de caracteres
| Função | Tipo retornado | Descrição | Exemplo | Resultado |
|---|---|---|---|---|
| cadeia_de_caracteres || cadeia_de_caracteres | text | Concatenação de cadeias de caracteres | 'Post' || 'greSQL' | PostgreSQL |
| bit_length(cadeia_de_caracteres) | integer | Número de bits na cadeia de caracteres | bit_length('José') | 32 |
| char_length(cadeia_de_caracteres) ou character_length(cadeia_de_caracteres) | integer | Número de caracteres na cadeia de caracteres | char_length('José') | 4 |
| convert(cadeia_de_caracteres using nome_da_conversão) | text | Muda a codificação utilizando o nome de conversão especificado. As conversões podem ser definidas pelo comando CREATE CONVERSION. Além disso, existem alguns nomes de conversão pré-definidos. Veja na Tabela 9-8 os nomes de conversão disponíveis. | convert('PostgreSQL' using iso_8859_1_to_utf_8) | 'PostgreSQL' na codificação Unicode (UTF-8) |
| lower(cadeia_de_caracteres) | text | Converte as letras da cadeia de caracteres em minúsculas | lower('SÃO') | sÃo |
| octet_length(cadeia_de_caracteres) | integer | Número de bytes na cadeia de caracteres | octet_length('José') | 4 |
| overlay(cadeia_de_caracteres placing cadeia_de_caracteres from integer [for integer]) | text | Substituir parte da cadeia de caracteres (sobreposição) | overlay('Txxxxas' placing 'hom' from 2 for 4) | Thomas |
| position(substring in cadeia_de_caracteres) | integer | Posição da subcadeia de caracteres | position('om' in 'Thomas') | 3 |
| substring(cadeia_de_caracteres [from integer] [for integer]) | text | Extrai parte da cadeia de caracteres | substring('Thomas' from 2 for 3) | hom |
| substring(cadeia_de_caracteres from padrão) | text | Extrai a parte da cadeia de caracteres correspondente à expressão regular POSIX [a] | substring('Thomas' from '...$') | mas |
| substring(cadeia_de_caracteres from padrão for escape) | text | Extrai a parte da cadeia de caracteres correspondente à expressão regular SQL | substring('Thomas' from '%#"o_a#"_' for '#') | oma |
| trim([leading | trailing | both] [caracteres] from cadeia_de_caracteres) | text | Remove a cadeia de caracteres mais longa contendo apenas os caracteres (espaço por padrão) da extremidade inicial/final/ambas da cadeia_de_caracteres. | trim(both 'x' from 'xTomxx') | Tom |
| upper(cadeia_de_caracteres) | text | Converte as letras da cadeia de caracteres em maiúsculas | upper('são') | SãO |
| Notas: a. Nos sistemas *nix execute man 7 regex para ver uma descrição das expressões regulares POSIX 1003.2. (N. do T.) |
||||
Estão disponíveis funções adicionais para manipulação de cadeias de caracteres, conforme mostrado na Tabela 9-7. Algumas delas são utilizadas internamente para implementar funções de cadeia de caracteres do padrão SQL, conforme mostrado na Tabela 9-6.
Tabela 9-7. Outras funções para cadeia de caracteres
| Função | Tipo retornado | Descrição | Exemplo | Resultado |
|---|---|---|---|---|
| ascii(text) | integer | código ASCII do primeiro caractere do argumento | ascii('x') | 120 |
| btrim(cadeia_de_caracteres text [, caracteres text]) | text | Remove a maior cadeia de caracteres contendo apenas os caracteres presentes em caracteres (espaço por padrão), do início e do fim da cadeia_de_caracteres | btrim('xyxtrimyyx', 'xy') | trim |
| chr(integer) | text | Caractere com o código ASCII fornecido | chr(65) | A |
| convert(cadeia_de_caracteres text, [codificação_de_origem name,] codificação_de_destino name) | text | Converte a cadeia de caracteres na codificação_de_destino. A codificação de origem é especificada por codificação_de_origem. Se a codificação_de_origem for omitida, será assumida a codificação do banco de dados. | convert( 'texto_em_unicode', 'UNICODE', 'LATIN1') | Representação na codificação ISO 8859-1 do texto_em_unicode |
| decode(cadeia_de_caracteres text, tipo text) | bytea | Decodifica os dados binários da cadeia_de_caracteres previamente codificada com encode(). O tipo do parâmetro é o mesmo que em encode(). | decode('MTIzAAE=', 'base64') | 123\000\001 |
| encode(dados bytea, tipo text) | text | Codifica dados binários na representação somente ASCII. Os tipos suportados são: base64, hex e escape. | encode( '123\\000\\001', 'base64') | MTIzAAE= |
| initcap(text) | text | Converte a primeira letra de cada palavra em maiúscula e as demais em minúsculas. As palavras são seqüências de caracteres alfanuméricos separadas por caracteres não alfanuméricos. | initcap('hi THOMAS') | Hi Thomas |
| length(cadeia_de_caracteres text) | integer | Número de caracteres presentes na cadeia_de_caracteres. | length('José') | 4 |
| lpad(cadeia_de_caracteres text, comprimento integer [, preenchimento text]) | text | Preenche a cadeia_de_caracteres até o comprimento adicionando os caracteres de preenchimento (espaço por padrão) à esquerda. Se a cadeia_de_caracteres for mais longa que o comprimento então é truncada (à direita). | lpad('hi', 5, 'xy') | xyxhi |
| ltrim(cadeia_de_caracteres text [, caracteres text]) | text | Remove a cadeia de caracteres mais longa contendo apenas caracteres presentes em caracteres (espaço por padrão) do início da cadeia_de_caracteres. | ltrim('zzzytrim', 'xyz') | trim |
| md5(cadeia_de_caracteres text) | text | Calcula o MD5 da cadeia_de_caracteres, retornando o resultado em hexadecimal. | md5('abc') | 900150983cd24fb0 d6963f7d28e17f72 |
| pg_client_encoding() | name | Nome da codificação atual do cliente | pg_client_encoding() | LATIN1 |
| quote_ident(cadeia_de_caracteres text) | text | Retorna a cadeia de caracteres fornecida apropriadamente entre aspas, para ser utilizada como identificador na cadeia de caracteres de um comando SQL. As aspas serão adicionadas somente quando forem necessárias (ou seja, se a cadeia de caracteres contiver caracteres não-identificadores, ou se contiver letras maiúsculas e minúsculas). As aspas internas são devidamente duplicadas. [a] | quote_ident('Foo bar') | "Foo bar" |
| quote_literal(cadeia_de_caracteres text) | text | Retorna a cadeia de caracteres fornecida apropriadamente entre apóstrofos, para ser utilizada como literal cadeia de caracteres na cadeia de caracteres de um comando SQL. Os apóstrofos e contrabarras embutidos são devidamente duplicados. | quote_literal( 'O\'Reilly') | 'O''Reilly' |
| repeat(cadeia_de_caracteres text, número integer) | text | Repete a cadeia_de_caracteres pelo número de vezes especificado | repeat('Pg', 4) | PgPgPgPg |
| replace(cadeia_de_caracteres text, origem text, destino text) | text | Substitui todas as ocorrências na cadeia_de_caracteres, da cadeia de caracteres de origem pela cadeia de caracteres de destino. | replace( 'abcdefabcdef', 'cd', 'XX') | abXXefabXXef |
| rpad(cadeia_de_caracteres text, comprimento integer [, preenchimento text]) | text | Preenche a cadeia_de_caracteres até o comprimento anexando os caracteres de preenchimento (espaço por padrão) à direita. Se a cadeia_de_caracteres for mais longa que o comprimento, então é truncada. | rpad('hi', 5, 'xy') | hixyx |
| rtrim(cadeia_de_caracteres text [, caracteres text]) | text | Remove do final da cadeia_de_caracteres, a cadeia de caracteres mais longa contendo apenas os caracteres presentes em caracteres (espaço por padrão). | rtrim('trimxxxx', 'x') | trim |
| split_part(cadeia_de_caracteres text, delimitador text, campo integer) | text | Divide a cadeia_de_caracteres utilizando o delimitador, retornando o campo especificado (contado a partir de 1). | split_part( 'abc~@~def~@~ghi', '~@~', 2) | def |
| strpos(cadeia_de_caracteres, caracteres) | text | Posição dos caracteres especificados; o mesmo que position(caracteres in cadeia_de_caracteres), mas deve ser observada a ordem invertida dos argumentos | strpos('high', 'ig') | 2 |
| substr(cadeia_de_caracteres, origem [, contador]) | text | Extrai a subcadeia de caracteres caracteres; o mesmo que substring(cadeia_de_caracteres from origem for contador) | substr('alphabet', 3, 2) | ph |
| to_ascii(text [, codificação]) | text | Converte texto em outras codificações em ASCII [b] | to_ascii('Conseqüência') | Consequencia |
| to_hex(número integer ou bigint) | text | Converte o número em sua representação hexadecimal equivalente | to_hex(2147483647) | 7fffffff |
| translate(cadeia_de_caracteres text, origem text, destino text) | text | Todo caractere da cadeia_de_caracteres que corresponde a um caractere do conjunto origem, é substituído pelo caractere correspondente do conjunto destino. | translate('12345', '14', 'ax') | a23x5 |
| Notas: a. SQL server — A função quotename retorna uma cadeia Unicode com delimitadores adicionados, para tornar a cadeia de entrada um identificador delimitado válido para o Microsoft SQL Server 2005. Os delimitadores podem ser apóstrofos ( ' ), colchete esquerdo e direito ( [ ] ), ou aspas ( " ). O padrão é colchetes. SQL Server 2005 Books Online — QUOTENAME (Transact-SQL) (N. do T.) b. A função to_ascii permite apenas a conversão das codificações LATIN1, LATIN2, LATIN9 e WIN1250. |
||||
Exemplo 9-1. Conversão de letras minúsculas e maiúsculas acentuadas
Abaixo estão mostradas duas funções para conversão de letras. A função maiusculas converte letras minúsculas, com ou sem acentos, em maiúsculas, enquanto a função minusculas faz o contrário, ou seja, converte letras maiúsculas, com ou sem acentos em minúsculas [1] .
=> \!chcp 1252
Active code page: 1252
=> CREATE FUNCTION maiusculas(text) RETURNS text AS '
'> SELECT translate( upper($1),
'> text ''áéíóúàèìòùãõâêîôôäëïöüç'',
'> text ''ÁÉÍÓÚÀÈÌÒÙÃÕÂÊÎÔÛÄËÏÖÜÇ'')
'> ' LANGUAGE SQL STRICT;
=> SELECT maiusculas('à ação seqüência');
maiusculas
------------------
À AÇÃO SEQÜÊNCIA
=> CREATE FUNCTION minusculas(text) RETURNS text AS '
'> SELECT translate( lower($1),
'> text ''ÁÉÍÓÚÀÈÌÒÙÃÕÂÊÎÔÛÄËÏÖÜÇ'',
'> text ''áéíóúàèìòùãõâêîôôäëïöüç'')
'> ' LANGUAGE SQL STRICT;
=> SELECT minusculas('À AÇÃO SEQÜÊNCIA');
minusculas
------------------
à ação seqüência
Tabela 9-8. Conversões nativas
| Nome da conversão [a] | Codificação de origem | Codificação de destino |
|---|---|---|
| ascii_to_mic | SQL_ASCII | MULE_INTERNAL |
| ascii_to_utf_8 | SQL_ASCII | UNICODE |
| big5_to_euc_tw | BIG5 | EUC_TW |
| big5_to_mic | BIG5 | MULE_INTERNAL |
| big5_to_utf_8 | BIG5 | UNICODE |
| euc_cn_to_mic | EUC_CN | MULE_INTERNAL |
| euc_cn_to_utf_8 | EUC_CN | UNICODE |
| euc_jp_to_mic | EUC_JP | MULE_INTERNAL |
| euc_jp_to_sjis | EUC_JP | SJIS |
| euc_jp_to_utf_8 | EUC_JP | UNICODE |
| euc_kr_to_mic | EUC_KR | MULE_INTERNAL |
| euc_kr_to_utf_8 | EUC_KR | UNICODE |
| euc_tw_to_big5 | EUC_TW | BIG5 |
| euc_tw_to_mic | EUC_TW | MULE_INTERNAL |
| euc_tw_to_utf_8 | EUC_TW | UNICODE |
| gb18030_to_utf_8 | GB18030 | UNICODE |
| gbk_to_utf_8 | GBK | UNICODE |
| iso_8859_10_to_utf_8 | LATIN6 | UNICODE |
| iso_8859_13_to_utf_8 | LATIN7 | UNICODE |
| iso_8859_14_to_utf_8 | LATIN8 | UNICODE |
| iso_8859_15_to_utf_8 | LATIN9 | UNICODE |
| iso_8859_16_to_utf_8 | LATIN10 | UNICODE |
| iso_8859_1_to_mic | LATIN1 | MULE_INTERNAL |
| iso_8859_1_to_utf_8 | LATIN1 | UNICODE |
| iso_8859_2_to_mic | LATIN2 | MULE_INTERNAL |
| iso_8859_2_to_utf_8 | LATIN2 | UNICODE |
| iso_8859_2_to_windows_1250 | LATIN2 | WIN1250 |
| iso_8859_3_to_mic | LATIN3 | MULE_INTERNAL |
| iso_8859_3_to_utf_8 | LATIN3 | UNICODE |
| iso_8859_4_to_mic | LATIN4 | MULE_INTERNAL |
| iso_8859_4_to_utf_8 | LATIN4 | UNICODE |
| iso_8859_5_to_koi8_r | ISO_8859_5 | KOI8 |
| iso_8859_5_to_mic | ISO_8859_5 | MULE_INTERNAL |
| iso_8859_5_to_utf_8 | ISO_8859_5 | UNICODE |
| iso_8859_5_to_windows_1251 | ISO_8859_5 | WIN |
| iso_8859_5_to_windows_866 | ISO_8859_5 | ALT |
| iso_8859_6_to_utf_8 | ISO_8859_6 | UNICODE |
| iso_8859_7_to_utf_8 | ISO_8859_7 | UNICODE |
| iso_8859_8_to_utf_8 | ISO_8859_8 | UNICODE |
| iso_8859_9_to_utf_8 | LATIN5 | UNICODE |
| johab_to_utf_8 | JOHAB | UNICODE |
| koi8_r_to_iso_8859_5 | KOI8 | ISO_8859_5 |
| koi8_r_to_mic | KOI8 | MULE_INTERNAL |
| koi8_r_to_utf_8 | KOI8 | UNICODE |
| koi8_r_to_windows_1251 | KOI8 | WIN |
| koi8_r_to_windows_866 | KOI8 | ALT |
| mic_to_ascii | MULE_INTERNAL | SQL_ASCII |
| mic_to_big5 | MULE_INTERNAL | BIG5 |
| mic_to_euc_cn | MULE_INTERNAL | EUC_CN |
| mic_to_euc_jp | MULE_INTERNAL | EUC_JP |
| mic_to_euc_kr | MULE_INTERNAL | EUC_KR |
| mic_to_euc_tw | MULE_INTERNAL | EUC_TW |
| mic_to_iso_8859_1 | MULE_INTERNAL | LATIN1 |
| mic_to_iso_8859_2 | MULE_INTERNAL | LATIN2 |
| mic_to_iso_8859_3 | MULE_INTERNAL | LATIN3 |
| mic_to_iso_8859_4 | MULE_INTERNAL | LATIN4 |
| mic_to_iso_8859_5 | MULE_INTERNAL | ISO_8859_5 |
| mic_to_koi8_r | MULE_INTERNAL | KOI8 |
| mic_to_sjis | MULE_INTERNAL | SJIS |
| mic_to_windows_1250 | MULE_INTERNAL | WIN1250 |
| mic_to_windows_1251 | MULE_INTERNAL | WIN |
| mic_to_windows_866 | MULE_INTERNAL | ALT |
| sjis_to_euc_jp | SJIS | EUC_JP |
| sjis_to_mic | SJIS | MULE_INTERNAL |
| sjis_to_utf_8 | SJIS | UNICODE |
| tcvn_to_utf_8 | TCVN | UNICODE |
| uhc_to_utf_8 | UHC | UNICODE |
| utf_8_to_ascii | UNICODE | SQL_ASCII |
| utf_8_to_big5 | UNICODE | BIG5 |
| utf_8_to_euc_cn | UNICODE | EUC_CN |
| utf_8_to_euc_jp | UNICODE | EUC_JP |
| utf_8_to_euc_kr | UNICODE | EUC_KR |
| utf_8_to_euc_tw | UNICODE | EUC_TW |
| utf_8_to_gb18030 | UNICODE | GB18030 |
| utf_8_to_gbk | UNICODE | GBK |
| utf_8_to_iso_8859_1 | UNICODE | LATIN1 |
| utf_8_to_iso_8859_10 | UNICODE | LATIN6 |
| utf_8_to_iso_8859_13 | UNICODE | LATIN7 |
| utf_8_to_iso_8859_14 | UNICODE | LATIN8 |
| utf_8_to_iso_8859_15 | UNICODE | LATIN9 |
| utf_8_to_iso_8859_16 | UNICODE | LATIN10 |
| utf_8_to_iso_8859_2 | UNICODE | LATIN2 |
| utf_8_to_iso_8859_3 | UNICODE | LATIN3 |
| utf_8_to_iso_8859_4 | UNICODE | LATIN4 |
| utf_8_to_iso_8859_5 | UNICODE | ISO_8859_5 |
| utf_8_to_iso_8859_6 | UNICODE | ISO_8859_6 |
| utf_8_to_iso_8859_7 | UNICODE | ISO_8859_7 |
| utf_8_to_iso_8859_8 | UNICODE | ISO_8859_8 |
| utf_8_to_iso_8859_9 | UNICODE | LATIN5 |
| utf_8_to_johab | UNICODE | JOHAB |
| utf_8_to_koi8_r | UNICODE | KOI8 |
| utf_8_to_sjis | UNICODE | SJIS |
| utf_8_to_tcvn | UNICODE | TCVN |
| utf_8_to_uhc | UNICODE | UHC |
| utf_8_to_windows_1250 | UNICODE | WIN1250 |
| utf_8_to_windows_1251 | UNICODE | WIN |
| utf_8_to_windows_1256 | UNICODE | WIN1256 |
| utf_8_to_windows_866 | UNICODE | ALT |
| utf_8_to_windows_874 | UNICODE | WIN874 |
| windows_1250_to_iso_8859_2 | WIN1250 | LATIN2 |
| windows_1250_to_mic | WIN1250 | MULE_INTERNAL |
| windows_1250_to_utf_8 | WIN1250 | UNICODE |
| windows_1251_to_iso_8859_5 | WIN | ISO_8859_5 |
| windows_1251_to_koi8_r | WIN | KOI8 |
| windows_1251_to_mic | WIN | MULE_INTERNAL |
| windows_1251_to_utf_8 | WIN | UNICODE |
| windows_1251_to_windows_866 | WIN | ALT |
| windows_1256_to_utf_8 | WIN1256 | UNICODE |
| windows_866_to_iso_8859_5 | ALT | ISO_8859_5 |
| windows_866_to_koi8_r | ALT | KOI8 |
| windows_866_to_mic | ALT | MULE_INTERNAL |
| windows_866_to_utf_8 | ALT | UNICODE |
| windows_866_to_windows_1251 | ALT | WIN |
| windows_874_to_utf_8 | WIN874 | UNICODE |
| Notas: a. Os nomes das conversões obedecem a um esquema de nomes padronizado: O nome oficial da codificação de origem, com todos os caracteres não alfanuméricos substituídos por sublinhado, seguido por _to_, seguido pelo nome da codificação de destino processado da mesma forma que o nome da codificação de origem. Portanto, os nomes podem desviar dos nomes habituais das codificações. |
||
Nota: Seção escrita pelo tradutor, não fazendo parte do manual original.
Os exemplos abaixo comparam funções e operadores para cadeias de caracteres do Oracle, do SQL Server, do DB2 e do PostgreSQL 8.0.0.
Exemplo 9-2. Tamanho de uma cadeia de caracteres com espaço à direita
Abaixo são mostradas consultas que retornam como resultado o tamanho de uma cadeia de caracteres com espaço à direita. Note que apenas a função len do SQL Server 2000 não conta o espaço à direita.
PostgreSQL 8.0.0:
=> SELECT length('1234567890 ');
length
--------
11
SQL Server 2000:
SELECT len('1234567890 ') AS len
len
---
10
Oracle 10g:
SQL> SELECT length('1234567890 ') AS length FROM sys.dual;
LENGTH
----------
11
DB2 9.1:
db2 => VALUES(length('1234567890 '));
1
-----------
11
Exemplo 9-3. Concatenação de cadeias de caracteres
Abaixo são mostradas consultas que retornam como resultado a concatenação de cadeias de caracteres. Deve ser observado que o SQL Server 2000 usa o operador +, enquanto os demais usam o operador || para concatenar cadeias de caracteres. Além disso, o Oracle e o DB2 possuem a função concat, nativa, para concatenar duas cadeias de caracteres. Embora o PostgreSQL e o SQL Server não possuam a função concat nativa, esta pode ser facilmente definida neste dois produtos.
PostgreSQL 8.0.0:
=> SELECT 'ae' || 'io' || 'u' AS vogais;
vogais
--------
aeiou
=> CREATE FUNCTION concat(text,text) RETURNS text AS '
'> SELECT $1 || $2;
'> ' LANGUAGE SQL STRICT;
=> SELECT concat(concat('ae','io'),'u') AS vogais;
vogais
--------
aeiou
SQL Server 2000:
SELECT 'ae' + 'io' + 'u' AS vogais;
vogais
------
aeiou
CREATE FUNCTION dbo.concat(@s1 varchar(64), @s2 varchar(64))
RETURNS varchar(128)
AS
BEGIN
RETURN @s1 + @s2
END
GO
SELECT dbo.concat(dbo.concat('ae','io'),'u') AS vogais
GO
vogais
------
aeiou
Oracle 10g:
SQL> SELECT 'ae' || 'io' || 'u' AS vogais FROM sys.dual;
VOGAI
-----
aeiou
SQL> SELECT concat(concat('ae','io'),'u') AS vogais FROM sys.dual;
VOGAI
-----
aeiou
DB2 9.1:
db2 => SELECT t.* FROM (VALUES('ae' || 'io' || 'u')) AS t(vogais);
VOGAIS
------
aeiou
db2 => SELECT t.* FROM (VALUES(concat(concat('ae','io'),'u'))) AS t(vogais);
VOGAIS
------
aeiou
Nota: Seção escrita pelo tradutor, não fazendo parte do manual original.
A Tabela 9-9 compara funções e operadores para cadeias de caracteres do PostgreSQL e do Oracle, através de exemplos tirados do próprio manual do Oracle, com intuito de mostrar similaridades.
Tabela 9-9. Funções e operadores para cadeias de caracteres do PostgreSQL e do Oracle
| PostgreSQL 8.0.0 | Oracle 10g |
|---|---|
=> SELECT CHR(67)||CHR(65)||CHR(84) AS "Dog"; Dog ----- CAT |
SQL> SELECT CHR(67)||CHR(65)||CHR(84) "Dog" 2 FROM sys.dual; Dog --- CAT |
=> SELECT INITCAP('the soap') AS "Capitals";
Capitals
----------
The Soap
|
SQL> SELECT INITCAP('the soap') "Capitals"
2 FROM sys.dual;
Capitals
---------
The Soap
|
=> SELECT LOWER('MR. SCOTT MCMILLAN') AS "Lowercase";
Lowercase
--------------------
mr. scott mcmillan
|
SQL> SELECT LOWER('MR. SCOTT MCMILLAN') "Lowercase"
2 FROM sys.dual;
Lowercase
--------------------
mr. scott mcmillan
|
=> SELECT LPAD('Page 1',15,'*.') AS "LPAD example";
LPAD example
-----------------
*.*.*.*.*Page 1
|
SQL> SELECT LPAD('Page 1',15,'*.') "LPAD example"
2 FROM sys.dual;
LPAD example
---------------
*.*.*.*.*Page 1
|
=> SELECT LTRIM('xyxXxyLAST WORD','xy') AS "LTRIM example";
LTRIM example
---------------
XxyLAST WORD
|
SQL> SELECT LTRIM('xyxXxyLAST WORD','xy') "LTRIM example"
2 FROM sys.dual;
LTRIM example
------------
XxyLAST WORD
|
=> SELECT REPLACE('JACK and JUE','J','BL') AS "Changes";
Changes
----------------
BLACK and BLUE
|
SQL> SELECT REPLACE('JACK and JUE','J','BL') "Changes"
2 FROM sys.dual;
Changes
--------------
BLACK and BLUE
|
=> SELECT RPAD('MORRISON',12,'ab') AS "RPAD example";
RPAD example
--------------
MORRISONabab
|
SQL> SELECT RPAD('MORRISON',12,'ab') "RPAD example"
2 FROM sys.dual;
RPAD example
-----------------
MORRISONabab
|
=> SELECT RTRIM('BROWNINGyxXxyyx','xy') AS "RTRIM example";
RTRIM example
---------------
BROWNINGyxX
|
SQL> SELECT RTRIM('BROWNINGyxXxyyx','xy') "RTRIM example"
2 FROM sys.dual;
RTRIM examp
-----------
BROWNINGyxX
|
=> SELECT SUBSTR('ABCDEFG',3,4) AS "Substring";
Substring
-----------
CDEF
|
SQL> SELECT SUBSTR('ABCDEFG',3,4) "Substring"
2 FROM sys.dual;
Substring
---------
CDEF
|
=> SELECT TRANSLATE('2KRW229',
(> '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ',
(> '9999999999XXXXXXXXXXXXXXXXXXXXXXXXXX') AS "License";
License
---------
9XXX999
|
SQL> SELECT TRANSLATE('2KRW229',
2 '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ',
3 '9999999999XXXXXXXXXXXXXXXXXXXXXXXXXX') "License"
4 FROM sys.dual;
License
--------
9XXX999
|
=> SELECT TRANSLATE('2KRW229',
(> '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ', '0123456789')
-> AS "Translate example";
Translate example
-------------------
2229
|
SQL> SELECT TRANSLATE('2KRW229',
2 '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ', '0123456789')
3 "Translate example"
4 FROM sys.dual;
Translate example
-----------------
2229
|
=> SELECT TRIM (0 FROM 0009872348900) AS "TRIM Example"; TRIM Example -------------- 98723489 |
SQL> SELECT TRIM (0 FROM 0009872348900) "TRIM Example"
2 FROM sys.dual;
TRIM Example
------------
98723489
|
=> SELECT UPPER('Large') AS "Uppercase";
Uppercase
-----------
LARGE
|
SQL> SELECT UPPER('Large') "Uppercase"
2 FROM sys.dual;
Upper
-----
LARGE
|
| [1] |
Exemplo escrito pelo tradutor, não fazendo parte do manual original. |
| Anterior | Principal | Próxima |
| Funções e operadores matemáticos | Acima | Funções e operadores para cadeias binárias |
