Início / dba / Perguntas / 125499
Accepted
keypress
Asked: 2016-01-08 05:20:06 +0800 CST

Qual é a sobrecarga para varchar(n)?

  • 772

Eu queria perguntar o significado deste fragmento do documento do Postgres em relação ao varchar(n)tipo:

O requisito de armazenamento para uma string curta (até 126 bytes) é de 1 byte mais a string real, que inclui o preenchimento de espaço no caso de caractere. Strings mais longas têm 4 bytes de sobrecarga em vez de 1.

Vamos supor que eu tenha um varchar(255)campo. E agora, as seguintes afirmações:

  • Se esse campo contiver uma string de 10 bytes, a sobrecarga será de 1 byte. Portanto, a string usará 11 bytes.
  • Se o campo contiver string usando 140 bytes, a sobrecarga será de 4 bytes. Portanto, a string usará 144 bytes.

Essas afirmações acima são verdadeiras? Aqui alguém entende o documento da mesma forma que eu, mas aqui alguém afirma que a sobrecarga é sempre de 4 bytes aqui ?

postgresql varchar

1 respostas

  1. Best Answer

    Sem surpresa, o manual está certo. Mas há mais do que isso.

    Por um lado, o tamanho no disco (em qualquer tabela , mesmo quando não estiver realmente armazenado no disco) pode ser diferente do tamanho na memória . No disco, a sobrecarga para varcharvalores curtos de até 126 bytes é reduzida para 1 byte , conforme indicado no manual. Mas a sobrecarga na memória é sempre de 4 bytes (uma vez que os valores individuais são extraídos).

    O mesmo é verdadeiro para text, ou varchar-varchar(n)char(n) exceto que char(n)é preenchido com ncaracteres em branco e você normalmente não deseja usá-lo. Seu tamanho efetivo ainda pode variar em codificações multibyte porque ndenota um máximo de caracteres, não bytes:

    strings de até ncaracteres (não bytes) de comprimento.

    Todos eles usam varlenainternamente.
    "char"(entre aspas) é uma criatura diferente e sempre ocupa um único byte.
    Literais de cadeia de caracteres não digitados ( 'foo') têm uma sobrecarga de um único byte. Não deve ser confundido com valores digitados!

    Teste com pg_column_size().

    CREATE TEMP TABLE t (id int, v_small varchar, v_big varchar);
INSERT INTO t VALUES (1, 'foo', '12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890');

SELECT pg_column_size(id)        AS id
     , pg_column_size(v_small)   AS v_small
     , pg_column_size(v_big)     AS v_big
     , pg_column_size(t)         AS t
FROM   t
UNION ALL  -- 2nd row measuring values in RAM
SELECT pg_column_size(1)
     , pg_column_size('foo'::varchar)
     , pg_column_size('12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890'::varchar)
     , pg_column_size(ROW(1, 'foo'::varchar, '12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890'::varchar));

 id | v_small | v_big |  t
----+---------+-------+-----
  4 |       4 |   144 | 176
  4 |       7 |   144 | 176

    Como você pode ver:

    • A string de 3 bytes 'foo' ocupa 4 bytes no disco e 7 bytes na RAM (portanto, 1 byte contra 4 bytes de sobrecarga).
    • A string de 140 bytes '123...' ocupa 144 bytes tanto no disco quanto na RAM (portanto, sempre 4 bytes de sobrecarga).
    • O armazenamento de integernão tem sobrecarga (mas tem requisitos de alinhamento que podem impor preenchimento).
    • A linha tem uma sobrecarga adicional de 24 bytes para o cabeçalho da tupla (mais 4 bytes adicionais por tupla para o identificador de item no cabeçalho da página).
    • E por último, mas não menos importante: a sobrecarga do pequeno varcharainda é de apenas 1 byte enquanto não foi extraído da linha - como pode ser visto no tamanho da linha. (É por isso que às vezes é um pouco mais rápido selecionar linhas inteiras.)

    Relacionado:

    • 29

relate perguntas