Postgresql - modifica la dimensione di una colonna varchar

Question

Ho una domanda sul comando ALTER TABLE su una tabella molto grande (quasi 30 milioni di righe). Una delle sue colonne è un varchar(255) e vorrei ridimensionarlo a un varchar(40). In sostanza, vorrei cambiare la mia colonna eseguendo il comando seguente:

ALTER TABLE mytable ALTER COLUMN mycolumn TYPE varchar(40); 

non ho alcun problema se il processo è molto lungo, ma a quanto pare il mio tavolo non è più leggibile durante il comando ALTER TABLE. C'è un modo più intelligente? Forse aggiungere una nuova colonna, copiare i valori dalla vecchia colonna, rilasciare la vecchia colonna e rinominare infine quella nuova?

Qualsiasi indizio sarà molto apprezzato! Grazie in anticipo,

Nota: utilizzo PostgreSQL 9.0.

Answer 1

C'è una descrizione di come fare questo a Resize a column in a PostgreSQL table without changing data. Devi hackerare i dati del catalogo del database. L'unico modo per farlo ufficialmente è con ALTER TABLE e, come hai notato, il cambiamento bloccherà e riscriverà l'intera tabella mentre è in esecuzione.

Assicurati di leggere la sezione Character Types della documentazione prima di cambiarla. Tutti i tipi di casi strani di cui essere a conoscenza qui. Il controllo della lunghezza viene eseguito quando i valori vengono memorizzati nelle righe. Se si ha un limite inferiore lì, ciò non ridurrà affatto la dimensione dei valori esistenti. Sarebbe saggio fare una scansione sull'intera tabella cercando le righe in cui la lunghezza del campo è> 40 caratteri dopo aver apportato la modifica. Avrai bisogno di capire come troncare quelli manualmente - quindi sei tornato alcuni blocchi solo su quelli sovradimensionati - perché se qualcuno cerca di aggiornare qualcosa su quella riga lo rifiuterà come troppo grande ora, al punto va a memorizzare la nuova versione della riga. L'ilarità segue per l'utente.

VARCHAR è un tipo terribile che esiste in PostgreSQL solo per soddisfare la sua terribile parte associata dello standard SQL. Se non ti interessa la compatibilità multi-database, considera di memorizzare i tuoi dati come TEXT e aggiungi un vincolo per limitarne la lunghezza. Vincoli che è possibile modificare senza questo problema di blocco/riscrittura della tabella e possono eseguire un controllo di integrità maggiore rispetto al controllo della lunghezza insufficiente.

Answer 2

Ecco il numero the cache della pagina descritta da Greg Smith. Nel caso in cui muore pure, l'istruzione ALTER assomiglia a questo:

UPDATE pg_attribute SET atttypmod = 35+4 
WHERE attrelid = 'TABLE1'::regclass 
AND attname = 'COL1'; 

Dove il tavolo è TABLE1, la colonna è COL1 e si desidera impostarla a 35 caratteri (la 4 è necessario per scopi legacy secondo al link, possibilmente il sovraccarico indicato da AH nei commenti).

Answer 3

Stavo affrontando lo stesso problema cercando di troncare un VARCHAR da 32 a 8 e ottenere il ERROR: value too long for type character varying(8). Voglio stare il più vicino possibile a SQL perché sto usando una struttura auto-costruita simile a JPA che potremmo dover passare a diversi DBMS in base alle scelte del cliente (PostgreSQL è quello predefinito). Quindi, non voglio usare il trucco di alterare le tabelle di sistema.

ho finito utilizzando l'istruzione USING nella ALTER TABLE:

ALTER TABLE "MY_TABLE" ALTER COLUMN "MyColumn" TYPE varchar(8) 
USING substr("MyColumn", 1, 8) 

non ho davvero considerato le implicazioni se la tabella si accede da un altro programma o se la tabella è indicizzato. Presumo che Postgres faccia questo tipo di automaticamente?

Answer 4

Ho trovato un modo molto semplice per modificare le dimensioni, ad esempio l'annotazione @Size (min = 1, max = 50) che fa parte di "import javax.validation.constraints" ovvero "import javax.validation.constraints .Dimensione;"

@Size(min = 1, max = 50) 
private String country; 


when executing this is hibernate you get in pgAdmin III 


CREATE TABLE address 
(
..... 
    country character varying(50), 

..... 

) 

Answer 5

Ok, sono probabilmente in ritardo alla festa, ma ...

NON c'è bisogno di ridimensionare la colonna nel tuo caso!

Postgres, a differenza di altri database, è abbastanza intelligente da utilizzare solo lo spazio sufficiente per adattarsi alla stringa (anche utilizzando la compressione per stringhe più lunghe), quindi anche se la colonna è dichiarata come VARCHAR (255) - se si memorizza 40 stringhe di caratteri nella colonna, l'utilizzo dello spazio sarà di 40 byte + 1 byte di sovraccarico.

La memorizzazione necessario per una breve stringa (fino a 126 byte) è 1 byte più la stringa effettiva, che comprende l'imbottitura spazio nel caso di carattere. Stringhe più lunghe hanno 4 byte di overhead anziché 1. Le stringhe lunghe vengono compresse automaticamente dal sistema, pertanto il requisito fisico su disco potrebbe essere inferiore. I valori molto lunghi sono anche memorizzati nelle tabelle di sfondo in modo che non interferiscano con l'accesso rapido ai valori di colonna più brevi.

(http://www.postgresql.org/docs/9.0/interactive/datatype-character.html)

La specifica dimensione in VARCHAR viene utilizzato solo per controllare la dimensione dei valori che vengono inseriti, non influenza il layout del disco. Infatti, VARCHAR and TEXT fields are stored in the same way in Postgres.

Answer 6

Aggiunta nuova colonna e la sostituzione di uno nuovo con il vecchio lavorato per me, su PostgreSQL redshift, consultare questo link per maggiori informazioni https://gist.github.com/mmasashi/7107430

BEGIN; 
LOCK users; 
ALTER TABLE users ADD COLUMN name_new varchar(512) DEFAULT NULL; 
UPDATE users SET name_new = name; 
ALTER TABLE users DROP name; 
ALTER TABLE users RENAME name_new TO name; 
END; 

Answer 7

In PostgreSQL 9.1 c'è un modo più semplice

http://www.postgresql.org/message-id/162867790801110710g3c686010qcdd852e721e7a559@mail.gmail.com

CREATE TABLE foog(a varchar(10)); 

ALTER TABLE foog ALTER COLUMN a TYPE varchar(30); 

postgres=# \d foog 

Table "public.foog" 
Column |   Type   | Modifiers 
--------+-----------------------+----------- 
a  | character varying(30) | 

Answer 8

se si inserisce la modifica in una transazione, la tabella non deve essere bloccata:

BEGIN; 
    ALTER TABLE "public"."mytable" ALTER COLUMN "mycolumn" TYPE varchar(40); 
COMMIT; 

questo ha funzionato per me sfolgorante velocemente, pochi secondi su un tavolo con più di 400k righe.