8.1.1. Tipos inteiros

Os tipos smallint, integer e bigint armazenam números inteiros, ou seja, números sem a parte fracionária, com faixas diferentes. A tentativa de armazenar um valor fora da faixa permitida resulta em erro.

O tipo integer é a escolha usual, porque oferece o melhor equilíbrio entre faixa de valores, tamanho de armazenamento e desempenho. Geralmente o tipo smallint só é utilizado quando o espaço em disco está muito escasso. O tipo bigint somente deve ser usado quando a faixa de valores de integer não for suficiente, porque este último é bem mais rápido.

O tipo bigint pode não funcionar de modo correto em todas as plataformas, porque depende de suporte no compilador para inteiros de oito bytes. Nas máquinas sem este suporte, o bigint age do mesmo modo que o integer (mas ainda ocupa oito bytes de armazenamento). Entretanto, não é de nosso conhecimento nenhuma plataforma razoável onde este caso se aplique.

O padrão SQL somente especifica os tipos inteiros integer (ou int) e smallint. O tipo bigint, e os nomes de tipo int2, int4 e int8 são extensões, também compartilhadas por vários outros sistemas de banco de dados SQL.

8.1.2. Números com precisão arbitrária

O tipo numeric pode armazenar números com precisão de até 1.000 dígitos e realizar cálculos exatos. É recomendado, especialmente, para armazenar quantias monetárias e outras quantidades onde se requeira exatidão. Entretanto, a aritmética em valores do tipo numeric é muito lenta se comparada com os tipos inteiros, ou com os tipos de ponto flutuante descritos na próxima seção.

São utilizados os seguintes termos: A escala do tipo numeric é o número de dígitos decimais da parte fracionária, à direita do ponto decimal. A precisão do tipo numeric é o número total de dígitos significativos de todo o número, ou seja, o número de dígitos nos dois lados do ponto decimal. Portanto, o número 23.5141 [5] possui precisão igual a 6 e escala igual a 4. Os inteiros podem ser considerados como tendo escala igual a zero.

Tanto a precisão máxima quanto a escala de uma coluna do tipo numeric podem ser configuradas. Para declarar uma coluna do tipo numeric é utilizada a sintaxe:

NUMERIC(precisão, escala)

A precisão deve ser um número positivo, enquanto a escala pode ser zero ou positiva. Como forma alternativa,

NUMERIC(precisão)

define a escala como sendo igual a 0. Especificando-se

NUMERIC

sem qualquer precisão ou escala é criada uma coluna onde podem ser armazenados valores numéricos com qualquer precisão ou escala, até a precisão limite da implementação. Uma coluna deste tipo não converte os valores de entrada para nenhuma escala em particular, enquanto as colunas do tipo numeric com escala declarada convertem os valores da entrada para esta escala (O padrão SQL requer a escala padrão igual a 0, ou seja, uma conversão para a precisão inteira. Isto foi considerado sem utilidade. Havendo preocupação com a portabilidade, a precisão e a escala devem ser sempre especificadas explicitamente).

Se a escala do valor a ser armazenado for maior que a escala declarada para a coluna, o sistema arredonda o valor para o número de dígitos fracionários especificado. Depois, se o número de dígitos à esquerda do ponto decimal exceder a precisão declarada menos a escala declarada, é gerado um erro.

BEGIN;
CREATE TEMPORARY TABLE t ( c NUMERIC(6,3)) ON COMMIT DROP;
INSERT INTO t VALUES (998.9991);
INSERT INTO t VALUES (998.9999);
SELECT * FROM t;

    c
---------
 998.999
 999.000
(2 linhas)

INSERT INTO t VALUES (999.9999);

ERRO:  estouro de campo numérico
DETALHE:  O valor absoluto é maior ou igual a 10^3 para campo com precisão 6, escala 3.

COMMIT;
ROLLBACK

Os valores numéricos são armazenados fisicamente sem zeros adicionais no início ou no final. Portanto, a precisão e a escala declaradas para uma coluna são as alocações máximas, e não fixas (Sob este aspecto o tipo numeric é mais semelhante ao tipo varchar(n) do que ao tipo char(n)).

Além dos valores numéricos ordinários o tipo numeric aceita o valor especial NaN, que significa "não-é-um-número" (not-a-number). Toda operação envolvendo NaN produz outro NaN. Para escrever este valor como uma constante em um comando SQL deve-se colocá-lo entre apóstrofos como, por exemplo, UPDATE tabela SET x = 'NaN'. Na entrada, a cadeia de caracteres NaN é reconhecida sem que haja distinção entre letras maiúsculas e minúsculas.

Os tipos decimal e numeric são equivalentes. Os dois tipos fazem parte do padrão SQL.

8.1.3. Tipos de ponto flutuante

Os tipos de dado real e double precision são tipos numéricos não exatos de precisão variável. Na prática, estes tipos são geralmente implementações do "Padrão IEEE 754 para Aritmética Binária de Ponto Flutuante" (de precisão simples e dupla, respectivamente), conforme suportado pelo processador, sistema operacional e compilador utilizados.

Não exato significa que alguns valores não podem ser convertidos exatamente para o formato interno, sendo armazenados como aproximações. Portanto, ao se armazenar e posteriormente imprimir um valor podem ocorrer pequenas discrepâncias. A gerência destes erros, e como se propagam através dos cálculos, é assunto de um ramo da matemática e da ciência da computação que não será exposto aqui, exceto os seguintes pontos:

• Se for necessário armazenamento e cálculos exatos (como em quantias monetárias), em vez de tipos de ponto flutuante deve ser utilizado o tipo numeric.

• Se for desejado efetuar cálculos complicados usando tipos de ponto flutuante para algo importante, especialmente dependendo de certos comportamentos em situações limites (infinito ou muito próximo de zero), a implementação deve ser avaliada cuidadosamente.

• A comparação de igualdade de dois valores de ponto flutuante pode funcionar conforme o esperado, ou não.

Na maioria das plataformas o tipo real possui uma faixa de pelo menos 1E-37 a 1E+37, com precisão de pelo menos 6 dígitos decimais. O tipo double precision normalmente possui uma faixa em torno de 1E-307 a 1E+308 com precisão de pelo menos 15 dígitos. Os valores muito pequenos ou muito grandes causam erro. O arredondamento pode acontecer se a precisão do número entrado for muito grande. Os números muito próximos de zero, que não podem ser representados de forma distinta de zero, causam erro de underflow.

Além dos valores numéricos ordinários, os tipos de ponto flutuante possuem diversos valores especiais:

Infinity
-Infinity
NaN

O PostgreSQL também suporta a notação do padrão SQL float e float(p) para especificar tipos numéricos inexatos. Neste caso, p especifica a precisão mínima aceitável em dígitos binários. O PostgreSQL aceita de float(1) a float(24) como selecionando o tipo real, enquanto float(25) a float(53) selecionam double precision. Os valores de p fora da faixa permitida ocasionam erro. float sem precisão especificada é assumido como significando double precision.

8.1.4. Tipos seriais

Os tipos de dado serial e bigserial não são tipos verdadeiros, mas meramente uma notação conveniente para definir colunas identificadoras únicas (semelhante à propriedade AUTO_INCREMENTO existente em alguns outros bancos de dados). Na implementação corrente especificar

CREATE TABLE nome_da_tabela (
    nome_da_coluna SERIAL
);

equivale a especificar:

CREATE SEQUENCE nome_da_tabela_nome_da_coluna_seq;
CREATE TABLE nome_da_tabela (
    nome_da_coluna integer DEFAULT nextval('nome_da_tabela_nome_da_coluna_seq') NOT NULL
);

Conforme visto, foi criada uma coluna do tipo inteiro e feito o valor padrão ser atribuído a partir de um gerador de seqüência. A restrição NOT NULL é aplicada para garantir que não pode ser inserido o valor nulo explicitamente. Na maior parte das vezes, deve ser colocada uma restrição UNIQUE ou PRIMARY KEY para não permitir a inserção de valores duplicados por acidente, mas isto não é automático.

Para inserir o próximo valor da seqüência em uma coluna do tipo serial deve ser especificada a atribuição do valor padrão à coluna serial, o que pode ser feito omitindo a coluna na lista de colunas no comando INSERT, ou através da utilização da palavra chave DEFAULT.

Os nomes de tipo serial e serial4 são equivalentes: ambos criam colunas do tipo integer. Os nomes de tipo bigserial e serial8 funcionam da mesma maneira, exceto por criarem uma coluna bigint. Deve ser utilizado bigserial se forem esperados mais de 2³¹ identificadores durante a existência da tabela.

A seqüência criada para a coluna do tipo serial é removida automaticamente quando a coluna que a definiu é removida, e não pode ser removida de outra forma (Isto não era verdade nas versões do PostgreSQL anteriores a 7.3. Deve ser observado que este vínculo de remoção automática não ocorre em uma seqüência criada pela restauração da cópia de segurança de um banco de dados pré-7.3; a cópia de segurança não contém as informações necessárias para estabelecer o vínculo de dependência). Além disso, a dependência entre a seqüência e a coluna é feita apenas para a própria coluna serial; se qualquer outra coluna fizer referência à seqüência (talvez chamando manualmente a função nextval()), haverá rompimento se a seqüência for removida. Esta forma de utilizar as seqüências das colunas serial é considerada um estilo ruim. Se for desejado suprir várias colunas a partir do mesmo gerador de seqüência, a seqüência deve ser criada como um objeto independente.

=> CREATE TABLE t ( c1 SERIAL, c2 TEXT);

NOTA:  CREATE TABLE irá criar a seqüência implícita "t_c1_seq" para a coluna "serial" "t.c1"
CREATE TABLE

=> \ds

             Lista de relações
 Esquema |   Nome   |   Tipo    |   Dono
---------+----------+-----------+----------
 public  | t_c1_seq | seqüência | postgres
(1 linha)

=> ALTER SEQUENCE t_c1_seq RESTART WITH 1000;

=> INSERT INTO t VALUES (DEFAULT, 'Primeira linha');

=> SELECT * FROM t;

  c1  |       c2
------+----------------
 1000 | Primeira linha
(1 linha)