PostgreSQL: Diferença entre texto e varchar (variação de caracteres)

Qual é a diferença entre o texttipo de dados e os tipos de dados character varying( varchar)?

De acordo com a documentação

Se a variação de caracteres for usada sem o especificador de comprimento, o tipo aceitará seqüências de caracteres de qualquer tamanho. Este último é uma extensão do PostgreSQL.

e

Além disso, o PostgreSQL fornece o tipo de texto, que armazena seqüências de caracteres de qualquer tamanho. Embora o texto do tipo não esteja no padrão SQL, vários outros sistemas de gerenciamento de banco de dados SQL também o possuem.

Então qual a diferença?

Não há diferença, por baixo do capô é tudo varlena( matriz de comprimento variável ).

Verifique este artigo da Depesz: http://www.depesz.com/index.php/2010/03/02/charx-vs-varcharx-vs-varchar-vs-text/

Alguns destaques:

Para resumir tudo:

• char (n) - ocupa muito espaço ao lidar com valores menores que n(preenche-os n) e pode levar a erros sutis devido à adição de espaços finais, além de ser problemático alterar o limite
• varchar (n) - é problemático alterar o limite no ambiente ativo (requer bloqueio exclusivo ao alterar a tabela)
• varchar - assim como o texto
• texto - para mim um vencedor - sobre (n) tipos de dados porque não possui problemas e sobre varchar - porque possui um nome distinto

O artigo faz testes detalhados para mostrar que o desempenho das inserções e seleções para todos os quatro tipos de dados é semelhante. Ele também analisa detalhadamente maneiras alternativas de restringir o comprimento quando necessário. Restrições ou domínios baseados em funções fornecem a vantagem do aumento instantâneo da restrição de comprimento e, com base no fato de que diminuir uma restrição de comprimento de sequência é raro, depesz conclui que uma delas geralmente é a melhor opção para um limite de comprimento.

Como " tipos de caracteres " nos pontos de documentação para fora, varchar(n), char(n), e textsão armazenados da mesma maneira. A única diferença é que são necessários ciclos extras para verificar o comprimento, se houver, e o espaço e tempo extras necessários para o preenchimento char(n).

No entanto, quando você só precisa armazenar um único caractere, há uma pequena vantagem de desempenho em usar o tipo especial "char"(mantenha as aspas duplas - elas fazem parte do nome do tipo). Você obtém acesso mais rápido ao campo e não há sobrecarga para armazenar o comprimento.

Acabei de criar uma tabela de 1.000.000 de caracteres aleatórios "char"escolhidos no alfabeto minúsculo. Uma consulta para obter uma distribuição de frequência ( select count(*), field ... group by field) leva cerca de 650 milissegundos, contra cerca de 760 nos mesmos dados usando um textcampo.

ATUALIZAÇÃO DE BENCHMARKS PARA 2016 (pág. 9.5 +)

E usando benchmarks "puro SQL" (sem nenhum script externo)

1. use qualquer string_generator com UTF8

2. principais benchmarks:

   2.1 INSERIR

   2.2 SELECIONAR comparando e contando

CREATE FUNCTION string_generator(int DEFAULT 20,int DEFAULT 10) RETURNS text AS $f$
  SELECT array_to_string( array_agg(
    substring(md5(random()::text),1,$1)||chr( 9824 + (random()*10)::int )
  ), ' ' ) as s
  FROM generate_series(1, $2) i(x);
$f$ LANGUAGE SQL IMMUTABLE;

Preparar teste específico (exemplos)

DROP TABLE IF EXISTS test;
-- CREATE TABLE test ( f varchar(500));
-- CREATE TABLE test ( f text); 
CREATE TABLE test ( f text  CHECK(char_length(f)<=500) );

Execute um teste básico:

INSERT INTO test  
   SELECT string_generator(20+(random()*(i%11))::int)
   FROM generate_series(1, 99000) t(i);

E outros testes,

CREATE INDEX q on test (f);

SELECT count(*) FROM (
  SELECT substring(f,1,1) || f FROM test WHERE f<'a0' ORDER BY 1 LIMIT 80000
) t;

... E use EXPLAIN ANALYZE.

ATUALIZADO NOVAMENTE 2018 (página 10)

pouca edição para adicionar os resultados de 2018 e reforçar as recomendações.

Resultados em 2016 e 2018

Meus resultados, depois da média, em muitas máquinas e muitos testes: todos iguais
(estatisticamente menos do que o desvio padrão).

Recomendação

• Use o texttipo de dados,
  evite o antigo, varchar(x)porque às vezes não é um padrão, por exemplo, nas CREATE FUNCTIONcláusulas varchar(x)≠varchar(y) .

• expressar limites (com o mesmo varchardesempenho!) por com CHECKcláusula no CREATE TABLE
  eg CHECK(char_length(x)<=10).
  Com uma perda insignificante de desempenho em INSERT / UPDATE, você também pode controlar intervalos e estrutura de cadeias,
  por exemploCHECK(char_length(x)>5 AND char_length(x)<=20 AND x LIKE 'Hello%')

No manual do PostgreSQL

Não há diferença de desempenho entre esses três tipos, além do aumento do espaço de armazenamento ao usar o tipo preenchido em branco e alguns ciclos extras de CPU para verificar o comprimento ao armazenar em uma coluna com restrição de comprimento. Embora o caractere (n) tenha vantagens de desempenho em alguns outros sistemas de banco de dados, não existe essa vantagem no PostgreSQL; de fato, o caractere (n) geralmente é o mais lento dos três devido aos seus custos adicionais de armazenamento. Na maioria das situações, a variação de texto ou caractere deve ser usada.

Eu costumo usar texto

Referências: http://www.postgresql.org/docs/current/static/datatype-character.html

Na minha opinião, varchar(n)tem suas próprias vantagens. Sim, todos eles usam o mesmo tipo subjacente e tudo isso. Porém, deve-se ressaltar que os índices no PostgreSQL têm seu limite de tamanho de 2712 bytes por linha.

TL; DR: Se você usar o texttipo sem restrição e tiver índices nessas colunas, é muito possível que você atinja esse limite para algumas de suas colunas e receba um erro ao tentar inserir dados, mas com o uso varchar(n), poderá evitá-lo.

Mais alguns detalhes: O problema aqui é que o PostgreSQL não oferece nenhuma exceção ao criar índices para o texttipo ou varchar(n)onde né maior que 2712. No entanto, ocorrerá um erro ao tentar inserir um registro com tamanho compactado maior que 2712. Isso significa que você pode inserir 100.000 caracteres da sequência, que é composta por caracteres repetitivos facilmente, porque será compactada muito abaixo de 2712, mas talvez não seja possível inserir uma sequência com 4000 caracteres, porque o tamanho compactado é maior que 2712 bytes. Usando varchar(n)onde nnão é muito maior que 2712, você está seguro contra esses erros.

text e varchar têm diferentes conversões implícitas de tipo. O maior impacto que notei é a manipulação de espaços à direita. Por exemplo ...

select ' '::char = ' '::varchar, ' '::char = ' '::text, ' '::varchar = ' '::text

retorna true, false, truee não true, true, truecomo você poderia esperar.

Um pouco OT: se você estiver usando o Rails, a formatação padrão das páginas da web pode ser diferente. Para formulários de entrada de dados, as textcaixas podem ser roladas, mas as caixas character varying(Rails string) são de uma linha. As exibições de exibição duram o necessário.

Uma boa explicação de http://www.sqlines.com/postgresql/datatypes/text :

A única diferença entre TEXT e VARCHAR (n) é que você pode limitar o comprimento máximo de uma coluna VARCHAR, por exemplo, VARCHAR (255) não permite inserir uma sequência com mais de 255 caracteres.

Tanto o TEXT quanto o VARCHAR têm o limite superior de 1 Gb e não há diferença de desempenho entre eles (de acordo com a documentação do PostgreSQL).

character varying(n), varchar(n)- (Ambos iguais). o valor será truncado para n caracteres sem gerar um erro.

character(n), char(n)- (Ambos iguais). comprimento fixo e preenchido com espaços em branco até o final do comprimento.

text- comprimento ilimitado.

Exemplo:

Table test:
   a character(7)
   b varchar(7)

insert "ok    " to a
insert "ok    " to b

Nós obtemos os resultados:

a        | (a)char_length | b     | (b)char_length
----------+----------------+-------+----------------
"ok     "| 7              | "ok"  | 2