MySQL na prática: Alterando tabelas com ALTER TABLE (DDL)

Por Sérgio Lacerda
Publicado em 19/07/2021 · Revisado em 11/01/2026

Neste artigo, você vai aprender na prática como alterar estruturas de tabelas no MySQL utilizando o comando ALTER TABLE, incluindo renomear, adicionar, modificar e remover colunas com DDL.

Hoje vamos explorar os comandos DDL (Data Definition Language – subconjunto da linguagem SQL) no MySQL, aprendendo como utilizá-los para manter e evoluir a estrutura de tabelas conforme necessário.

Para nossos exemplos, vamos criar e ampliar gradativamente uma única tabela, de forma a tornar o processo mais simples para o entendimento. Nossa tabela irá conter informações sobre pessoas e, inicialmente, vamos criá-la com apenas dois campos: "IdPessoa" (chave primária da tabela) e "Nome" (irá armazenar o nome da pessoa).

/* Criando o banco de dados */
CREATE DATABASE dbPessoa;
USE dbPessoa;

/* Criando a tabela de pessoas */
CREATE TABLE Pessoas (
    IdPessoa INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
    Nome VARCHAR(80) NOT NULL
);

+----------+-------------+------+-----+---------+----------------+
| Field    | Type        | Null | Key | Default | Extra          |
+----------+-------------+------+-----+---------+----------------+
| IdPessoa | int         | NO   | PRI | NULL    | auto_increment |
| Nome     | varchar(80) | NO   |     | NULL    |                |
+----------+-------------+------+-----+---------+----------------+

Imagine agora que eu tenha cometido um erro na instrução acima. Eu criei o campo "Nome", quando, na verdade, eu queria que se chamasse "NomePessoa". Como é preciso alterar a estrutura da tabela, vamos utilizar uma instrução ALTER TABLE (alterar tabela) com uma cláusula CHANGE COLUMN (mudar coluna), conforme o exemplo abaixo:

/* Renomeando uma coluna que já existe */
ALTER TABLE Pessoas 
CHANGE COLUMN Nome NomePessoa VARCHAR(80) NOT NULL;

+------------+-------------+------+-----+---------+----------------+
| Field      | Type        | Null | Key | Default | Extra          |
+------------+-------------+------+-----+---------+----------------+
| IdPessoa   | int         | NO   | PRI | NULL    | auto_increment |
| NomePessoa | varchar(80) | NO   |     | NULL    |                |
+------------+-------------+------+-----+---------+----------------+

Ao executar o comando acima, estamos alterando o nome da coluna "Nome" para "NomePessoa". Note que foi mantido o mesmo tipo VARCHAR(80) NOT NULL, ou seja, o campo continua sendo texto de no máximo 80 caracteres, e não aceita nulo. Se quiséssemos, poderíamos mudar isso também, mas vamos ver isso um pouco mais adiante.

Se surgir um novo requisito, por exemplo, precisaremos adicionar uma coluna para armazenar a idade de cada pessoa. Novamente vamos utilizar o ALTER TABLE, mas agora adicionando uma coluna (ADD COLUMN), que será chamada de "Idade".

/* Adicionando uma nova coluna */
ALTER TABLE Pessoas 
ADD COLUMN Idade VARCHAR(3) NOT NULL;

+------------+-------------+------+-----+---------+----------------+
| Field      | Type        | Null | Key | Default | Extra          |
+------------+-------------+------+-----+---------+----------------+
| IdPessoa   | int         | NO   | PRI | NULL    | auto_increment |
| NomePessoa | varchar(80) | NO   |     | NULL    |                |
| Idade      | varchar(3)  | NO   |     | 0       |                |
+------------+-------------+------+-----+---------+----------------+

Executamos o comando e criamos com sucesso o campo "Idade", mas você deve ter percebido que eu cometi um novo erro: a idade, uma informação, por padrão, numérica, foi criada como sendo um texto - VARCHAR(3). Dessa forma, temos agora que corrigir essa falha e mudar o tipo desse campo (MODIFY COLUMN):

/* Alterando o tipo de dado de uma coluna que já existe */
ALTER TABLE Pessoas 
MODIFY COLUMN Idade INT UNSIGNED NOT NULL;

+------------+--------------+------+-----+---------+----------------+
| Field      | Type         | Null | Key | Default | Extra          |
+------------+--------------+------+-----+---------+----------------+
| IdPessoa   | int          | NO   | PRI | NULL    | auto_increment |
| NomePessoa | varchar(80)  | NO   |     | NULL    |                |
| Idade      | int unsigned | NO   |     | NULL    |                |
+------------+--------------+------+-----+---------+----------------+

Agora, nossa coluna "Idade" armazena números inteiros.

Você deve ter percebido que a coluna "Idade" foi adicionada por padrão como a última da tabela, mas às vezes precisamos inseri-la em uma posição específica.

Para exemplificar essa situação, vamos inserir uma nova coluna chamada "DataNascimento", posicionando-a entre as colunas "NomePessoa" e "Idade". Vamos usar novamente a cláusula ADD COLUMN, mas agora com AFTER NomePessoa (o novo campo será inserido após a coluna "NomePessoa").

/* Adicionando uma nova coluna em uma posição específica na tabela (Depois do campo "NomePessoa") */
ALTER TABLE Pessoas 
ADD COLUMN DataNascimento DATE NOT NULL AFTER NomePessoa;

+----------------+--------------+------+-----+---------+----------------+
| Field          | Type         | Null | Key | Default | Extra          |
+----------------+--------------+------+-----+---------+----------------+
| IdPessoa       | int          | NO   | PRI | NULL    | auto_increment |
| NomePessoa     | varchar(80)  | NO   |     | NULL    |                |
| DataNascimento | date         | NO   |     | NULL    |                |
| Idade          | int unsigned | NO   |     | NULL    |                |
+----------------+--------------+------+-----+---------+----------------+

Note que "DataNascimento" foi criada e inserida após a coluna "NomePessoa", ocupando exatamente a posição que desejávamos.

Se, por algum motivo, precisarmos alterar a posição desse campo, podemos movê-lo fazendo uso do MODIFY COLUMN, como no exemplo abaixo, onde estamos reposicionando o campo "DataNascimento" para depois da coluna "Idade".

/* Alterando a posição de uma coluna (Colocando depois do campo "Idade") */
ALTER TABLE Pessoas 
MODIFY COLUMN DataNascimento DATE NOT NULL AFTER Idade;

+----------------+--------------+------+-----+---------+----------------+
| Field          | Type         | Null | Key | Default | Extra          |
+----------------+--------------+------+-----+---------+----------------+
| IdPessoa       | int          | NO   | PRI | NULL    | auto_increment |
| NomePessoa     | varchar(80)  | NO   |     | NULL    |                |
| Idade          | int unsigned | NO   |     | NULL    |                |
| DataNascimento | date         | NO   |     | NULL    |                |
+----------------+--------------+------+-----+---------+----------------+

Analisando agora a nova estrutura, percebemos que talvez não faça mais sentido manter o campo "Idade", uma vez que podemos obter essa informação através de um simples cálculo a partir da coluna "DataNascimento". Logo, vamos excluir (DROP COLUMN) essa coluna da nossa tabela de pessoas.

/* Excluindo uma coluna da tabela */
ALTER TABLE Pessoas 
DROP COLUMN Idade;

+----------------+-------------+------+-----+---------+----------------+
| Field          | Type        | Null | Key | Default | Extra          |
+----------------+-------------+------+-----+---------+----------------+
| IdPessoa       | int         | NO   | PRI | NULL    | auto_increment |
| NomePessoa     | varchar(80) | NO   |     | NULL    |                |
| DataNascimento | date        | NO   |     | NULL    |                |
+----------------+-------------+------+-----+---------+----------------+

Com isso, finalizamos este pequeno tour pelos comandos DDL. É claro que não exploramos todas as possibilidades, mas passamos por boa parte das operações de alteração em tabelas usando ALTER TABLE, que você pode vir a precisar no seu dia a dia como dev.

Espero que tenha gostado desse artigo e que ele tenha sido útil para você. Siga-me nas redes sociais para mais conteúdos como esse!