9.4. Funções e operadores de cadeia de caracteres #

9.4.1. Função format

Esta seção descreve as funções e operadores disponíveis para examinar e tratar valores cadeia de caracteres. Neste contexto, cadeia de caracteres inclui todos os valores dos tipos de dados character, character varying e text. Exceto onde indicado, estas funções e operadores são declarados para aceitar e retornar o tipo de dados text. Também aceitam indistintamente argumentos do tipo de dados character varying. Valores do tipo de dados character são convertidos no tipo de dados text antes que a função ou o operador seja aplicado, resultando na remoção de quaisquer espaços à direita no valor do tipo de dados character.

O padrão SQL define algumas funções de cadeia de caracteres que usam palavras-chave, em vez de vírgulas, para separar os argumentos. Os detalhes se encontram na Tabela 9.9. O PostgreSQL também fornece versões destas funções que usam a sintaxe de chamada de função regular (veja a Tabela 9.10).

Nota

O operador de concatenação de cadeias de caracteres (||) aceita uma entrada que não é uma cadeia de caracteres, desde que pelo menos uma das entradas seja do tipo cadeia de caracteres, conforme descrito na Tabela 9.9. Para os outros casos, pode ser adicionada uma conversão explícita para o tipo de dados text, para que a entrada que não é uma cadeia de caracteres seja aceita.

Tabela 9.9. Funções e operadores SQL de cadeia de caracteres

Função/Operador

Descrição

Exemplo(s)

text || texttext

Concatena as duas cadeias de caracteres.

'Post' || 'greSQL'PostgreSQL

text || anynonarraytext

anynonarray || texttext

Converte a entrada não-cadeia de caracteres em texto e, em seguida, concatena as duas cadeias de caracteres. (A entrada não-cadeia de caracteres não pode ser do tipo matriz, porque isto criaria ambiguidade com os operadores de matriz ||. Se for desejado concatenar o equivalente em texto de uma matriz, esta deve ser convertida explicitamente para text.)

'Value: ' || 42Value: 42

btrim ( string text [, characters text ] ) → text

Remove do início e do fim da string a cadeia de caracteres mais longa contendo apenas os caracteres presentes em characters (espaço por padrão).

btrim('xyxtrimyyx', 'xyz')trim

text IS [NOT] [form] NORMALIZEDboolean

Verifica se a cadeia de caracteres está no formato de normalização Unicode especificado. A palavra-chave opcional form especifica a forma: NFC (o padrão), NFD, NFKC ou NFKD. Esta expressão só pode ser usada quando a codificação do servidor for UTF8. Note que verificar a normalização usando esta expressão costuma ser mais rápido do que normalizar cadeias de caracteres que possivelmente já estão normalizadas.

U&'\0061\0308bc' IS NFD NORMALIZEDt

bit_length ( text ) → integer

Retorna o número de bits na cadeia de caracteres (8 vezes o octet_length).

bit_length('jose')32

char_length ( text ) → integer

character_length ( text ) → integer

Retorna o número de caracteres na cadeia de caracteres.

char_length('josé')4

lower ( text ) → text

Converte a cadeia de caracteres para letras minúsculas, de acordo com as regras de localidade do banco de dados.

lower('TOM')tom

lpad ( string text, length integer [, fill text ] ) → text

Estende a string para o comprimento length apensando os caracteres em fill (espaço por padrão). Se a string já for mais longa que length então é feito o truncamento (à direita).

lpad('hi', 5, 'xy')xyxhi

ltrim ( string text [, characters text ] ) → text

Remove do início da string a cadeia de caracteres mais longa contendo apenas os caracteres em characters (espaço por padrão).

ltrim('zzzytest', 'xyz')test

normalize ( text [, form ] ) → text

Converte a cadeia de caracteres para o formato de normalização Unicode especificado. A palavra chave opcional form especifica a forma: NFC (o padrão), NFD, NFKC ou NFKD. Esta função só pode ser usada quando a codificação do servidor for UTF8.

normalize(U&'\0061\0308bc', NFC)U&'\00E4bc'

octet_length ( text ) → integer

Retorna o número de bytes na cadeia de caracteres.

octet_length('josé')5 (se a codificação do servidor for UTF8)

octet_length ( character ) → integer

Retorna o número de bytes na cadeia de caracteres. Como esta versão da função aceita diretamente o tipo de dados character, ela não removerá os espaços em branco à direita.

octet_length('abc '::character(4))4

overlay ( string text PLACING newsubstring text FROM start integer [ FOR count integer ] ) → text

Substitui a sub-cadeia de caracteres de string começando no start-ésimo caractere e se estende por count caracteres pela newsubstring. Se count for omitido, o valor padrão será o comprimento de newsubstring.

overlay('Txxxxas' placing 'hom' from 2 for 4)Thomas

position ( substring text IN string text ) → integer

Retorna a posição do primeiro início da substring especificada na string, ou zero se não estiver presente.

position('om' in 'Thomas')3

rpad ( string text, length integer [, fill text ] ) → text

Estende a string para o comprimento length apensando os caracteres em fill (espaço por padrão). Se a string já for maior que length, então será truncada.

rpad('hi', 5, 'xy')hixyx

rtrim ( string text [, characters text ] ) → text

Remove do fim da string a cadeia de caracteres mais longa contendo apenas os caracteres em characters (espaço por padrão).

rtrim('testxxzx', 'xyz')test

substring ( string text [ FROM start integer ] [ FOR count integer ] ) → text

Extrai a sub-cadeia de caracteres da string começando no start-ésimo caractere se este for especificado, e terminando após count caracteres se este for especificado. É necessário fornecer pelo menos o valor de start ou count.

substring('Thomas' from 2 for 3)hom

substring('Thomas' from 3)omas

substring('Thomas' for 2)Th

substring ( string text FROM pattern text ) → text

Extrai a primeira sub-cadeia de caracteres que corresponde à expressão regular POSIX; veja a Seção 9.7.3.

substring('Thomas' from '...$')mas

substring ( string text SIMILAR pattern text ESCAPE escape text ) → text

substring ( string text FROM pattern text FOR escape text ) → text

Extrai a primeira sub-cadeia de caracteres que corresponde à expressão regular SQL; veja a Seção 9.7.2. A primeira forma está especificada desde o SQL:2003; a segunda forma existia apenas no SQL:1999 devendo ser considerado obsoleta.

substring('Thomas' similar '%#"o_a#"_' escape '#')oma

trim ( [ LEADING | TRAILING | BOTH ] [ characters text ] FROM string text ) → text

Remove a cadeia de caracteres mais longa contendo apenas os caracteres em characters (espaço por padrão) do início, do fim ou das duas extremidades (BOTH é o padrão) de string.

trim(both 'xyz' from 'yxTomxx')Tom

trim ( [ LEADING | TRAILING | BOTH ] [ FROM ] string text [, characters text ] ) → text

Esta é uma sintaxe fora do padrão para trim().

trim(both from 'yxTomxx', 'xyz')Tom

unicode_assigned ( text ) → boolean

Retorna true se todos os caracteres na cadeia de caracteres tiverem pontos de código Unicode atribuídos; false caso contrário. Esta função só pode ser usada quando a codificação do servidor for UTF8.

upper ( text ) → text

Converte a cadeia de caracteres para letras maiúsculas, de acordo com as regras de localidade do banco de dados.

upper('tom')TOM


Estão disponíveis as funções adicionais para manejo de cadeia de caracteres listadas na Tabela 9.10. (Algumas delas são usadas internamente para implementar as funções de cadeia de caracteres padrão SQL listadas na Tabela 9.9.) Existem também operadores de correspondência de padrões, que são descritos na Seção 9.7, e operadores para procura de texto completo que são descritos no Capítulo 12.

Tabela 9.10. Outras funções e operadores de cadeias de caracteres

Função

Descrição

Exemplo(s)

text ^@ textboolean

Retorna verdade se a primeira cadeia de caracteres começar com a segunda cadeia de caracteres. (equivalente à função starts_with()).

'alphabet' ^@ 'alph't

ascii ( text ) → integer

Retorna o código numérico do primeiro caractere do argumento. Na codificação UTF8, retorna o ponto de código Unicode do caractere. Em outras codificações multibyte, o argumento deve ser um caractere ASCII.

ascii('x')120

chr ( integer ) → text

Retorna o caractere com o código fornecido. Na codificação UTF8, o argumento é tratado como um ponto de código Unicode. Em outras codificações multibyte, o argumento deve designar um caractere ASCII. chr(0) não é permitido, porque os tipos de dados de texto não podem armazenar este caractere..

chr(65)A

concat ( val1 "any" [, val2 "any" [, ...] ] ) → text

Concatena as representações textuais de todos os argumentos. Argumentos NULL são ignorados.

concat('abcde', 2, NULL, 22)abcde222

concat_ws ( sep text, val1 "any" [, val2 "any" [, ...] ] ) → text

Concatena todos os argumentos, exceto o primeiro, com separadores. O primeiro argumento é usado como cadeia de caracteres separadora e não deve ser NULL. Outros argumentos NULL são ignorados.

concat_ws(',', 'abcde', 2, NULL, 22)abcde,2,22

format ( formatstr text [, formatarg "any" [, ...] ] ) → text

Formata os argumentos de acordo com a cadeia de caracteres de formatação; veja a Seção 9.4.1. Esta função é semelhante à função sprintf da linguagem C.

format('Hello %s, %1$s', 'World')Hello World, World

initcap ( text ) → text

Converte a primeira letra de cada palavra para maiúscula e as restantes para minúscula. As palavras são sequências de caracteres alfanuméricos separados por caracteres não alfanuméricos.

initcap('hi THOMAS')Hi Thomas

casefold ( text ) → text

Executa a dobragem de caixa (maiúsculas/minúsculas) da cadeia de caracteres de entrada de acordo com a sequência de ordenação [a]. A dobragem de caixa é semelhante à conversão de caixa, mas o objetivo da dobragem de caixa é facilitar a correspondência de cadeias de caracteres sem distinção de caixa entre elas, enquanto o objetivo da conversão de caixa é converter para uma forma específica caixa. Esta função só pode ser usada quando a codificação do servidor for UTF8.

Normalmente, a dobragem de caixa simplesmente converte para minúsculas, mas pode haver exceções dependendo da sequência de ordenação. Por exemplo, alguns caracteres têm mais de duas variantes minúsculas ou se transformam em maiúsculas.

A dobragem da caixa pode alterar o comprimento da cadeia de caracteres. Por exemplo, na sequência de ordenação PG_UNICODE_FAST, ß (U+00DF) se torna ss.

A função casefold pode ser usada para correspondência Unicode padrão sem distinção entre letras maiúsculas e minúsculas (Unicode Default Caseless Matching). e nem sempre preserva a forma normalizada da cadeia de caracteres de entrada (veja normalização).

O provedor libc não tem suporte para dobragem de caixa, portanto casefold é idêntico a lower.

left ( string text, n integer ) → text

Retorna os primeiros n caracteres da cadeia de caracteres, ou quando n for negativo retorna todos os caracteres exceto os últimos |n| caracteres.

left('abcde', 2)ab

length ( text ) → integer

Retorna o número de caracteres na cadeia de caracteres.

length('jose')4

md5 ( text ) → text

Calcula o hash MD5 do argumento, com o resultado escrito em hexadecimal.

md5('abc')900150983cd24fb0​d6963f7d28e17f72

parse_ident ( qualified_identifier text [, strict_mode boolean DEFAULT true ] ) → text[]

Divide o qualified_identifier em uma matriz de identificadores, removendo todos os delimitadores dos identificadores individuais. Por padrão, caracteres extras presentes após o último identificador são considerados um erro; mas se o segundo parâmetro for false, então estes caracteres extras são ignorados. (Esse comportamento é útil para analisar nomes de objetos como funções.) Note que esta função não trunca identificadores com comprimento excessivo. Se o truncamento for desejado, o resultado poderá ser convertido para o tipo de dados name[].

parse_ident('"SomeSchema".someTable'){SomeSchema,sometable}

pg_client_encoding ( ) → name

Retorna o nome da codificação do cliente corrente.

pg_client_encoding()UTF8

quote_ident ( text ) → text

Retorna a cadeia de caracteres fornecida, adequadamente delimitada para ser usada como identificador em uma cadeia de caracteres de uma instrução SQL. São adicionadas aspas apenas se necessário (ou seja, se a cadeia de caracteres contiver caracteres não identificadores, ou sofrer dobra de caixa). As aspas incorporadas são devidamente duplicadas. Veja também o Exemplo 41.1.

quote_ident('Foo bar')"Foo bar"

quote_literal ( text ) → text

Retorna a cadeia de caracteres fornecida, adequadamente delimitada para ser usada como literal cadeia de caracteres em uma cadeia de caracteres de instrução SQL. Apóstrofos e contrabarras incorporados são duplicados de forma apropriada. Note que a função quote_literal retorna nulo quando a entrada é nula; se o argumento puder ser nulo, geralmente a função quote_nullable é mais adequada. Veja também o Exemplo 41.1.

quote_literal(E'O\'Reilly')'O''Reilly'

quote_literal ( anyelement ) → text

Converte o valor fornecido em texto e o delimita como literal. Apóstrofos e contrabarras incorporadas são duplicadas devidamente.

quote_literal(42.5)'42.5'

quote_nullable ( text ) → text

Retorna a cadeia de caracteres fornecida adequadamente delimitada para ser usada como um literal cadeia de caracteres em uma cadeia de caracteres de instrução SQL; ou, se o argumento for nulo, retorna NULL. Apóstrofos e contrabarras incorporadas são duplicados devidamente. Veja também o Exemplo 41.1.

quote_nullable(NULL)NULL

quote_nullable ( anyelement ) → text

Converte o valor fornecido em texto e o delimita como literal; ou, se o argumento for nulo, retorna NULL. Apóstrofos e contrabarras incorporadas são duplicadas devidamente;

quote_nullable(42.5)'42.5'

regexp_count ( string text, pattern text [, start integer [, flags text ] ] ) → integer

Retorna o número de vezes que a expressão regular POSIX pattern corresponde na string; veja a Seção 9.7.3.

regexp_count('123456789012', '\d\d\d', 2)3

regexp_instr ( string text, pattern text [, start integer [, N integer [, endoption integer [, flags text [, subexpr integer ] ] ] ] ] ) → integer

Retorna a posição dentro da string onde a N-ésima correspondência da expressão regular POSIX pattern ocorre, ou zero se não houver correspondência; veja a Seção 9.7.3.

regexp_instr('ABCDEF', 'c(.)(..)', 1, 1, 0, 'i')3

regexp_instr('ABCDEF', 'c(.)(..)', 1, 1, 0, 'i', 2)5

regexp_like ( string text, pattern text [, flags text ] ) → boolean

Verifica existe uma correspondência da expressão regular POSIX pattern na string; veja a Seção 9.7.3.

regexp_like('Hello World', 'world$', 'i')t

regexp_match ( string text, pattern text [, flags text ] ) → text[]

Retorna as sub-cadeias de caracteres da primeira correspondência da expressão regular POSIX pattern com a string; veja a Seção 9.7.3.

regexp_match('foobarbequebaz', '(bar)(beque)'){bar,beque}

regexp_match('foobarbequebazbar', '(bar)(beque)'){bar,beque}

regexp_matches ( string text, pattern text [, flags text ] ) → setof text[]

Retorna as sub-cadeias de caracteres da primeira correspondência da expressão regular POSIX pattern com a string, ou as sub-cadeias de caracteres para todas estas correspondências se for usado o sinalizador g; veja a Seção 9.7.3.

regexp_matches('foobarbequebaz', 'ba.', 'g')

 {bar}
 {baz}

regexp_replace ( string text, pattern text, replacement text [, flags text ] ) → text

Substitui a sub-cadeia de caracteres que é a primeira correspondência da expressão regular POSIX pattern, ou todas as correspondências se for usado o sinalizador g; veja a Seção 9.7.3.

regexp_replace('Thomas', '.[mN]a.', 'M')ThM

regexp_replace ( string text, pattern text, replacement text, start integer [, N integer [, flags text ] ] ) → text

Substitui a sub-cadeia de caracteres que é a N-ésima correspondência da expressão regular POSIX pattern, ou todas as correspondências se N for zero, com a procura começando no start-ésimo caractere da string. Se N for omitido, seu valor padrão é 1. Veja a Seção 9.7.3.

regexp_replace('Thomas', '.', 'X', 3, 2)ThoXas

regexp_replace(string=>'hello world', pattern=>'l', replacement=>'XX', start=>1, "N"=>2)helXXo world

regexp_split_to_array ( string text, pattern text [, flags text ] ) → text[]

Divide a string utilizando uma expressão regular POSIX como delimitador, produzindo uma matriz de resultados; veja a Seção 9.7.3.

regexp_split_to_array('hello world', '\s+'){hello,world}

regexp_split_to_table ( string text, pattern text [, flags text ] ) → setof text

Divide a string utilizando uma expressão regular POSIX como delimitador, produzindo uma tabela de resultados; veja a Seção 9.7.3.

regexp_split_to_table('hello world', '\s+')

 hello
 world

regexp_substr ( string text, pattern text [, start integer [, N integer [, flags text [, subexpr integer ] ] ] ] ) → text

Retorna a sub-cadeia de caracteres de string que corresponde à N-ésima ocorrência da expressão regular POSIX pattern, ou NULL se não houver nenhuma correspondência; veja a Seção 9.7.3.

regexp_substr('ABCDEF', 'c(.)(..)', 1, 1, 'i')CDEF

regexp_substr('ABCDEF', 'c(.)(..)', 1, 1, 'i', 2)EF

repeat ( string text, number integer ) → text

Repete a string number de vezes especificado.

repeat('Pg', 4)PgPgPgPg

replace ( string text, from text, to text ) → text

Substitui todas as ocorrências na string da sub-cadeia de caracteres from pela sub-cadeia de caracteres to.

replace('abcdefabcdef', 'cd', 'XX')abXXefabXXef

reverse ( text ) → text

Inverte a ordem dos caracteres na sequência.

reverse('abcde')edcba

right ( string text, n integer ) → text

Retorna os últimos n caracteres da cadeia de caracteres, ou quando n for negativo retorna todos os caracteres menos os primeiros |n| caracteres.

right('abcde', 2)de

split_part ( string text, delimiter text, n integer ) → text

Divide a string nas ocorrências do delimiter e retorna o n-ésimo campo (contado a partir de 1), ou quando n for negativo retorna o |n|-ésimo campo a partir do último campo.

split_part('abc~@~def~@~ghi', '~@~', 2)def

split_part('abc,def,ghi,jkl', ',', -2)ghi

starts_with ( string text, prefix text ) → boolean

Retorna verdade se a string começa pelo prefix.

starts_with('alphabet', 'alph')t

string_to_array ( string text, delimiter text [, null_string text ] ) → text[]

Divide a string nas ocorrências de delimiter e transforma os campos resultantes em uma matriz do tipo de dados text. Se o delimiter for NULL, cada caractere na string se tornará um elemento separado na matriz. Se o delimiter for uma cadeia de caracteres vazia, então a string será tratada como um único campo. Se for fornecido o parâmetro null_string e este não for NULL, os campos que correspondem a esta cadeia de caracteres serão substituídos por NULL. Veja também a função array_to_string.

string_to_array('xx~~yy~~zz', '~~', 'yy'){xx,NULL,zz}

string_to_table ( string text, delimiter text [, null_string text ] ) → setof text

Divide a string nas ocorrências de delimiter e retorna os campos resultantes como uma matriz de linhas do tipo de dados text. Se delimiter for NULL, cada caractere na string se tornará uma linha separada do resultado. Se delimiter for uma cadeia de caracteres vazia, então a string será tratada como um único campo. Se for fornecido o parâmetro null_string e este não for NULL, então os campos que correspondem a esta cadeia de caracteres serão substituídos por NULL.

string_to_table('xx~^~yy~^~zz', '~^~', 'yy')

 xx
 NULL
 zz

strpos ( string text, substring text ) → integer

Retorna a primeira posição do início da substring na string, ou zero se não estiver presente. (O mesmo que position(substring in string), mas observe a ordem inversa dos argumentos.)

strpos('high', 'ig')2

substr ( string text, start integer [, count integer ] ) → text

Extrai a sub-cadeia de caracteres de string começando no start-ésimo caractere, e se estendendo por count caracteres, se este especificado. (O mesmo que substring(string from start for count).)

substr('alphabet', 3)phabet

substr('alphabet', 3, 2)ph

to_ascii ( string text ) → text

to_ascii ( string text, encoding name ) → text

to_ascii ( string text, encoding integer ) → text

Converte string para ASCII a partir de outra codificação, que pode ser identificada pelo nome ou número. Se encoding for omitido é assumida a codificação do banco de dados (o que, na prática, é o único caso útil.). A conversão consiste principalmente na eliminação dos acentos. A conversão só tem suporte para as codificações LATIN1, LATIN2, LATIN9 e WIN1250. (Veja o módulo unaccent para outra solução mais flexível.)

to_ascii('Karél')Karel

to_bin ( integer ) → text

to_bin ( bigint ) → text

Converte o número para sua representação binária equivalente em complemento de dois [b].

to_bin(2147483647)1111111111111111111111111111111

to_bin(-1234)11111111111111111111101100101110

to_hex ( integer ) → text

to_hex ( bigint ) → text

Converte o número para sua representação hexadecimal equivalente em complemento de dois.

to_hex(2147483647)7fffffff

to_hex(-1234)fffffb2e

to_oct ( integer ) → text

to_oct ( bigint ) → text

Converte o número para sua representação octal equivalente em complemento de dois.

to_oct(2147483647)17777777777

to_oct(-1234)37777775456

translate ( string text, from text, to text ) → text

Substitui cada caractere na string que corresponde a um caractere no conjunto de caracteres de from pelo caractere correspondente no conjunto de caracteres de to Se from for maior que to, as ocorrências dos caracteres extras em from serão excluídas.

translate('12345', '143', 'ax')a2x5

unistr ( text ) → text

Avalia os caracteres Unicode com escape no argumento. Os caracteres Unicode podem ser especificados como \XXXX (4 dígitos hexadecimais), \+XXXXXX (6 dígitos hexadecimais), \uXXXX (4 dígitos hexadecimais) ou \UXXXXXXXX (8 dígitos hexadecimais). Para especificar uma contrabarra invertida, deve ser escritas duas contrabarras. Todos os outros caracteres são interpretados literalmente.

Se a codificação do servidor não for UTF-8, o ponto de código Unicode identificado por uma destas sequências de escape será convertido para a codificação corrente do servidor; Será relatado um erro caso isto não seja possível.

Esta função fornece uma alternativa (fora do padrão) para constantes de cadeia de caracteres com escapes Unicode. (veja a Seção 4.1.2.3).

unistr('d\0061t\+000061')data

unistr('d\u0061t\U00000061')data

[a] O gerenciador de banco de dados compara dados de caracteres usando uma sequência de ordenação. Esta sequência define a ordem de um conjunto de caracteres, determinando se um caractere específico será classificado em posição superior, inferior ou igual a outro. IBM - Collating sequences

[b] Complemento de dois é um tipo de representação binária de números com sinal. Wikipédia


As funções concat, concat_ws e format são mutáveis, então é possível passar os valores a serem concatenados ou formatados como uma matriz marcada com a palavra-chave VARIADIC (veja Seção 36.5.6). Para a função, os elementos da matriz são tratados como se fossem argumentos comuns separados. Se o argumento matriz VARIADIC for NULL, concat e concat_ws retornam NULL, mas format trata NULL como uma matriz de zero elementos.

Veja também a função de agregação string_agg em Seção 9.21, e as funções de conversão entre cadeias de caracteres e o tipo de dados bytea na Tabela 9.13.

9.4.1. Função format #

A função format produz uma saída formatada segundo a cadeia de caracteres de formatação, em um estilo semelhante ao da função sprintf da linguagem C.

format(formatstr text [, formatarg "any" [, ...] ])

onde formatstr é a cadeia de caracteres de formatação, que determina como o resultado deve ser formatado. O texto na cadeia de caracteres de formatação é copiado diretamente para o resultado, exceto onde são usados especificadores de formatação. Os especificadores de formatação atuam como espaços reservados na cadeia de caracteres, definindo como os argumentos subsequentes da função devem ser formatados e inseridos no resultado. Cada formatarg é convertido em texto conforme as regras de saída usuais para o seu tipo de dados e, em seguida, formatado e inserido na cadeia de caracteres de resultado segundo o(s) especificador(es) de formatação.

Os especificadores de formatação são introduzidos pelo caractere % e têm a forma

%[posição][sinalizadores][largura]tipo

onde os campos componentes são:

posição (opcional)

Uma cadeia de caracteres na forma n$ onde n é a posição do argumento a ser impresso. A posição 1 significa o primeiro argumento após o formatstr. Se a posição for omitida, o padrão é usar o próximo argumento na sequência.

sinalizadores (opcional)

Opções adicionais que controlam como a saída do especificador de formatação é formatada. No momento, o único sinalizador com suporte é o sinal de menos (-), que faz com que a saída do especificador de formatação seja justificada à esquerda. Esse sinalizador não tem efeito, a menos que o campo largura também seja especificado.

largura (opcional)

Especifica o número mínimo de caracteres a serem usados para exibir a saída do especificador de formatação. A saída é preenchida à esquerda ou à direita (dependendo do sinalizador -), com espaços conforme seja necessário para preencher a largura. Uma largura muito pequena não causa truncamento da saída, é simplesmente ignorada. A largura pode ser especificada usando qualquer uma das seguintes opções: um inteiro positivo; um asterisco (*) para usar o próximo argumento da função como largura; ou uma cadeia de caracteres na forma *n$ para usar o n-ésimo argumento da função como largura.

Se a largura vier de um argumento da função, esse argumento será consumido antes do argumento usado para o valor do especificador de formatação. Se o argumento de largura for negativo, o resultado será alinhado à esquerda (como se o sinalizador - tivesse sido especificado) dentro de um campo de comprimento abs(largura).

tipo (requerido)

O tipo de conversão de formato a ser usado para produzir a saída do especificador de formatação. Os seguintes tipos têm suporte:

  • s formata o valor do argumento como uma cadeia de caracteres simples. O valor nulo é tratado como uma cadeia de caracteres vazia.

  • I trata o valor do argumento como um identificador SQL, colocando-o entre aspas, se for necessário. É errado o valor ser nulo (equivalente a quote_ident).

  • L delimita o valor do argumento como um literal SQL. O valor nulo é mostrado como a cadeia de caracteres NULL, sem aspas (equivalente a quote_nullable).

Além dos especificadores de formatação descritos acima, a sequência especial %% pode ser usada para produzir o caractere literal %.

Abaixo estão alguns exemplos das conversões básicas de formato:

SELECT format('Hello %s', 'World');
→ Hello World

SELECT format('Testing %s, %s, %s, %%', 'one', 'two', 'three');
→ Testing one, two, three, %

SELECT format('INSERT INTO %I VALUES(%L)', 'Foo bar', E'O\'Reilly');
→ INSERT INTO "Foo bar" VALUES('O''Reilly')

SELECT format('INSERT INTO %I VALUES(%L)', 'locations', 'C:\Program Files');
→ INSERT INTO locations VALUES('C:\Program Files')

Abaixo estão alguns exemplos usando o campo largura e o sinalizador -:

SELECT format('|%10s|', 'foo');
→ |       foo|

SELECT format('|%-10s|', 'foo');
→ |foo       |

SELECT format('|%*s|', 10, 'foo');
→ |       foo|

SELECT format('|%*s|', -10, 'foo');
→ |foo       |

SELECT format('|%-*s|', 10, 'foo');
→ |foo       |

SELECT format('|%-*s|', -10, 'foo');
→ |foo       |

Estes exemplos mostram o uso do campo posição:

SELECT format('Testing %3$s, %2$s, %1$s', 'one', 'two', 'three');
→ Testing three, two, one

SELECT format('|%*2$s|', 'foo', 10, 'bar');
→ |       bar|

SELECT format('|%1$*2$s|', 'foo', 10, 'bar');
→ |       foo|

Diferentemente da função padrão sprintf da linguagem C, a função format do PostgreSQL permite que especificadores de formatação com e sem o campo posição sejam misturados na mesma cadeia de caracteres de formatação. Um especificador de formatação sem o campo posição sempre usa o próximo argumento após o último argumento consumido. Além disso, a função format não requer que todos os argumentos da função sejam usados na cadeia de caracteres de formatação. Por exemplo:

SELECT format('Testando %3$s, %2$s, %s', 'um', 'dois', 'três');
→ Testando três, dois, três

Os especificadores de formatação %I e %L são particularmente úteis para a construção segura de instruções SQL dinâmicas. Veja o Exemplo 41.1.