PostgreSQL: Diferența dintre text și varchar (caractere diferite)

Nu există nici o diferență, sub capota se's toate varlena (lungime variabilă array).

Verificați acest articol din Depesz: http://www.depesz.com/index.php/2010/03/02/charx-vs-varcharx-vs-varchar-vs-text/

Câteva repere:

Pentru a rezuma totul:

• char(n) – are prea mult spațiu atunci când se ocupă cu valori mai scurt decât n (tampoane de ele pentru a "n"), și poate duce la subtile erori din cauza adăugând la sfârșit spații, plus că este problematic de a modifica limita de
• varchar(n) – l's problematică pentru a schimba limita în mediu live (necesită exclusiv de blocare în timp ce modificarea tabelul)
• varchar – doar ca text
• text – pentru mine un câștigător – peste (n) tipuri de date, deoarece nu dispune de problemele lor, și peste varchar – pentru că are nume diferite

Articolul face teste detaliate pentru a arăta că performanța de inserții și selectează pentru toate cele 4 tipuri de date sunt similare. Ea are, de asemenea, o privire detaliată la modalități alternative de pe constrângere lungimea atunci când este necesar. Funcție de constrângerile sau domenii oferă avantajul de a crește instant de lungimea de constrângere, și pe baza faptului că descrescătoare a unui șir de lungime constrângere este rară, depesz concluzionează că una dintre ele este de obicei cea mai bună alegere pentru o limită de lungime.

Ca "Tipuri de Caractere" în documentația de puncte, pentru varchar(n),char(n), și "text" sunt toate stocate în același mod. Singura diferență este extra cicluri sunt necesare pentru a verifica lungimea, dacă unul este dat, și spațiu suplimentar și timpul necesar dacă umplutură este necesar pentru char(n).

Cu toate acestea, atunci când aveți nevoie doar pentru a stoca un singur caracter, există o ușoară avantaj de performanță pentru a utiliza speciale de tip `"char" (se ține dublu-citate — au're o parte din nume de tip). Veți obține acces mai rapid la câmp, și nu există nici o deasupra capului pentru a stoca lungime.

Am făcut doar o masă de 1.000.000 aleatorie"char"ales din litere mici alfabet. O interogare pentru a obține o frecvență de distribuție (select count(*), teren ... grup de teren`) durează aproximativ 650 de milisecunde, vs aproximativ 760 pe aceleași date, folosind un "text" de teren.

ACTUALIZAREA REFERINȚĂ PENTRU 2016 (pg9.5+)

Și folosind "pur SQL" indicii de referință (fără nici un script extern)

1. folosi orice string_generator cu UTF8

2. principalele criterii de referință:

2.1. INTRODUCE

2.2. SELECTAȚI comparare și numărare

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;

Pregătiți de testare specifice (exemple)

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) );

Efectuați un test de bază:

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

Și alte teste,

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;

... Și de a folosi EXPLICA ANALIZA.

ACTUALIZAT din NOU 2018 (pg10)

pic de editare pentru a adăuga 2018's rezultatele și de a consolida recomandări.

Rezultate în 2016 și 2018

Rezultatele mele, după medie, în mai multe mașini și mai multe teste: toate la fel
(statistic mai puțin tham abaterea standard).

Recomandare

• Utilizarea "text" tip de date,
  evitarea vechi varchar(x) pentru că, uneori, nu este un standard, de exemplu, pentru a CREA o FUNCȚIE de clauzele privind varchar(x)≠varchar(y).

• exprima limitele (cu același varchar performanta!) de cu "CHECK" clauză în create TABLE
  de exemplu, VERIFICARE(char_length(x)<=10).
  Cu o pierdere neglijabilă de performanță în INSERT/UPDATE puteți, de asemenea, pentru a controla variază și șir structura
  de exemplu, VERIFICARE(char_length(x)>5 ȘI char_length(x)<=20 x CA &#39;Alo%&#39;)

Pe PostgreSQL manual

Nu există nici o diferență de performanță între aceste trei tipuri, în afară de spațiu de stocare mai mare atunci când se utilizează gol căptușit tip, și un plus cateva cicluri CPU pentru a verifica lungimea atunci când stocarea într-o lungime limitată în coloană. În timp ce personajul(n) are avantaje de performanță în alte sisteme de baze de date, nu există nici un astfel de avantaj în PostgreSQL; în fapt, personajul(n) este de obicei cel mai lent dintre cele trei, din cauza sale costuri de depozitare suplimentare. În cele mai multe situații text sau caractere diferite ar trebui să fie folosit în loc.

Eu folosesc, de obicei text

Referințe: http://www.postgresql.org/docs/current/static/datatype-character.html

În opinia mea, varchar(n) a's avantaje proprii. Da, toate folosesc același tip de fond al sistemului și toate astea. Dar, trebuie subliniat faptul că indicii în PostgreSQL are o limită de dimensiune de 2712 bytes pe rând.

TL;DR: Dacă utilizați "text" tip fără o constrângere și au indici de pe aceste coloane, este foarte posibil ca te-a lovit această limită pentru unele dintre coloane și de a lua de eroare atunci când încercați să introduceți date dar cu ajutorul `varchar(n), se poate preveni.

Mai multe detalii: problema aici este că PostgreSQL nu't da orice excepții atunci când crearea de indici pentru "text" tip sau varchar(n), unde " n " este mai mare decât 2712. Cu toate acestea, se va da eroare atunci când o înregistrare comprimat cu dimensiunea mai mare decât 2712 se încearcă să fie introdus. Aceasta înseamnă că puteți introduce 100.000 de caracter din șir care este compus din repetitive caractere ușor, pentru că va fi comprimat cu mult sub 2712 dar este posibil să nu fi capabil de a introduce un șir de caractere cu 4000 de caractere, deoarece dimensiunea comprimat este mai mare decât 2712 bytes. Folosindvarchar(n), unde " n " este nu prea mult mai mare decât 2712, ai're în siguranță de la aceste erori.

text și varchar au diferite conversii de tip implicite. Cel mai mare impact pe care am'am observat că se ocupă de spații. De exemplu ...

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

se întoarce true, false, true "și nu" adevărat, adevărat, adevărat ca s-ar putea aștepta.

Oarecum OT: Daca're folosind Șine, standard de formatare a paginilor web pot fi diferite. Pentru formulare de introducere a datelor "text" cutii sunt derulabil, dar caracterul variabil(Șinestring`) casetele sunt pe o singură linie. Spectacol de vedere sunt la fel de mult ca este necesar.

character varying(n), varchar(n) - (Ambele la fel). valoarea va fi trunchiat la n caractere, fără a ridica o eroare.

personaj(n), char(n) - (Ambele la fel). de lungime fixă și va pad cu gloanțe oarbe până la sfârșitul lungime.

"text" - lungime Nelimitată.

Exemplu:

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

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

Am primit rezultatele:

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