8.3. Tipos para cadeias de caracteres

A Tabela 8-4 mostra os tipos de propósito geral para cadeias de caracteres disponíveis no PostgreSQL.

O SQL define dois tipos primários para caracteres: character varying(n) e character(n), onde n é um número inteiro positivo. Estes dois tipos podem armazenar cadeias de caracteres com comprimento de até n caracteres. A tentativa de armazenar uma cadeia de caracteres mais longa em uma coluna de um destes tipos resulta em erro, a não ser que os caracteres excedentes sejam todos espaços; neste caso a cadeia de caracteres será truncada em seu comprimento máximo (Esta exceção um tanto bizarra é requerida pelo padrão SQL). Se a cadeia de caracteres a ser armazenada for mais curta que o comprimento declarado, os valores do tipo character são completados com espaços; os valores do tipo character varying simplesmente armazenam uma cadeia de caracteres mais curta.

Se um valor for convertido explicitamente (cast) para character varying(n), ou para character(n), o excesso de comprimento será truncado para n caracteres sem gerar erro (isto também é requerido pelo padrão SQL).

As notações varchar(n) e char(n) são sinônimos para character varying(n) e character(n), respectivamente. O uso de character sem especificação de comprimento equivale a character(1); se for utilizado character varying sem especificador de comprimento, este tipo aceita cadeias de caracteres de qualquer tamanho. Este último é uma extensão do PostgreSQL.

Além desses o PostgreSQL disponibiliza o tipo text, que armazena cadeias de caracteres de qualquer comprimento. Embora o tipo text não esteja no padrão SQL, vários outros sistemas gerenciadores de banco de dados SQL também o possuem.

São necessários para armazenar dados destes tipos 4 bytes mais a própria cadeia de caracteres e, no caso do tipo character, mais os espaços para completar o tamanho. As cadeias de caracteres longas são comprimidas automaticamente pelo sistema e, portanto, o espaço físico necessário em disco pode ser menor. Os valores longos também são armazenados em tabelas secundárias, para não interferirem com o acesso rápido aos valores mais curtos da coluna. De qualquer forma, a cadeia de caracteres mais longa que pode ser armazenada é em torno de 1 GB (O valor máximo permitido para n na declaração do tipo de dado é menor que isto. Não seria muito útil mudar, porque de todo jeito nas codificações de caractere multibyte o número de caracteres e de bytes podem ser bem diferentes. Se for desejado armazenar cadeias de caracteres longas, sem um limite superior especificado, deve ser utilizado text ou character varying sem a especificação de comprimento, em vez de especificar um limite de comprimento arbitrário).

Consulte a Seção 4.1.2.1 para obter informações sobre a sintaxe dos literais cadeias de caracteres, e o Capítulo 9 para obter informações sobre os operadores e funções.

Existem dois outros tipos para cadeias de caracteres de comprimento fixo no PostgreSQL, mostrados na Tabela 8-5 . O tipo name existe apenas para armazenamento de identificadores nos catálogos internos do sistema, não tendo por finalidade ser usado pelos usuários comuns. Seu comprimento é definido atualmente como 64 bytes (63 caracteres utilizáveis mais o terminador) mas deve ser referenciado utilizando a constante NAMEDATALEN. O comprimento é definido quando é feita a compilação (sendo, portanto, ajustável para usos especiais); o padrão para comprimento máximo poderá mudar em uma versão futura. O tipo "char" (observe as aspas) é diferente de char(1), porque utiliza apenas um byte para armazenamento. É utilizado internamente nos catálogos do sistema como o tipo de enumeração do homem pobre (poor-man's enumeration type).

=> CREATE TABLE teste1 (a character(4));
=> INSERT INTO teste1 VALUES ('ok');
=> SELECT a, char_length(a) FROM teste1; -- 
(1)


  a   | char_length
------+-------------
 ok   |           4

=> CREATE TABLE teste2 (b VARCHAR(5));
=> INSERT INTO teste2 VALUES ('ok');
=> INSERT INTO teste2 VALUES ('bom        '); -- 
(2)

=> INSERT INTO teste2 VALUES ('muito longo');
ERRO:  valor muito longo para o tipo character varying(5)
=> INSERT INTO teste2 VALUES (CAST('muito longo' AS VARCHAR(5))); -- truncamento explícito
=> SELECT b, char_length(b) FROM teste2;

   b   | char_length
-------+-------------
 ok    |           2
 bom   |           5
 muito |           5

CREATE TABLE t1 ( c1 CHAR(10), c2 CHAR(10));
INSERT INTO t1 VALUES ('X', 'X ');
SELECT '''' || c1 || '''' AS c1,
       '''' || c2 || '''' AS c2,
       CASE WHEN (c1=c2) THEN 'igual' ELSE 'diferente' END AS comparação
FROM t1;

CREATE TABLE t2 ( c1 VARCHAR(10), c2 VARCHAR(10));
INSERT INTO t2 VALUES ('X', 'X ');
SELECT '''' || c1 || '''' AS c1,
       '''' || c2 || '''' AS c2,
       CASE WHEN (c1=c2) THEN 'igual' ELSE 'diferente' END AS comparação
FROM t2;

CREATE TABLE t3 ( c1 CHAR(10), c2 VARCHAR(10));
INSERT INTO t3 VALUES ('X', 'X ');
INSERT INTO t3 VALUES ('X ', 'X');
SELECT '''' || c1 || '''' AS c1,
       '''' || c2 || '''' AS c2,
       CASE WHEN (c1=c2) THEN 'igual' ELSE 'diferente' END AS comparação
FROM t3;

 c1  | c2  | comparação
-----+-----+------------
 'X' | 'X' | igual

 c1  |  c2  | comparação
-----+------+------------
 'X' | 'X ' | diferente

 c1  |  c2  | comparação
-----+------+------------
 'X' | 'X ' | igual
 'X' | 'X'  | igual

c1           c2           comparação
------------ ------------ ----------
'X         ' 'X         ' igual

c1           c2           comparação
------------ ------------ ----------
'X'          'X '         igual

c1           c2           comparação
------------ ------------ ----------
'X         ' 'X '         igual
'X         ' 'X'          igual

C1           C2           COMPARAÇÃO
------------ ------------ ----------
'X         ' 'X         ' igual

C1           C2           COMPARAÇÃO
------------ ------------ ----------
'X'          'X '         diferente

C1           C2           COMPARAÇÃO
------------ ------------ ----------
'X         ' 'X '         diferente
'X         ' 'X'          diferente

C1           C2           COMPARAÇÃO
------------ ------------ ----------
'X         ' 'X         ' igual

C1           C2           COMPARAÇÃO
------------ ------------ ----------
'X'          'X '         igual

C1           C2           COMPARAÇÃO
------------ ------------ ----------
'X         ' 'X '         igual
'X         ' 'X'          igual