MySQL: Todos os artigos do TutsUP relacionados com o Servidor MySQL. Tutoriais, dicas, configurações e muito mais. Venha aprender mais a respeito.

Você pode utilizar expressões regulares POSIX no MySQL com as declarações RLIKE e REGEXP, além disso, também pode negar uma expressão regular (o contrário) com NOT REGEXP.

Uma expressão regular é uma forma muito poderosa para encontrar valores específicos em qualquer campo, como números, parte de valores, contagem de caracteres e coisas do tipo.

Na verdade, as possibilidades das expressões regulares são praticamente infinitas.

Já falamos muito sobre expressões regulares aqui no Tutsup, tanto para PHP quanto JavaScript, seguem os artigos:

Os artigos acima darão uma introdução mais ampla sobre quando, e porquê, utilizar expressões regulares. Recomendo a leitura.

Hoje você vai aprender a utilizar expressões regulares no MySQL para encontrar valores de maneira mais específica do que utilizando LIKE.

Outras aulas

Antes que você continue, lembre-se que este artigo faz parte de uma série de artigos sobre comandos SQL, mais especificamente em um servidor MySQL.

Os outros artigos dão coordenadas sobre a base de dados e tabelas que estamos utilizando para realizar as consultas descritas posteriormente neste texto.

Seguem os links para outras aulas:

Daqui em diante, vou assumir que você tem a mesma base de dados, tabelas e valores, que foram indicados nos artigos acima.

Nossa tabela

Seguem os dados da nossa tabela:

cliente_idcliente_nomecliente_sobrenomecliente_idadecliente_sexocliente_data_cadastro
1Luiz OtávioMiranda Figueiredo27Masculino2014-10-23 09:58:52
2Luiz OtávioMiranda Figueiredo27Masculino2014-10-23 09:58:52
3Luiz OtávioMiranda Figueiredo27Masculino2014-10-23 09:58:52
4LetíciaBarbosa20Feminino2014-10-01 09:59:21
5JoãoSilva35Outro2014-09-16 10:00:00
6JuniorOliveira29Masculino2014-10-30 10:00:30
7RosanaAlves19Feminino2014-05-04 10:00:50
8AlanaMaria25Feminino2014-09-08 10:01:17
9AlanAlbuquerque45Masculino2014-08-04 10:01:42
10JackMichel50Masculino2014-04-29 10:02:30
11NatanieleRafael23Feminino2014-08-26 10:03:03
12AlineRocha18Feminino2013-11-18 10:03:24
13CássioMiguel30Masculino2014-10-12 10:04:09
14Vitor HugoFigueira32Masculino2015-02-10 10:04:14
15AbdnegoOswald21Masculino2013-09-17 10:05:05
16JohnLenon29Masculino2014-06-10 10:05:38
17AlariasNickson20Masculino2014-07-21 10:08:07
18LuanSantana25Masculino2014-05-19 10:08:01
19WanessaCamargo30Feminino2014-06-16 10:07:56
20LucianoLima50Feminino2014-08-18 10:07:52
21RenanOliveira23Masculino2014-10-06 10:07:48
22RafaelFilho18Outro2014-10-26 10:07:43

Os comandos abaixo serão realizados na tabela acima, para que você entenda o que será retornado.

Utilizando RLIKE e REGEXP

RLIKE e REGEXP são a mesma coisa, pra dizer a verdade. Um é sinônimo do outro, portanto, qualquer uma das duas funções irá retornar o mesmo valor.

Vamos utilizar RLIKE por ser mais parecido com LIKE, que é mais utilizado em consultas MySQL.

Utilizamos RLIKE da seguinte maneira:

SELECT * FROM clientes WHERE LOWER ( cliente_nome ) RLIKE 'EXPRESSÃO';

Perceba que estou pedindo para o MySQL executar a função LOWER no campo que desejo encontrar o valor, isso significa que eu não preciso me preocupar com letras maiúsculas e minúsculas na minha expressão regular. Qualquer letra maiúscula será tratada como minúscula pela minha consulta.

Observação: Isso é só para a pesquisa, os valores retornados estarão como você os cadastrou na base de dados.

Substituindo “EXPRESSÃO” por uma expressão regular normal ficaria assim:

SELECT * FROM clientes WHERE LOWER ( cliente_nome ) RLIKE '^[a-z]{4}$';

^[a-z]{4}$ significa que o MySQL irá pesquisar apenas valores que iniciam e terminam com letras de A até Z (minúsculas) com um máximo de 4 caracteres. Veja o retorno:

cliente_idcliente_nomecliente_sobrenomecliente_idadecliente_sexocliente_data_cadastro
9AlanAlbuquerque45Masculino2014-08-04 10:01:42
10JackMichel50Masculino2014-04-29 10:02:30
16JohnLenon29Masculino2014-06-10 10:05:38
18LuanSantana25Masculino2014-05-19 10:08:01

Todos os nomes do campo “cliente_nome” tem 4 letras.

Não vou entrar muito em detalhes sobre expressões regulares POSIX por fugir do escopo do que estamos falando (eu poderia gastar vários artigos só para falar sobre expressões regulares). Mas veja alguns exemplos:

/* Todos os nomes que terminam com a letra "a" ou "o" */
SELECT * FROM clientes WHERE LOWER ( cliente_nome ) RLIKE '(a|o)$';

/* Todos os nomes que começam com a letra "a" ou "o" */
SELECT * FROM clientes WHERE LOWER ( cliente_nome ) RLIKE '^(a|o)';

/* Nomes que começam com "L" e terminam com "O" */
SELECT * FROM clientes WHERE LOWER ( cliente_nome ) RLIKE '^l.*(o)$';

/* Nomes que tenham as letras "a", "b" ou "o" */
SELECT * FROM clientes WHERE LOWER ( cliente_nome ) RLIKE '[abo]';

/* Nomes que começam com "A" */
SELECT * FROM clientes WHERE LOWER ( cliente_nome ) RLIKE '^a';

É bastante útil, vai por mim!

Utilizando NOT REGEXP ou NOT RLIKE

NOT REGEXP e NOT RLIKE são exatamente o contrário do que você estiver procurando na sua expressão regular.

Pense como se fosse “NÃO CONTÉM” tal expressão. Veja exemplos:

/* Todos os nomes que NÃO terminam com a letra "a" ou "o" */
SELECT * FROM clientes WHERE LOWER ( cliente_nome ) NOT RLIKE '(a|o)$';

/* Todos os nomes que NÃO começam com a letra "a" ou "o" */
SELECT * FROM clientes WHERE LOWER ( cliente_nome ) NOT RLIKE '^(a|o)';

/* Nomes que NÃO começam com "L" e terminam com "O" */
SELECT * FROM clientes WHERE LOWER ( cliente_nome ) NOT RLIKE '^l.*(o)$';

/* Nomes que NÃO tenham as letras "a", "b" ou "o" */
SELECT * FROM clientes WHERE LOWER ( cliente_nome ) NOT RLIKE '[abo]';

/* Nomes que NÃO começam com "A" */
SELECT * FROM clientes WHERE LOWER ( cliente_nome ) NOT RLIKE '^a';

Os detalhes estão nos comentários acima.

Concluindo

Expressões regulares são divertidas e fácil de entender, você pode encontrar por elas na internet facilmente pesquisando no Google. Se você souber inglês, recomendo o site:

É uma ferramenta muito útil para encontrar valores no MySQL.

Caso tenha dúvidas, comente!

Quando estamos selecionando valores no MySQL, em várias ocasiões não queremos um dado específico, mas valores que contenham parte do que gostaríamos de encontrar. LIKE pode receber dois caracteres curinga para substituir as partes dos valores que não sabemos ou queremos omitir. São eles:

  • % – Que é equivalente qualquer valor independente da quantidade de caracteres;
  • _ – Que é equivalente a apenas um caractere qualquer.

Vamos ver como utilizar LIKE no MySQL.

Outras aulas

Antes que você continue, lembre-se que este artigo faz parte de uma série de artigos sobre comandos SQL, mais especificamente em um servidor MySQL.

Os outros artigos dão coordenadas sobre a base de dados e tabelas que estamos utilizando para realizar as consultas descritas posteriormente neste texto.

Seguem os links para outras aulas:

Daqui em diante, vou assumir que você tem a mesma base de dados, tabelas e valores, que foram indicados nos artigos acima.

Nossa tabela

Nossa tabela se chama “clientes” e tem os seguintes valores:

cliente_idcliente_nomecliente_sobrenomecliente_idadecliente_sexocliente_data_cadastro
1Luiz OtávioMiranda Figueiredo27Masculino2014-10-23 09:58:52
2Luiz OtávioMiranda Figueiredo27Masculino2014-10-23 09:58:52
3Luiz OtávioMiranda Figueiredo27Masculino2014-10-23 09:58:52
4LetíciaBarbosa20Feminino2014-10-01 09:59:21
5JoãoSilva35Outro2014-09-16 10:00:00
6JuniorOliveira29Masculino2014-10-30 10:00:30
7RosanaAlves19Feminino2014-05-04 10:00:50
8AlanaMaria25Feminino2014-09-08 10:01:17
9AlanAlbuquerque45Masculino2014-08-04 10:01:42
10JackMichel50Masculino2014-04-29 10:02:30
11NatanieleRafael23Feminino2014-08-26 10:03:03
12AlineRocha18Feminino2013-11-18 10:03:24
13CássioMiguel30Masculino2014-10-12 10:04:09
14Vitor HugoFigueira32Masculino2015-02-10 10:04:14
15AbdnegoOswald21Masculino2013-09-17 10:05:05
16JohnLenon29Masculino2014-06-10 10:05:38
17AlariasNickson20Masculino2014-07-21 10:08:07
18LuanSantana25Masculino2014-05-19 10:08:01
19WanessaCamargo30Feminino2014-06-16 10:07:56
20LucianoLima50Feminino2014-08-18 10:07:52
21RenanOliveira23Masculino2014-10-06 10:07:48
22RafaelFilho18Outro2014-10-26 10:07:43

Utilizando LIKE

LIKE vem dentro da cláusula WHERE da sua consulta MySQL, substituindo os operadores de igual (=) ou diferente (<>, !=). Por exemplo:

SELECT * FROM clientes WHERE cliente_nome LIKE 'Luiz%';

Perceba que “cliente_nome” deve ser “LIKE” (parecido com) ‘Luiz%’. Neste caso, o caractere curinga %, indica que depois de “Luiz” pode vir qualquer coisa.

Para nossa tabela, valores retornados foram:

cliente_idcliente_nomecliente_sobrenomecliente_idadecliente_sexocliente_data_cadastro
1Luiz OtávioMiranda Figueiredo27Masculino2014-10-23 09:58:52
2Luiz OtávioMiranda Figueiredo27Masculino2014-10-23 09:58:52
3Luiz OtávioMiranda Figueiredo27Masculino2014-10-23 09:58:52

Que são os únicos valores que começam com “Luiz”.

Like no MySQL (SQLyog)

Like no MySQL (SQLyog)

Observação: O programa de testes acima é o SQLyog Community Edition (grátis).

Eu posso utilizar quantos caracteres curinga forem necessários para atingir meu objetivo, veja:

SELECT * FROM clientes WHERE cliente_nome LIKE '%ana%';

Agora eu fui mais além, utilizei um caractere curinga para o início e outro para o fim, isso indica que qualquer palavra que contenha “ana” será retornada na minha consulta.

O resultado para nossa tabela foi o seguinte:

cliente_idcliente_nomecliente_sobrenomecliente_idadecliente_sexocliente_data_cadastro
7RosanaAlves19Feminino2014-05-04 10:00:50
8AlanaMaria25Feminino2014-09-08 10:01:17

Ou seja: “Rosana” e “Alana“.

Diferente do caractere curinga %, o caractere _ serve para apenas um caractere, por exemplo:

SELECT * FROM clientes WHERE cliente_nome LIKE '_uiz_Otávi_';

Neste caso, _uiz_Otávi_ substituiria o “L”, “[espaço]” e o “o” do final de “Luiz Otávio”.

Eu também posso combinar ambos os caracteres curinga, veja:

SELECT * FROM clientes WHERE cliente_nome LIKE '_uiz_O%';

E continuaria encontrando “Luiz Otávio”.

Vários LIKEs na mesma consulta

Eu também posso combinar vários LIKEs na mesma consulta, para isso eu precisaria dos operadores OR ou AND, veja:

SELECT * FROM clientes WHERE cliente_nome LIKE '_uiz_O%' OR cliente_nome LIKE 'Rosa%';

Agora estou selecionando todos os campos, onde (WHERE) o campo cliente_nome seja parecido com (LIKE) _uiz_O% ou (OR) Rosa%. Veja o que foi retornado:

cliente_idcliente_nomecliente_sobrenomecliente_idadecliente_sexocliente_data_cadastro
1Luiz OtávioMiranda Figueiredo27Masculino2014-10-23 09:58:52
2Luiz OtávioMiranda Figueiredo27Masculino2014-10-23 09:58:52
3Luiz OtávioMiranda Figueiredo27Masculino2014-10-23 09:58:52
7RosanaAlves19Feminino2014-05-04 10:00:50

Simples assim!

Concluindo

Tome cuidado ao utilizar LIKE e OR em uma consulta do MySQL, dependendo do tamanho da sua consulta, você pode comprometer a performance do servidor. Nunca se esqueça de colocar um limite (LIMIT) razoável na sua consulta, por exemplo:

SELECT 
    * 
FROM
    clientes 
WHERE cliente_nome LIKE '_uiz_O%' 
    OR cliente_nome LIKE 'Rosa%' 
LIMIT 10 ;

Em tabelas que retornariam milhares de linhas, eles seriam limitados em um máximo de 10.

Em caso de dúvidas, comente!

CONCAT é uma função que pode ser utilizada em várias partes da sua consulta, tanto para unir valores de campos da tabela temporariamente quanto para unir strings que você quiser digitar manualmente (ou por variáveis) na consulta.

Neste artigo você verá como utilizar CONCAT no MySQL de várias maneiras diferentes, além disso, também vamos falar sobre a função CONCAT_WS, que também faz a mesma coisa, porém com um separador para cada valor.

Não perca as aulas anteriores

Antes que você continue a ler, lembre-se que este artigo faz parte de uma série de artigos sobre comandos SQL, mais especificamente em um servidor MySQL.

Os artigos anteriores dão coordenadas sobre a base de dados e tabelas que estamos utilizando para realizar as consultas descritas posteriormente neste texto.

Seguem os links para aulas anteriores:

Daqui em diante, vou assumir que você tem a mesma base de dados, tabelas e valores, que foram indicados nos artigos acima.

O que é CONCAT?

CONCAT significa concatenar (juntar) valores. Se eu tenho dois campos diferentes – como “Nome” e “Sobrenome” – em uma mesma tabela, pode ser que em algum momento eu precise dos dois valores juntos em um único campo para facilitar a minha vida. CONCAT e CONCAT_WS são as duas funções que você pode utilizar para atingir este objetivo.

Utilizando CONCAT em campos

Uma parte muito útil da função CONCAT é a possibilidade de juntar campos e utilizar um alias para gerar um único campo temporário.

Veja os dados da nossa tabela:

cliente_idcliente_nomecliente_sobrenomecliente_idadecliente_sexocliente_data_cadastro
1Luiz OtávioMiranda Figueiredo27Masculino2014-10-23 09:58:52
2Luiz OtávioMiranda Figueiredo27Masculino2014-10-23 09:58:52
3Luiz OtávioMiranda Figueiredo27Masculino2014-10-23 09:58:52
4LetíciaBarbosa20Feminino2014-10-01 09:59:21
5JoãoSilva35Outro2014-09-16 10:00:00
6JuniorOliveira29Masculino2014-10-30 10:00:30
7RosanaAlves19Feminino2014-05-04 10:00:50
8AlanaMaria25Feminino2014-09-08 10:01:17
9AlanAlbuquerque45Masculino2014-08-04 10:01:42
10JackMichel50Masculino2014-04-29 10:02:30
11NatanieleRafael23Feminino2014-08-26 10:03:03
12AlineRocha18Feminino2013-11-18 10:03:24
13CássioMiguel30Masculino2014-10-12 10:04:09
14Vitor HugoFigueira32Masculino2015-02-10 10:04:14
15AbdnegoOswald21Masculino2013-09-17 10:05:05
16JohnLenon29Masculino2014-06-10 10:05:38
17AlariasNickson20Masculino2014-07-21 10:08:07
18LuanSantana25Masculino2014-05-19 10:08:01
19WanessaCamargo30Feminino2014-06-16 10:07:56
20LucianoLima50Feminino2014-08-18 10:07:52
21RenanOliveira23Masculino2014-10-06 10:07:48
22RafaelFilho18Outro2014-10-26 10:07:43

Veja uma consulta que une os campos cliente_nome e cliente_sobrenome em um único campo chamado nome:

SELECT CONCAT( cliente_nome, cliente_sobrenome ) AS nome FROM clientes;

O resultado:

nome
Luiz OtávioMiranda Figueiredo
Luiz OtávioMiranda Figueiredo
Luiz OtávioMiranda Figueiredo
LetíciaBarbosa
JoãoSilva
JuniorOliveira
RosanaAlves
AlanaMaria
AlanAlbuquerque
JackMichel
NatanieleRafael
AlineRocha
CássioMiguel
Vitor HugoFigueira
AbdnegoOswald
JohnLenon
AlariasNickson
LuanSantana
WanessaCamargo
LucianoLima
RenanOliveira
RafaelFilho

Apesar de termos atingido nosso resultado inicial, existe algo estranho nos valores, ambos os valores dos campos cliente_nome e cliente_sobrenome estão colados. Para resolver isso, basta concatenar um espaço entre eles na consulta, veja:

SELECT CONCAT( cliente_nome, ' ', cliente_sobrenome ) AS nome FROM clientes;

Para concatenar valores, basta colocá-los entre vírgula dentro da função. Exemplo:

SELECT CONCAT( 'Eu', ' ', 'sei', ' ', 'concatenar.' ) AS frase;

O retorno seria:

frase
Eu sei concatenar.

Utilizando CONCAT em strings

Você também pode concatenar strings manualmente (ou conforme preferir), por exemplo:

SELECT * FROM clientes WHERE cliente_nome = CONCAT('Luiz', ' ', 'Otávio');

Isso irá retornar todos os clientes onde o campo “cliente_nome” for igual a “Luiz Otávio”.

Utilizando CONCAT_WS

CONCAT_WS é a função perfeita para unir valores com um separador qualquer. Isso evita colocarmos um espaço (por exemplo) a cada campo concatenado.

CONCAT_WS precisa de um separador no primeiro argumento, o restante são os valores a serem concatenados. Por exemplo:

SELECT 
    CONCAT_WS(
        '-',
        cliente_nome,
        cliente_sobrenome,
        cliente_sexo
    ) AS dados 
FROM
    clientes ;

A consulta acima retornaria todos os campos separados por um sinal de menos “-“, você pode utilizar o que quiser como separador, até mesmo um espaço.

Concluindo

CONCAT e CONCAT_WS são funções para strings do MySQL, você pode saber mais sobre todas elas em MySQL String Functions.

Caso tenha dúvidas, basta comentar.

Quando trabalhamos com bases de dados relacionais, como MySQL, é muito comum termos milhares de tabelas que se relacionam entre si através de um campo ou mais. JOIN, RIGHT JOIN e LEFT JOIN são declarações que podem unir os valores dessas tabelas temporariamente e retornar tudo o que foi pedido.

Neste artigo você vai entender como funcionam essas declarações.

Antes de iniciar…

Antes que você comece a seguir este tutorial, recomendo que siga as dicas anteriores dessa mesma série, já que este é um complemento do que já falamos anteriormente.

Seguem os artigos anteriores:

Neles estávamos utilizando o phpMyAdmin com o EasyPHP para realizar nossas consultas SQL, porém, vamos mudar de planos. A partir de agora, vamos continuar utilizando o EasyPHP para termos um servidor WAMP (com um servidor MySQL) em nosso computador, porém, vamos passar a executar as consultas no software SQLyog Community Edition (também gratuito). Isso porque o phpMyAdmin não estava retornando certos valores de maneira correta para que você possa entender o que está fazendo em suas consultas SQL.

Portanto, não se esqueça de instalar o SQLyog Community Edition em seu computador e configurar os dados da seguinte maneira:

Configuração do SQLyog

Configuração do SQLyog

Se tiver alguma dúvida, basta comentar!

Nossa base de dados de testes

Configure uma base de dados de testes com pelo menos duas tabelas relacionadas por um campo. Em nosso caso, já temos uma base de dados pronta que você pode baixar e importar para seu servidor.

Baixe-a no link abaixo:

Descompacte o arquivo e importe para seu servidor MySQL.

A base de dados acima contém apenas uma tabela chamada “clientes”, então vamos inserir mais uma tabela e alguns valores na mesma. Para criar uma nova tabela na base de dados acima, utilize a seguinte declaração:

CREATE TABLE dados_clientes (
	cliente_id_ INT(11) NOT NULL,
	cliente_endereco TEXT,
	PRIMARY KEY ( cliente_id_ )
);

Vamos relacionar o campo cliente_id da tabela clientes com o campo cliente_id_ da tabela dados clientes. Essa nova tabela terá apenas o endereço do cliente. Os campos cliente_id e cliente_id_ apenas indicarão ao servidor MySQL que é o mesmo cliente nas duas tabelas.

Vamos inserir alguns endereços fictícios para nossos clientes, então execute o seguinte comando:

INSERT INTO dados_clientes 
(cliente_id_, cliente_endereco) 
VALUES
(1, 'Rua Maria de lima, Centro, São Paulo'),
(5, 'Rua Osvaldo Cruz, Maringá, Belo Horizonte'),
(7, 'Rua Rosana, Sinara, Nova Esperança'),
(10, 'Av. Bias Fortes, Centro, Brasília'),
(12, 'Beatles, Santa Cruz, Rio de Janeiro'),
(15, 'Av. Esquerda, Vila Pinheiro, New York');

Pronto, agora temos duas tabelas relacionadas entre si e podemos utilizar JOIN, RIGHT JOIN e LEFT JOIN.

Dados das tabelas

Se você não quer enviar ou criar as tabelas em seu servidor, seguem os dados de ambas:

clientes

cliente_idcliente_nomecliente_sobrenomecliente_idadecliente_sexocliente_data_cadastro
1Luiz OtávioMiranda Figueiredo27Masculino2014-10-23 09:58:52
2Luiz OtávioMiranda Figueiredo27Masculino2014-10-23 09:58:52
3Luiz OtávioMiranda Figueiredo27Masculino2014-10-23 09:58:52
4LetíciaBarbosa20Feminino2014-10-01 09:59:21
5JoãoSilva35Outro2014-09-16 10:00:00
6JuniorOliveira29Masculino2014-10-30 10:00:30
7RosanaAlves19Feminino2014-05-04 10:00:50
8AlanaMaria25Feminino2014-09-08 10:01:17
9AlanAlbuquerque45Masculino2014-08-04 10:01:42
10JackMichel50Masculino2014-04-29 10:02:30
11NatanieleRafael23Feminino2014-08-26 10:03:03
12AlineRocha18Feminino2013-11-18 10:03:24
13CássioMiguel30Masculino2014-10-12 10:04:09
14Vitor HugoFigueira32Masculino2015-02-10 10:04:14
15AbdnegoOswald21Masculino2013-09-17 10:05:05
16JohnLenon29Masculino2014-06-10 10:05:38
17AlariasNickson20Masculino2014-07-21 10:08:07
18LuanSantana25Masculino2014-05-19 10:08:01
19WanessaCamargo30Feminino2014-06-16 10:07:56
20LucianoLima50Feminino2014-08-18 10:07:52
21RenanOliveira23Masculino2014-10-06 10:07:48
22RafaelFilho18Outro2014-10-26 10:07:43

dados_clientes

cliente_id_cliente_endereco
1Rua Maria de lima, Centro, São Paulo
5Rua Osvaldo Cruz, Maringá, Belo Horizonte
7Rua Rosana, Sinara, Nova Esperança
10Av. Bias Fortes, Centro, Brasília
12Beatles, Santa Cruz, Rio de Janeiro
15Av. Esquerda, Vila Pinheiro, New York

Perceba a identificação dos clientes pelos campos cliente_id e cliente_id_ de ambas as tabelas. Veja também que alguns clientes não tem valores na tabela dados_clientes. Isso é justamente para testarmos nossas consultas.

JOIN

O comando JOIN tem várias variações, sendo a mais utilizada delas INNER JOIN. Mas não se confunda, os únicos comandos que podem fazer alguma diferença para unir duas ou mais tabelas são RIGHT JOIN e LEFT JOIN. O restante serve apenas para mostrar aos desenvolvedores uma melhor escrita de código.

Portanto, o que temos que nos preocupar em nossas consultas MySQL são as declarações JOIN, RIGHT JOIN e LEFT JOIN.

A declaração JOIN indica ao MySQL que ele deve trazer os valores presentes em ambas as tabelas, ou seja, ele deverá verificar se o mesmo valor está presente nas duas tabelas indicadas. Por exemplo:

SELECT clientes.cliente_id, clientes.cliente_nome, dados_clientes.cliente_endereco
FROM clientes
JOIN dados_clientes
ON clientes.cliente_id = dados_clientes.cliente_id_;

Com isso, eliminamos os valores que NÃO estão presentes em ambas as tabelas. Veja o resultado:

clientes.cliente_idclientes.cliente_nomedados_clientes.cliente_endereco
1Luiz OtávioRua Maria de lima, Centro, São Paulo
5JoãoRua Osvaldo Cruz, Maringá, Belo Horizonte
7RosanaRua Rosana, Sinara, Nova Esperança
10JackAv. Bias Fortes, Centro, Brasília
12AlineBeatles, Santa Cruz, Rio de Janeiro
15AbdnegoAv. Esquerda, Vila Pinheiro, New York

Veja que os valores das tabelas foram unidos temporariamente e retornados para nossa visualização. Isso vai funcionar com suas consultas PDO ou qualquer outra linguagem que esteja utilizando.

Você pode utilizar os comandos mais básicos nessa mesma estrutura, como ORDER BY, WHERE e coisas do tipo, veja:

SELECT clientes.cliente_id, clientes.cliente_nome, dados_clientes.cliente_endereco
FROM clientes
JOIN dados_clientes
ON clientes.cliente_id = dados_clientes.cliente_id_
WHERE 
dados_clientes.cliente_endereco LIKE '%Rua%' OR dados_clientes.cliente_endereco LIKE 'Av%'
ORDER BY clientes.cliente_nome ASC;

Veja o retorno da consulta acima:

cliente_idcliente_nomecliente_endereco
15AbdnegoAv. Esquerda, Vila Pinheiro, New York
10JackAv. Bias Fortes, Centro, Brasília
5JoãoRua Osvaldo Cruz, Maringá, Belo Horizonte
1Luiz OtávioRua Maria de lima, Centro, São Paulo
7RosanaRua Rosana, Sinara, Nova Esperança

Na verdade, a declaração WHERE não está fazendo muita diferença, já que eu sabia os valores que seriam retornados, mas ORDER BY modificou completamente a ordem dos valores.

Entendendo os lados RIGHT e LEFT

Antes de passar a declaração RIGHT e LEFT JOIN, é necessário que você compreenda os lados em que as tabelas são apresentadas na consulta.

Quando eu digo o seguinte:

SELECT *
FROM clientes
JOIN dados_clientes
ON cliente_id = cliente_id_;

O MySQL considera o seguinte:

SELECT *
FROM clientes /* LEFT - Tabela da esquerda */
JOIN dados_clientes /* RIGHT - Tabela da direita */
ON cliente_id = cliente_id_;

As palavras RIGHT e LEFT indicam respectivamente direta e esquerda.

Para o comando JOIN isso não fará muita diferença, já que os dados devem estar presentes em ambas as tabelas, porém, para RIGHT JOIN e LEFT JOIN isso pode mudar um pouco.

LEFT JOIN

Quando eu digo LEFT JOIN, quero dizer ao MySQL para comparar os valores da ESQUERDA com os da direita. Seria como falar, compare os valores de “clientes” com os valores de “dados_clientes”.

Neste caso, o MySQL irá analisar TODOS os valores da tabela da esquerda (clientes) e inserir na consulta. Os valores da direita serão apresentados apenas se coincidirem na consulta.

Veja um exemplo:

SELECT *
FROM clientes /* Tabela da esquerda */
LEFT JOIN dados_clientes /* Tabela da direita */
ON cliente_id = cliente_id_;

Agora veja o resultado:

cliente_idcliente_nomecliente_sobrenomecliente_idadecliente_sexocliente_data_cadastrocliente_id_cliente_endereco
1Luiz OtávioMiranda Figueiredo27Masculino2014-10-23 09:58:521Rua Maria de lima, Centro, São Paulo
5JoãoSilva35Outro2014-09-16 10:00:005Rua Osvaldo Cruz, Maringá, Belo Horizonte
7RosanaAlves19Feminino2014-05-04 10:00:507Rua Rosana, Sinara, Nova Esperança
10JackMichel50Masculino2014-04-29 10:02:3010Av. Bias Fortes, Centro, Brasília
12AlineRocha18Feminino2013-11-18 10:03:2412Beatles, Santa Cruz, Rio de Janeiro
15AbdnegoOswald21Masculino2013-09-17 10:05:0515Av. Esquerda, Vila Pinheiro, New York
2Luiz OtávioMiranda Figueiredo27Masculino2014-10-23 09:58:52(NULL)(NULL)
3Luiz OtávioMiranda Figueiredo27Masculino2014-10-23 09:58:52(NULL)(NULL)
4LetíciaBarbosa20Feminino2014-10-01 09:59:21(NULL)(NULL)
6JuniorOliveira29Masculino2014-10-30 10:00:30(NULL)(NULL)
8AlanaMaria25Feminino2014-09-08 10:01:17(NULL)(NULL)
9AlanAlbuquerque45Masculino2014-08-04 10:01:42(NULL)(NULL)
11NatanieleRafael23Feminino2014-08-26 10:03:03(NULL)(NULL)
13CássioMiguel30Masculino2014-10-12 10:04:09(NULL)(NULL)
14Vitor HugoFigueira32Masculino2015-02-10 10:04:14(NULL)(NULL)
16JohnLenon29Masculino2014-06-10 10:05:38(NULL)(NULL)
17AlariasNickson20Masculino2014-07-21 10:08:07(NULL)(NULL)
18LuanSantana25Masculino2014-05-19 10:08:01(NULL)(NULL)
19WanessaCamargo30Feminino2014-06-16 10:07:56(NULL)(NULL)
20LucianoLima50Feminino2014-08-18 10:07:52(NULL)(NULL)
21RenanOliveira23Masculino2014-10-06 10:07:48(NULL)(NULL)
22RafaelFilho18Outro2014-10-26 10:07:43(NULL)(NULL)

Veja que todos os valores de ambas as tabelas foram unidos temporariamente, porém, agora foram retornados todos os valores da tabela “clientes”, mesmo que os valores da tabela “dados_clientes” não existam.

RIGHT JOIN

RIGHT JOIN é o contrário de LEFT JOIN, ou seja, diz ao MySQL para analisar os valores da DIREITA primeiro e comparar com os valores da esquerda. Isso que dizer que todos os valores da tabela da esquerda serão apresentados, e, para os valores da direita, apenas os que coincidirem com a consulta.

Veja um exemplo:

SELECT *
FROM clientes /* Tabela da esquerda */
RIGHT JOIN dados_clientes /* Tabela da direita */
ON cliente_id = cliente_id_;

Agora veja o resultado:

cliente_idcliente_nomecliente_sobrenomecliente_idadecliente_sexocliente_data_cadastrocliente_id_cliente_endereco
1Luiz OtávioMiranda Figueiredo27Masculino2014-10-23 09:58:521Rua Maria de lima, Centro, São Paulo
5JoãoSilva35Outro2014-09-16 10:00:005Rua Osvaldo Cruz, Maringá, Belo Horizonte
7RosanaAlves19Feminino2014-05-04 10:00:507Rua Rosana, Sinara, Nova Esperança
10JackMichel50Masculino2014-04-29 10:02:3010Av. Bias Fortes, Centro, Brasília
12AlineRocha18Feminino2013-11-18 10:03:2412Beatles, Santa Cruz, Rio de Janeiro
15AbdnegoOswald21Masculino2013-09-17 10:05:0515Av. Esquerda, Vila Pinheiro, New York

Viu que agora apenas foram preenchidos os valores que estão presentes na tabela da DIREITA? Isso porque o MySQL analisa todos da direita e só verifica se existe algum valor correspondente na tabela da esquerda.

Concluindo

Consultas MySQL são bastante interessantes quando você começa a entender o que está fazendo. Espero que tenha entendido.

Caso tenha alguma dúvida, basta comentar aí abaixo.

Utilizar alias em consultas SQL pode ser bastante conveniente em milhares de casos. Eles servem para renomear um campo (coluna) ou uma tabela temporariamente.

Hoje você vai aprender a utilizar alias SQL de maneira apropriada para suas consultas.

Então vamos lá.

Artigos anteriores

Antes que você continue a ler este tutorial, saiba que ele faz parte de uma série de tutoriais sobre consultas SQL (mais especificamente em um servidor MySQL utilizando o phpMyAdmin).

Nos tutoriais anteriores detalhei como criar o servidor WAMP e como realizar as consultas que vou passar no artigo abaixo. Se você perdeu algum artigo dessa série, seguem os links:

Neles você ficará apto para executar todas as consultas SQL indicadas abaixo.

Utilizando alias SQL para tabelas

Para utilizar um alias SQL em tabelas MySQL, basta utilizar a declaração AS e o nome temporário que deseja. Veja:

/* Indica ao servidor MySQL para utilizar nossa base de dados */
USE tutsup_bd_teste;

/* 
 * Seleciona todos os valores da tabela clientes renomeando-a
 * temporariamente para nome_temporario_da_tabela
 */
SELECT * FROM clientes AS nome_temporario_da_tabela;

No trecho de código acima, nossa tabela “clientes” passa a se chamar “nome_temporario_da_tabela”.

Com isso eu poderia fazer o seguinte:

/* Indica ao servidor MySQL para utilizar nossa base de dados */
USE tutsup_bd_teste;

/* 
 * Seleciona todos os valores da tabela clientes renomeando-a
 * temporariamente para nome_temporario_da_tabela
 */
SELECT * FROM clientes AS nome_temporario_da_tabela
WHERE nome_temporario_da_tabela.cliente_id = 1;

O trecho acima retornará apenas o cliente com o campo cliente_id igual a 1.

Resultado da consulta no phpMyAdmin

Resultado da consulta no phpMyAdmin

Utilizando alias com nomes de campos

Você também pode utilizar alias para renomear campos da sua tabela (ou ambos, se assim preferir).

Também utilizamos AS e o novo nome do campo (coluna), veja como ficaria:

/* Indica ao servidor MySQL para utilizar nossa base de dados */
USE tutsup_bd_teste;

/* 
 * Seleciona cliente_id com nome temporário de id_temporario
 * cliente_nome com nome temporário de nome
 * da tabela clientes com nome temporário de nome_temporario_da_tabela
 * onde o cliente_id seja igual a 1
 */
SELECT cliente_id AS id_temporario, cliente_nome AS nome 
FROM clientes AS nome_temporario_da_tabela
WHERE cliente_id = 1;

Infelizmente, no phpMyAdmin não consigo ver o nome temporário dos campos e tabelas. Mas se eu trocar de software, utilizar o SQLyog ou PHP PDO, o retorno da consulta ficaria assim:

Resultado da consulta no SQLyog

Resultado da consulta no SQLyog

Download: Caso queira baixar uma versão FREE (grátis) do SQLyog, utilize o SQLyog Community Edition.

Perceba que os nomes dos campos selecionados não são mais os mesmos, mas id_temporario para cliente_id e nome para cliente_nome.

Observação:  Se você estiver utilizando PHP PDO, o array retornado virá com os nomes temporários dos campos, portanto, cliente_id e cliente_nome deixarão de existir temporariamente. Utilize os nomes temporários como chaves do array retornado pela consulta.

Quando utilizar alias SQL?

Em uma consulta SQL simples (como as dos exemplos acima) não faz muito sentido utilizar alias, porém quando estamos selecionando valores de várias tabelas ao mesmo tempo e essas tabelas não foram criadas apropriadamente, normalmente utilizando alias para distinguir os nomes dos campos.

Suponhamos que você tenha três tabelas relacionais. Nas três existe um campo chamado ID para identificar a linha. Quando você for realizar a consulta SQL juntando as três tabelas mencionadas, o servidor não conseguirá distinguir qual ID é de qual tabela, e isso vai gerar problemas na sua consulta.

Outro ponto interessante para utilizar alias SQL é na contagem de linhas. Por exemplo:

/* Indica ao servidor MySQL para utilizar nossa base de dados */
USE tutsup_bd_teste;

/* Conta as linhas cliente_id encontradas */
SELECT COUNT(*) FROM clientes;

COUNT(*) conta as linhas encontradas, mas e agora? Qual o nome do campo que isso irá gerar?

Para resolver este problema, basta fazer o seguinte:

/* Indica ao servidor MySQL para utilizar nossa base de dados */
USE tutsup_bd_teste;

/* Conta as linhas cliente_id encontradas */
SELECT COUNT(*) AS total_de_clientes FROM clientes;

Pronto, agora eu sei que posso buscar o campo “total_de_clientes”.

Concluindo

Alias em consultas SQL são bastante simples para serem utilizados. Também pode ajudar a organizar tabelas mal relacionadas, além de deixarem a possibilidade do desenvolvedor trabalhar com nomes mais amigáveis.

Espero que tenha entendido, mas fique à vontade para tirar suas dúvidas nos comentários.

A declaração SQL “SELECT DISTINCT” serve para retornar apenas linhas com valores distintos na sua consulta, porém, existem algumas informações importantes a se saber antes de utilizá-la.

Antes de qualquer consulta, vamos criar uma base de dados de testes para realizarmos as nossas consultas. Se você perdeu o tutorial anterior, onde descrevi como estamos realizando todos os comandos e retornando os valores, não deixe de ler (link abaixo):

Para este artigo, vou assumir que você tenha lido o conteúdo do link anterior.

Importando os dados

Para realizarmos qualquer consulta, mesmo que de testes, precisaremos de uma base de dados, uma tabela e alguns valores na mesma. Eu criei um arquivo SQL que você pode importar para seu phpMyAdmin para não precisar ficar executando milhares de consultas manualmente.

Você pode baixar este arquivo no link abaixo:

Como você pode perceber, o arquivo está compactado. Descompacte e importe para seu phpMyAdmin. Para isso basta acessar o software e utilizar o menu “Importar”.

Descobrindo as bases de dados

Caso queira saber o nome das bases de dados presentes no seu phpMyAdmin, abra a opção SQL e digite o seguinte:

SHOW DATABASES;

Logo após executar a consulta, você verá o nome de todas as bases de dados existentes no seu MySQL, a nossa se chama tutsup_bd_teste.

Descobrindo as tabelas

Para saber quais tabelas existem em nossa base de dados, digite:

USE tutsup_bd_teste;
SHOW TABLES;

Isso fará você descobrir que só temos a tabela “clientes” em nossa base de dados.

Descobrindo os campos

Caso queira saber quais campos existem em nossa tabela, digite o seguinte:

USE tutsup_bd_teste;
SHOW FIELDS FROM clientes;

E você verá que temos os seguintes campos:

CampoTipoNullKeyPadrãoExtra
cliente_idint(11)NOPRINULLauto_increment
cliente_nomevarchar(255)YESNULL
cliente_sobrenomevarchar(255)YESNULL
cliente_idadevarchar(11)YESNULL
cliente_sexoenum(‘Outro’,’Masculino’,’Feminino’)YESOutro
cliente_data_cadastrodatetimeYES0000-00-00 00:00:00

Neles também existem valores que você pode obter utilizando o comando SELECT descrito no tutorial anterior.

Utilizando a declaração SELECT DISTINCT

SELECT DISTINCT no MySQL serve para exibir apenas valores distintos (diferentes). Valores com dois campos diferentes (um ID, por exemplo) em duas linhas diferentes são considerados dois valores diferentes.

Por exemplo: suponha os seguintes valores:

cliente_idcliente_nomecliente_sobrenomecliente_idadecliente_sexocliente_data_cadastro
1Luiz OtávioMiranda Figueiredo27Masculino2014-10-23 09:58:52
2Luiz OtávioMiranda Figueiredo27Masculino2014-10-23 09:58:52
3Luiz OtávioMiranda Figueiredo27Masculino2014-10-23 09:58:52
4LetíciaBarbosa20Feminino2014-10-01 09:59:21
5JoãoSilva35Outro2014-09-16 10:00:00
6JuniorOliveira29Masculino2014-10-30 10:00:30
7RosanaAlves19Feminino2014-05-04 10:00:50
8AlanaMaria25Feminino2014-09-08 10:01:17
9AlanAlbuquerque45Masculino2014-08-04 10:01:42
10JackMichel50Masculino2014-04-29 10:02:30
11NatanieleRafael23Feminino2014-08-26 10:03:03
12AlineRocha18Feminino2013-11-18 10:03:24
13CássioMiguel30Masculino2014-10-12 10:04:09
14Vitor HugoFigueira32Masculino2015-02-10 10:04:14
15AbdnegoOswald21Masculino2013-09-17 10:05:05
16JohnLenon29Masculino2014-06-10 10:05:38
17AlariasNickson20Masculino2014-07-21 10:08:07
18LuanSantana25Masculino2014-05-19 10:08:01
19WanessaCamargo30Feminino2014-06-16 10:07:56
20LucianoLima50Feminino2014-08-18 10:07:52
21RenanOliveira23Masculino2014-10-06 10:07:48
22RafaelFilho18Outro2014-10-26 10:07:43

Veja que as três primeiras linhas são praticamente idênticas, com exceção do campos “cliente_id”.

Eu poderia fazer uma consulta com o seguinte formato:

SELECT DISTINCT * FROM clientes;

E ainda continuaria obtendo o mesmo valor – com as três linhas idênticas ainda sendo apresentadas.

Isso acontece pelo que descrevi anteriormente, se qualquer um dos campos forem diferentes, DISTINCT não vai considerar isso como valores distintos, mas duas linhas totalmente diferentes.

Para resolver isso, você deve selecionar os campos que deseja que sejam exibidos, por exemplo:

SELECT DISTINCT `cliente_nome`, `cliente_sobrenome`, `cliente_idade` FROM clientes;

Agora sim, os três primeiros valores se tornam um, porque os campos (colunas) que selecionei tem os valores totalmente igual, portanto, não são distintos para o MySQL.

Vídeo tutorial

Caso queira, poderá seguir um vídeo tutorial detalhando tudo o que foi descrito neste tutorial:

É bem detalhado, isso eu garanto!

Concluindo

Caso tenha alguma dúvida, basta comentar!

Quem trabalha com desenvolvimento deve, pelo menos, entender como funcionam os comandos básicos do MySQL, que são os que envolvem a criação de bases de dados e tabelas, e a manipulação de valores, tais como INSERT, SELECT, UPDATE e DELETE (também conhecidos como CRUD).

Neste artigo vou ser bem simples e direto, e tentarei explicar de maneira breve os comandos mencionados anteriormente. Além disso, vou explicar uma maneira bem simples para que você possa treinar tais comandos diretamente em um servidor MySQL com o phpMyAdmin.

Instalando o phpMyAdmin

Para continuar seguindo o tutorial abaixo, vamos instalar o phpMyAdmin para que você tenha uma interface simples e visual dos comandos que você estiver executando na sua base de dados MySQL.

Na verdade, não há segredos na instalação do phpMyAdmin, já que qualquer servidor WAMP que você configurar em seu computador trará a instalação do mesmo. Como já criamos tutoriais sobre a instalação de um servidor WAMP e sobre a utilização do phpMyAdmin, recomendo que siga os tutoriais abaixo para concluir a operação:

Feito isso, você terá o phpMyAdmin instalado em seu computador para que possamos continuar.

Dentro do phpMyAdmin, você precisará acessar a opção “SQL” (no menu superior do lado direito).

SQL no phpMyAdmin

SQL no phpMyAdmin

A caixa de texto acima permite que você execute consultas MySQL como se estivesse fazendo por linha de comando.

Entendendo comandos MySQL

Apesar de não ser necessário colocar ponto e vírgula (;) na maioria dos programas gerenciadores MySQL (nem no PHP com PDO) é interessante que você nunca se esqueça de coloca-lo ao final de cada consulta que realizar manualmente, pois este é o modo correto. Portanto, todo e qualquer comando MySQL que você executar, deve terminar com um ponto e vígula (;).

Exemplo:

CREATE DATABASE `minha_base_de_dados`;

Para os nomes de tabelas, bases de dados e campos, é interessante colocar dois acentos ao redor dos nomes, já que se o nome de sua tabela ou base de dados coincidir com qualquer comando MySQL, ocorrerá um erro e sua consulta não será realizada.

Exemplo:

SELECT `base_de_dados`.`tabela`.`campo` FROM `base_de_dados`.`tabela`;

Os nomes de comandos devem estar em letras maiúsculas.

Valores devem vir entre aspas. Exemplo:

SELECT `campo` FROM `tabela` WHERE `campo` = 'Valor';

Essas são as dicas básicas sobre os comandos MySQL.

Criando uma base de dados

Para criar uma base de dados utilizando comandos MySQL, utilizamos o seguinte:

CREATE DATABASE `nome_da_base_de_dados`;

Onde “nome_da_base_de_dados” seria exatamente o nome da base de dados que você deseja criar.

Pode ocorrer da base de dados que você estiver tentando criar já existir no seu servidor MySQL. Se isso ocorrer, você verá um erro no seguinte formato:

Can't create database 'nome_da_base_de_dados'; database exists

Que significa que a base de dados que você está tentando criar já existe.

Para resolver este erro, podemos fazer o seguinte:

CREATE DATABASE IF NOT EXISTS `nome_da_base_de_dados`;

O “IF NOT EXISTS” faz aquele erro se tornar um “Warning“, o que não afeta sua consulta em nada.

Criando uma tabela

Para criar uma tabela, utilizamos o seguinte comando:

CREATE TABLE IF NOT EXISTS `nome_da_base_de_dados`.`nome_da_tabela` (
    `campo_id` INT (11) NOT NULL AUTO_INCREMENT,
    PRIMARY KEY (`campo_id`)
);

Este é o comando mais básico que existe para criarmos uma tabela, já que você deve ter pelo menos um campo na mesma.

A parte inicial do comando é bem intuitiva, veja:

/* 
 * Crie a tabela nome_da_tabela na base de dados
 * nome_da_base_de_dados se a mesma não existir
 */
CREATE TABLE IF NOT EXISTS `nome_da_base_de_dados`.`nome_da_tabela`

Logo em seguida, entre parênteses, adicionamos os campos e os detalhes dos campos.

/*
 * Campo 'campo_id'
 * INT (11) - Inteiro, Máximo de 11 casas
 * NOT NULL - Campo não pode ser nulo (valor em branco)
 * AUTO_INCREMENT - Campo é incrementado automaticamente
 */
`campo_id` INT (11) NOT NULL AUTO_INCREMENT,

Podemos adicionar quantos campos quisermos no mesmo formato, por exemplo:

CREATE TABLE `nome_da_base_de_dados`.`nome_da_tabela` (
    `campo_id` INT (11) NOT NULL AUTO_INCREMENT,
    `campo_texto_limitado` VARCHAR (255),
    `campo_texto_ilimitado` TEXT,
    `campo_numerico` INT (11),
    `campo_data` DATETIME NOT NULL DEFAULT '0000-00-00 00:00:00',
    PRIMARY KEY (`campo_id`)
) CHARSET = utf8 ;

Veja o mesmo comando comentado:

/* 
 * Crie a tabela nome_da_tabela na base de dados
 * nome_da_base_de_dados se a mesma não existir
 */
CREATE TABLE IF NOT EXISTS `nome_da_base_de_dados`.`nome_da_tabela` (

    /*
     * Campo 'campo_id'
     * INT (11) - Inteiro, Máximo de 11 casas
     * NOT NULL - Campo não pode ser nulo (valor em branco)
     * AUTO_INCREMENT - Campo é incrementado automaticamente
     */
    `campo_id` INT (11) NOT NULL AUTO_INCREMENT,

    /*
     * Campo 'campo_texto_limitado'
     * VARCHAR (255) - Campo de texto, máximo de 255 caracteres
     */    
    `campo_texto_limitado` VARCHAR (255),
    
    /*
     * Campo 'campo_texto_ilimitado'
     * TEXT - Texto
     */     
    `campo_texto_ilimitado` TEXT,  
     
    /*
     * Campo 'campo_numerico'
     * INT (11) - Inteiro com 11 casas
     */   
    `campo_numerico` INT (11),
    
      
    /*
     * Campo 'campo_data'
     * DATETIME - Data e hora
     * NOT NULL - Não pode ser nulo
     * DEFAULT '0000-00-00 00:00:00' - Valor padrão 0000-00-00 00:00:00
     */   
    `campo_data` DATETIME NOT NULL DEFAULT '0000-00-00 00:00:00',
    
    /*
     * PRIMARY KEY (`campo_id`) - Chave primária 'campo_id'
     */     
    PRIMARY KEY (`campo_id`)
    
) 

/*
 * Charset padrão UTF8
 */ 
CHARSET = utf8 ;

Os detalhes estão todos nos comentários.

 Alterando a tabela

Para alterar uma tabela já criada, utilizamos o seguinte:

ALTER TABLE `nome_da_base_de_dados`.`nome_da_tabela` 
    ADD COLUMN `novo_campo` VARCHAR (255);

Neste caso estou adicionando um novo campo chamado “novo_campo” e descrevendo o tipo desse campo.

Caso queira remover um campo, deverá fazer o seguinte:

ALTER TABLE `nome_da_base_de_dados`.`nome_da_tabela` 
    DROP `novo_campo` ;

Poderá fazer isso com qualquer campos que preferir.

Caso queira alterar um campo que já existe:

ALTER TABLE `nome_da_base_de_dados`.`nome_da_tabela` 
    CHANGE `campo_texto_limitado` `novo_nome` VARCHAR (10);

Agora o “campo_texto_limitado” se chamará “novo_nome” e será limitado em 10 caracteres.

Apagando a tabela

Para apagar a tabela, faça o seguinte:

DROP TABLE `nome_da_base_de_dados`.`nome_da_tabela`;

E pronto, já era!

INSERT – Inserindo valores na tabela

Agora que você já aprendeu a manipular bases de dados e tabelas, crie novamente a tabela que você “dropou” (apagou) acima e vamos inserir valores nos campos.

O comando INSERT funciona da seguinte maneira:

INSERT INTO `nome_da_base_de_dados`.`nome_da_tabela` (
    `campo_texto_limitado`,
    `campo_texto_ilimitado`,
    `campo_numerico`,
    `campo_data`
) 
VALUES
(
        'Valor do campo',
        'Um texto qualquer! <p>Até HTML se preferir</p>',
        '50',
        '2014-10-21 12:15:41'
) ;

Ou seja, você descreve os campos que quer preencher e, em VALUES, descreve os valores na mesma ordem em que adicionou os campos. Além disso, VALUES também pode inserir vários campos ao mesmo tempo, basta adicionar os valores entre parênteses e separá-los por vírgula.

Veja:

INSERT INTO `nome_da_base_de_dados`.`nome_da_tabela` (
    `campo_texto_limitado`,
    `campo_texto_ilimitado`,
    `campo_numerico`,
    `campo_data`
) 
VALUES
(
        'Valor 1',
        'Texto 1',
        '1',
        NOW()
),
(
        'Valor 2',
        'Texto 2',
        '2',
        NOW()
),
(
        'Valor 3',
        'Texto 3',
        '3',
        NOW()
);

Agora eu adicionei 3 linhas na base de dados em um único comando.

Observação: NOW() é uma função MySQL para retornar a data e hora atual.

SELECT – Lendo valores cadastrados na tabela

SELECT é o comando MySQL que utilizamos para selecionar valores da base de dados. Ele pode se tornar um comando extremamente complexo.

Com ele você pode unir valores de várias tabelas, utilizar funções e alias para retornar valores de cálculos e funções MySQL e muito mais. Hoje vamos ficar no básico, já que poderíamos escrever milhares de artigos apenas para descrever a complexidade do comando SELECT.

Para não precisarmos ficar descrevendo o nome completo da base de dados, tabela e campos que queremos selecionar, podemos descrever para o MySQL qual base de dados estamos utilizando da seguinte maneira:

USE `nome_da_base_de_dados`;

Assim, ao invés de escrever `nome_da_base_de_dados`.`nome_da_tabela` toda vez que precisarmos, podemos descrever apenas `nome_da_tabela`, já que o MySQL já sabe em qual base de dados estamos trabalhando.

Para selecionar os valores de uma tabela, utilizamos o seguinte:

SELECT 
    `campo_id`,
    `campo_texto_limitado`,
    `campo_texto_ilimitado`,
    `campo_numerico`,
    `campo_data` 
FROM
    `nome_da_tabela` ;

Ou seja: “Selecione campo_id, campo_texto_limitado, campo_texto_ilimitado, campo_numerico, campo_data da tabela nome_da_tabela”.

Isso retornará os valores que cadastramos com o comando “INSERT”.

Se você for selecionar todos os campos da tabela (como eu fiz), pode simplificar a consulta fazendo o seguinte:

SELECT 
    * 
FROM
    `nome_da_tabela` ;

O asterisco significa “todos”.

ORDER BY – Ordenação

O comando SELECT pode ser ordenado utilizando o seguinte:

SELECT 
    * 
FROM
    `nome_da_tabela` 
ORDER BY campo_id ASC ;

Ou seja: “Ordene pelo campo_id de forma crescente”.

Caso queira ordenar de forma decrescente, utilize DESC.

SELECT 
    * 
FROM
    `nome_da_tabela` 
ORDER BY campo_id DESC ;

Você pode ordenar por mais de um campo, conforme preferir:

SELECT 
    * 
FROM
    `nome_da_tabela` 
ORDER BY `campo_id` ASC,
    `campo_data` DESC,
    `campo_numerico` ASC ;

Só que (conforme a consulta acima) se os campos não coincidirem com o que você precisa, sua consulta entrará em “contradição” (por assim dizer) e o MySQL vai demorar mais para realizar a tarefa. Além disso, podem ocorrer efeitos indesejados caso você utilize a ordenação de forma incorreta.

Existem mais formas para ordenar valores no MySQL, como ordem randômica por exemplo:

SELECT 
    * 
FROM
    `nome_da_tabela` 
ORDER BY RAND() ;

Mas vamos ficar no básico por hoje.

WHERE – Selecionando valores específicos

Com os comandos UPDATE, DELETE e SELECT, você pode selecionar um valor específico na base de dados, ou seja, apenas uma linha.

Para isso, utilizamos o comando “WHERE”, veja:

SELECT * FROM `nome_da_tabela` WHERE `campo_texto_ilimitado` = 'Texto 2';

Agora apenas as linhas onde o ‘campo_texto_ilimitado for igual’ a ‘Texto 2’ serão retornadas.

Você pode utilizar os operadores (como o sinal de igual utilizado acima) para coincidir valores. Por exemplo, vamos mudar o operador utilizado acima para “LIKE”.

SELECT * FROM `nome_da_tabela` WHERE `campo_texto_ilimitado` LIKE 'Text%';

Agora todos os valores do campos campo_texto_ilimitado que contenham a palavra “Text” no início serão encontrados.

Você também pode ser mais específico quanto aos campos e procurar mais valores.

SELECT 
    * 
FROM
    `nome_da_tabela` 
WHERE `campo_texto_ilimitado` LIKE 'Text%' 
    AND `campo_numerico` = 3
    OR `campo_numerico` = 2;

Agora estamos verificando se o campo_texto_ilimitado tem a palavra “Text” no início e se o campo_numerico tem valor 3 ou 2. AND  e OR são utilizados para descrever “E” e “OU” respectivamente.

Observação: Valores numéricos não precisam de aspas.

UPDATE – Editando valores

Para editar valores cadastrados na sua base de dados, utilizamos o seguinte:

UPDATE 
    `nome_da_tabela` 
SET
    `campo_texto_ilimitado` = 'Novo valor' 
WHERE campo_numerico = 3 ;

Ou seja: “Atualize a tabela `nome_da_tabela` ; configure o campo `campo_texto_ilimitado` para ‘Novo valor’; onde o `campo_numerico` for igual a 3”.

Simples assim!

Tudo o que já foi descrito sobre “WHERE” se aplica aqui também.

Para atualizar vários campos ao mesmo tempo, faça o seguinte:

UPDATE 
    `nome_da_tabela` 
SET
    `campo_texto_ilimitado` = 'Novo valor',
    `campo_numerico` = 3,
    `campo_texto_limitado` = 'Outra coisa qualquer' 
WHERE campo_numerico = 3 ;

Agora, além do campo_texto_ilimitado, também estou atualizando campo_numerico e campo_texto_limitado.

DELETE – Apagando valores da base de dados

Este é o comando mais perigoso para valores de tabelas MySQL, pois não tem NENHUMA CONFIRMAÇÃO. Uma vez apagados, valores não podem ser recuperados.

Apesar disso, é um dos comandos mais simples para serem executados.

Para apagar qualquer valor de uma tabela MySQL, simplesmente faça o seguinte:

DELETE FROM `nome_da_tabela` WHERE `campo_numerico` = 3;

Pronto! Agora todos os valores onde o campo_numerico for igual a 3 serão apagados.

Dica: Para garantir que apenas uma linha seja apagada, utilize a chave primária (nosso caso, campo_id), já que é garantido que ela tenha o  valor único daquela linha em toda a tabela.

Concluindo

Ainda vamos aprofundar bem mais em comando MySQL específicos. Eu quis fazer essa introdução para que você possa ter um local seguro para realizar seus testes.

O melhor modo de aprender é errando e tentando novamente, portanto treine no seu novo servidor WAMP.

Em caso de dúvidas, deixe um comentário.

Se você trabalha em qualquer área do desenvolvimento há muito tempo, provavelmente já deve ter se deparado com tipos de dados estranhos, como a {php}string{/php} apresentada abaixo:

a:3:{s:6:"chave1";b:1;i:0;i:1234;i:1;a:2:{i:0;i:1;i:1;i:2;}}

Isso se chama serialização, ou seja, transformar qualquer tipo de dado em uma string para ter a possibilidade de salvar tais dados na base de dados.

Neste artigo, você vai entender como criar dados serializados e fazer a desserialização (retornar o tipo de dados original) posteriormente.

Serialização de dados PHP

Para serializar qualquer tipo de dado em PHP, simplesmente utilize a função {php}serialize{/php} (ver manual). Por exemplo:

<?php
// Array original
$array_original = array(
	'chave1' => true,
	1234,
	array(1,2),
);

// Serializando o array
// a:3:{s:6:"chave1";b:1;i:0;i:1234;i:1;a:2:{i:0;i:1;i:1;i:2;}} 
$array_serializado = serialize($array_original);
?>

O {php}array{/php} serializado acima deverá retornar o seguinte:

a:3:{s:6:"chave1";b:1;i:0;i:1234;i:1;a:2:{i:0;i:1;i:1;i:2;}}

Embora isso não se pareça inteligível para mais leigos, ao final do artigo vou explicar como ler e entender tais dados.

Se você salvar a {php}string{/php} gerada pela serialização no seu banco de dados, vai conseguir recuperar seus dados originais com apenas uma linha de código. É isso que vamos ver agora.

Desserialização em PHP

Certo, então eu tenho aquele dado estranho na minha base de dados, como faço para recuperar o formato original?

Simples demais, veja:

<?php
// Array serializado
$array_serializado = 'a:3:{s:6:"chave1";b:1;i:0;i:1234;i:1;a:2:{i:0;i:1;i:1;i:2;}}';

// Retornando o array original
$array_original = unserialize( $array_serializado );

print_r( $array_original );

/**

Retorno: 
Array
(
    [chave1] => 1
    [0] => 1234
    [1] => Array
        (
            [0] => 1
            [1] => 2
        )

)
*/
?>

Na verdade é só utilizar a função {php}unserialize{/php} (ver manual).

Nos meus exemplos acima, utilizei apenas arrays como cobaias, porém, isso funciona com quase todos os tipos de dados, como objetos, arrays, booleans, e assim por diante.

Como funciona a serialização em PHP

A serialização sabe exatamente qual o tipo de dado você está serializando pelo simples fato de deixar tudo anotado na própria string.

Veja nosso exemplo anterior:

a:3:{s:6:"chave1";b:1;i:0;i:1234;i:1;a:2:{i:0;i:1;i:1;i:2;}}

Vamos organizar e indentar esses valores para você entender melhor.

a:3: {
	s:6: "chave1";
	b:1; 
	i:0;
	i:1234;
	i:1;
	a:2: {
		i:0;i:1;i:1;i:2;
	}
}

Sempre temos uma letra e um número que indicam o tipo de dado e seu tamanho, em seguida seu valor. Por exemplo:

  • a:3: Array com 3 chaves/valores
  • s:6; String com 6 casas
  • b:1; Boolean verdadeiro (0 para falso)
  • i:0; Inteiro 0
  • i:1234; Inteiro 1234
  • a:2: Array com 2 chaves/valores

E temos mais alguns tipos, exemplo:

  • N; Null
  • O:N:"stdClass":N: Objeto

Não que você vá precisar ler dados serializados, já que o PHP faz isso graciosamente por você com a função {php}unserialize{/php}, porém, é sempre importante entender como as coisas funcionam.

Trabalhar com PHP é sinônimo de trabalhar com páginas dinâmicas, e não há a possibilidade de imaginar páginas dinâmicas sem uma base de dados onde salvar os dados.

PDO é uma classe PHP que representa a conexão entre o PHP e o servidor de banco de dados. Com essa classe é possível adicionar, excluir e editar dados presentes em bancos de dados e tabelas de vários SGBDs diferentes, tais como MySQL, SQLite, PostgreSQL, e outros.

Para esse tutorial em específico, vamos aprender a conectar e manipular dados de bases de dados MySQL utilizando PDO.

Então vamos lá.

Criando o banco de dados

Antes de qualquer coisa, precisamos criar uma base de dados em nosso servidor MySQL para conectar-se posteriormente com PDO. Felizmente, ontem explicamos como fazer isso utilizando o phpMyAdmin:

Vou criar uma base de dados chamada contatos.

Você pode fazer isso pelo phpMyAdmin (como explicado no artigo mencionado anteriormente), ou diretamente pelo servidor MySQL. Se estiver utilizando o servidor MySQL, vou detalhando o que vou fazer, e logo em seguida mostrarei o comando.

Comando MySQL:

CREATE DATABASE `contatos`; 

Depois criei um usuário chamado user_db_contatos, senha senha_db_contatos, com permissão somente na base de dados contatos.

Comando MySQL:

CREATE USER 'user_db_contatos' @'%' IDENTIFIED BY 'senha_db_contatos' ;
FLUSH PRIVILEGES; 
GRANT ALL ON `contatos`.* TO 'user_db_contatos'@'%';

Logo em seguida, criei uma tabela chamada tabela_contatos com os seguintes campos:

  • IDcontato_id
  • Nome contato_nome
  • Sobrenome contato_sobrenome
  • Email contato_email
  • Site contato_site
  • Data de nascimentocontato_data_nascimento
  • Telefone contato_telefone
  • Descrição contato_descricao

Comando MySQL:

CREATE TABLE `contatos`.`tabela_contatos` (
  `contato_id` INT (11) NOT NULL AUTO_INCREMENT,
  `contato_nome` VARCHAR (40),
  `contato_sobrenome` VARCHAR (40),
  `contato_email` VARCHAR (50),
  `contato_site` VARCHAR (255),
  `contato_data_nascimento` DATETIME DEFAULT '0000-00-00 00:00:00',
  `contato_telefone` VARCHAR (25),
  `contato_descricao` TEXT,
  PRIMARY KEY (`contato_id`)
) ;

Perceba que não podemos adicionar acentos, ou caracteres estranhos para o nome de nossos campos, portanto, tente utilizar apenas letras, números e um caractere sublinhado (underline) para separar as palavras.

Crie a base de dados, o usuário e a tabela e vamos para a próxima parte da aula.

PDO – Conectando-se à base de dados

Depois de configurar a base de dados, podemos iniciar a configuração de nosso script de conexão PDO em PHP.

Vamos separar a conexão do arquivo principal, portanto, crie dois arquivos:

  • index.php – Terá a configuração que o usuário vai ver na tela do navegador (sem PDO);
  • conexao.php – Terá a configuração do nosso script PDO (será embutido no arquivo index.php);

Após a criação, abra o arquivo "conexao.php" e crie as seguintes variáveis:

<?php
/* Variáveis para conexão PDO */
$base_dados = 'contatos';
$usuario_bd = 'user_db_contatos';
$senha_bd   = 'senha_db_contatos';
$host_db    = 'localhost';

Perceba que vou utilizar os dados das variáveis acima para a conexão PDO com a base de dados, portanto, preencha os valores corretamente. Se você alterou alguma coisa anteriormente, também terá que alterar os dados nas variáveis acima.

Para criar uma instância da classe PDO, basta fazer o seguinte:

// Instância PDO
$conexao_pdo = new PDO('mysql:host=IP_OU_HOST_AQUI;dbname=NOME_DO_BD', 'USUÁRIO', 'SENHA');

Para a nossa conexão, vamos deixar isso um pouco mais simples:

<?php
/* Variáveis PDO */
$base_dados = 'contatos';
$usuario_bd = 'user_db_contatos';
$senha_bd   = 'senha_db_contatos';
$host_db    = 'localhost';
$conexao_pdo = null;

/* Concatenação das variáveis para detalhes da classe PDO */
$detalhes_pdo = 'mysql:host=' . $host_db . ';dbname='. $base_dados;

// Tenta conectar
try {
    // Cria a conexão PDO com a base de dados
    $conexao_pdo = new PDO($detalhes_pdo, $usuario_bd, $senha_bd);
} catch (PDOException $e) {
    // Se der algo errado, mostra o erro PDO
    print "Erro: " . $e->getMessage() . "<br/>";
	
    // Mata o script
    die();
}
?>

Você não precisa decorar isso, apenas altere os valores das variáveis e pronto, conectado à base de dados com a classe PDO instanciada em $conexao_pdo.

Exibindo dados na tabela MySQL com PDO

ATENÇÃO: Você vai precisar saber comandos MySQL para continuar essa leitura, caso não saiba nada, leia nos links abaixo:

Agora abra o arquivo index.php (ou o arquivo que você tiver criado anteriormente) e, na primeira linha, coloque o seguinte:

<?php include('conexao.php');?>

A função include do PHP faz a inclusão do que escrevemos no arquivo conexao.php para o arquivo index.php, assim nosso script ficará mais organizado.

Para iniciar qualquer ação com PDO, primeiramente temos que preparar o comando a ser executado pelo MySQL com o método PDO::prepare.

Veja um exemplo:

// A classe PDO prepara o comando a ser executado
$prepara = $conexao_pdo->prepare('SELECT * FROM tabela_contatos');

Como você pode perceber acima, estamos preparando nosso servidor MySQL para receber o comando "SELECT * FROM tabela_contatos" (selecione tudo da tabela tabela_contatos).

Feito isso, é necessário executar o comando:

// A classe PDO executa o comando
$prepara->execute();

Agora o comando que havíamos enviado anteriormente é executado. Porém, agora precisamos de mais um recurso para visualizar os dados, PDO::fetch. Este método nos retorna a linhas de uma consulta SQL, além disso, retorna true enquanto houver novas linhas. Isso indica que podemos utilizar o laço while para mostrar tudo o que for encontrado pelo comando que executarmos.

Por exemplo:

// Laço para exibir todas as linhas
while ( $linha = $prepara->fetch() ) {
	echo 'Nome: ' . $linha['contato_nome'] . '<br>';
	echo 'Sobrenome: ' . $linha['contato_sobrenome'] . '<br>';
	// ... E assim por diante ... 
}

Observação: Você deve adicionar dados na tabela, caso contrário, nada será exibido na tela.

Perceba que você deve saber o nome dos campos que deseja exibir para utilizar com a variável criada na condição do laço while.

Quando precisamos enviar parâmetros para o comando – selecionar um ID em específico, por exemplo – devemos enviar um interrogação (?) para cada parâmetro.

Veja um exemplo:

// Prepara o comando a ser executado
$prepara = $conexao_pdo->prepare('SELECT * FROM tabela_contatos WHERE contato_id = ?');

Perceba que estamos agora enviando o seguinte comando para o servidor MySQL: SELECT * FROM tabela_contatos WHERE contato_id = ? (selecione tudo da tabela tabela_contatos onde campo contato_id é igual a ? ).

Esse interrogação será enviado para o método PDO::execute como um array. Veja:

// Parâmetros do comando SQL
$parametros = array( 2 );

// Executa o comando
$prepara->execute( $parametros );

Ou seja, meu primeiro interrogação será substituído pelo número 2, que estou enviando como parâmetro.

Caso precise enviar mais parâmetros, basta adicionar interrogações em todos os locais onde iriam os valores, depois adicionar os valores no array de parâmetros. Por exemplo:

// Prepara o comando a ser executado
$prepara = $conexao_pdo->prepare('SELECT * FROM tabela_contatos WHERE contato_id = ? OR contato_id = ?');

// Parâmetros do comando SQL
$parametros = array( 2, 1 );

// Executa o comando
$prepara->execute( $parametros );

// Laço para exibir todas as linhas
while ( $linha = $prepara->fetch() ) {
	echo 'Nome: ' . $linha['contato_nome'] . '<br>';
	echo 'Sobrenome: ' . $linha['contato_sobrenome'] . '<br>';
	// ... E assim por diante ... 
}

Agora estou pedindo para exibir os IDs 1 e 2.

Você pode utilizar qualquer tipo de consulta, como "BETWEEN", "LIKE", e demais. Por exemplo, suponhamos que eu queira utilizar LIKE, veja:

<?php include('conexao.php');?>

<?php
// Prepara o comando a ser executado
$prepara = $conexao_pdo->prepare(
	'SELECT 
	  * 
	FROM
	  tabela_contatos 
	WHERE contato_nome LIKE ? 
	  OR contato_nome LIKE ?'
);

// Parâmetros do comando SQL
$parametros = array( '%pedaço do nome%', '%outro pedaço%' );

// Executa o comando
$prepara->execute( $parametros );

// Laço para exibir todas as linhas
while ( $linha = $prepara->fetch() ) {
	echo 'Nome: ' . $linha['contato_nome'] . '<br>';
	echo 'Sobrenome: ' . $linha['contato_sobrenome'] . '<br>';
	// ... E assim por diante ... 
}

Perceba também que só iremos utilizar o laço while quando utilizarmos o comando "SELECT", para "UPDATE", "INSERT" e "DELETE", não é necessário (vamos falar sobre cada um dos comandos).

Inserindo dados na tabela MySQL com PDO

Para inserir dados na tabela, siga a mesma estrutura, porém, não é necessário utilizar o laço while.

Por exemplo:

<?php include('conexao.php');?>

<?php
// Prepara o comando a ser executado
$prepara = $conexao_pdo->prepare(
	"INSERT INTO `contatos`.`tabela_contatos` (
	  `contato_nome`,
	  `contato_sobrenome`,
	  `contato_email`,
	  `contato_site`,
	  `contato_data_nascimento`,
	  `contato_telefone`,
	  `contato_descricao`
	) 
	VALUES ( 
		?, 
		?,
		?, 
		?, 
		?, 
		?, 
		?
	)"
);

// Parâmetros do comando SQL
$parametros = array( 
	'José',
	'Silva de Oliveira',
	'[email protected]/w',
	'http://www.todoespacoonline.com/w',
	'1987-04-20 13:45:57',
	'+553588888888',
	'Meu nome é José Silva de Oliveira e tenho 27 anos.'
);

// Executa o comando
$verifica = $prepara->execute( $parametros );

// Verifica se o comando foi executado
if ( $verifica ) {
	echo 'Dados enviados à base de dados com sucesso';
} else {
	$erro = $prepara->errorInfo();
	echo 'Ocorreu um erro na sua consulta. <br>';
	echo 'Erro: ' . $erro[2];
}

Verifique que agora inseri dados na base de dados, e mesmo assim tudo continua o mesmo. Onde eu deveria colocar valores; coloco interrogações. Depois substituo os pontos de interrogação por valores do array de parâmetros. Os pontos de interrogação serão substituídos na mesma ordem em que foram adicionados no array.

Como o método PDO::execute retorna true se o comando for executado com sucesso, podemos fazer a verificação para saber se os dados foram enviados para a base de dados corretamente:

// Verifica se o comando PDO foi executado com sucesso
if ( $verifica ) {
	echo 'Dados enviados à base de dados com sucesso';
} else {
	$erro = $prepara->errorInfo();
	echo 'Ocorreu um erro na sua consulta. <br>';
	echo 'Erro: ' . $erro[2];
}

Editando dados da tabela MySQL com PDO

Para editar dados não muda muita coisa, porém, é mais seguro se enviarmos o ID da linha que queremos editar. Veja:

<?php include('conexao.php');?>

<?php
// Prepara o comando a ser executado
$prepara = $conexao_pdo->prepare(
	"UPDATE tabela_contatos SET contato_nome = ? WHERE contato_id = ? "
);

// Parâmetros do comando SQL
$parametros = array('Serafim', 6);

// Executa o comando
$verifica = $prepara->execute( $parametros );

// Verifica se o comando foi executado
if ( $verifica ) {
	echo 'Dados enviados à base de dados com sucesso';
} else {
	$erro = $prepara->errorInfo();
	echo 'Ocorreu um erro na sua consulta. <br>';
	echo 'Erro: ' . $erro[2];
}

Ou seja, estou executando um comando que modifica o nome que estiver na linha de ID 6 para "Serafim". Simples assim.

Excluindo dados da tabela MySQL com PDO

Para excluir dados é mais simples ainda.

Basta enviar o comando e executar:

<?php include('conexao.php');?>

<?php
// Prepara o comando a ser executado
$prepara = $conexao_pdo->prepare("DELETE FROM tabela_contatos WHERE contato_id = ?");

// Parâmetros do comando SQL
$parametros = array( 6 );

// Executa o comando
$verifica = $prepara->execute( $parametros );

// Verifica se o comando foi executado
if ( $verifica ) {
	echo 'Linha excluída.';
} else {
	$erro = $prepara->errorInfo();
	echo 'Ocorreu um erro na sua consulta. <br>';
	echo 'Erro: ' . $erro[2];
}

Pronto, agora excluí a linha com ID 6 (contato_id = 6).

Vídeo tutorial: PDO em PHP

Assista a um vídeo tutorial para complementar o artigo acima:

Concluindo

Este é o método mais seguro para manipular dados de bases de dados em PHP. Além de prevenir SQLInjection, os outros métodos que utilizávamos antigamente estão obsoletos.

Caso tenha qualquer dúvida, basta deixar um comentário. Será um prazer ajudar.

Não deixe de acessar outras aulas do nosso curso gratuito de PHP.

O phpMyAdmin é um sistema de gerenciamento de bases de dados online, ou seja, você utiliza seu navegador para criar, apagar e editar tabelas e bancos de dados no servidor MySQL.

É interessante utilizar este sistema, já que você não vai precisar entender muito sobre o servidor MySQL em si, tudo será gerenciado por uma interface simples, intuitiva, e, relativamente fácil de se trabalhar.

O melhor da história é que o software que estamos utilizando como servidor WAMP em nosso curso de PHP gratuito – o EasyPHP – já vem com um servidor MySQL e o phpMyAdmin nativamente. Se você estiver seguindo nosso curso à risca, ambos já estão instalados em seu computador.

Se você perdeu a aula onde falamos sobre nosso servidor WAMP, leia o artigo abaixo:

Naquela aula descrevi como instalar e utilizar o EasyPHP.

Criando tabelas e bases de dados no phpMyAdmin

Agora que você já tem o EasyPHP com phpMyAdmin instalado em seu computador, podemos começar a criação de uma base de dados.

Criando a base de dados

1 – Primeiramente, clique com o botão direito do mouse sobre o ícone do EasyPHP na bandeja do sistema, e selecione a opção "Administration";

EasyPHP - Administration

2 – Dentro da janela que abriu em seu navegador de internet padrão, procure o módulo do phpMyAdmin e clique em "Open";

phpMyAdmin: Open

3 – Na lado esquerdo, você vai ver um link com a palavra "New" (Novo); Clique sobre este link para criar um novo banco de dados;

Nova base de dados no phpMyAdmin

4 – Na janela que abriu no lado direito da tela, digite o nome do banco de dados que deseja, e clique em "Criar";

Criar base de dados no phpMyAdmin

5 – Você vai perceber que sua base de dados foi criada com o nome escolhido; Clique sobre ela;

Base de dados no phpMyAdmin

6 – No menu superior, clique em "Privilégios" para adicionar um novo usuário para a sua base de dados;

phpMyAdmin - Privilégios

7 – Na janela que abriu, clique em "Adicionar utilizador";

 

phpMyAdmin - Adicionar utilizador

8 – Preencha os campos:

  1. Nome do usuário;
  2. O IP ou nome do host que deseja se conectar (% para todos);
  3. A senha do usuário;
  4. Repita a senha.

Marque a caixa "Grant all privileges on database nome_do_seu_bd".

Criando usuário - phpMyAdmin

9 – Por fim, clique em "Executar". Este é um botão que fica no final da página.

Criando um tabela

Para criar uma tabela com o phpMyAdmin faça o seguinte:

1 – Clique sobre o banco de dados desejado;

Banco de dados - phpMyAdmin

2 – No canto direito da tela, digite o nome da tabela e o número de campos;

Criar tabela no phpMyAdmin

3 – Um dos seus campos deverá ser incrementado automaticamente. Normalmente utilizamos este campo como o identificador da linha requisitada (ID).

Neste campo você deve preencher o seguinte:

  1. Nome;
  2. Tipo INT (Inteiro);
  3. Tamanho (número de casas seu número inteiro terá);
  4. Índice PRIMARY;
  5. Marque a caixa "A.I." (para que o campo seja incrementado automaticamente).

Os demais campos podem ser de texto puro com limite de caracteres – VARCHAR, 255, por exemplo – ou texto puro sem limite de caracteres – TEXT, por exemplo.

Além disso, se você entende de servidores MySQL, poderá colocar outros tipos de campos, depende dos dados que serão incluídos nesse campo.

Criando tabelas - phpMyAdmin

4 – Se você verificar a sua base de dados após a criação, verá que agora temos os dados necessários para começar a brincar com PDO em PHP (assunto para a próxima aula).

BD com tabelas - phpMyAdmin

Vídeo tutorial: Criando tabelas e bases de dados no phpMyAdmin

Abaixo um vídeo tutorial para complementar o artigo acima:

Qualquer dúvida, basta comentar aí abaixo.

Concluindo

O phpMyAdmin deixa as coisas bem simples quando vamos gerenciar nossas bases de dados e tabelas, porém, você também pode fazer isso diretamente com PHP, ou no servidor MySQL por linha de comando, se souber um pouco mais do assunto.

Essa aula faz parte do nosso curso gratuito de PHP, já que na próxima aula iremos falar sobre PDO (conexão e manipulação de dados da base de dados em PHP).

Até lá!

EasyPHP é um software gratuito que cria um servidor Wamp (Windows, Apache, MySQL e PHP) no seu computador com Windows. Ele faz praticamente tudo automaticamente, você só precisa baixar e executar o instalador.

O mais interessante do EasyPHP é que ele traz uma interface fácil de ser utilizada, onde você pode parar e reiniciar o servidor de MySQL e Apache com apenas um clique com o mouse. Além disso, ele também traz uma área administrativa com vários módulos já incluídos, dentre eles, destaque para o phpMyAdmin, que é um software web voltado para o gerenciamento de suas bases de dados MySQL.

Outra vantagem do EasyPHP é a facilidade com que você pode acessar os arquivos de configuração do Apache, MySQL, PHP e phpMyAdmin. Simplesmente um clique com o botão direito do mouse sobre o ícone do programa na bandeja do sistema da acesso ao que você precisa.

EasyPHP

A imagem acima mostra as opções do EasyPHP na bandeja (próximo ao relógio) do Windows.

Download do EasyPHP

Pretende testar o EasyPHP no seu computador? É bastante simples, você pode baixá-lo no site oficial utilizando o link abaixo:

Você também pode fazer uma pesquisa rápida no Google, que vai encontrar o link para download facilmente.

Primeiros passos com o EasyPHP em vídeo

Não há muito segredo em instalar e utilizar o EasyPHP, mesmo assim, fiz um pequeno tutorial em vídeo mostrando como dar os passos iniciais com o EasyPHP, e ter o seu servidor rodando no seu computador local.

Mostrei como fazer o download, instalar o EasyPHP, acessar a raiz do seu servidor local e criar um primeiro arquivo PHP de teste, como alterar os arquivos de configuração do Apache, MySQL e qualquer outro, como acessar a área administrativa, e mais algumas dicas legais sobre o software.

Você pode assistir ao vídeo logo abaixo:

Aproveite e inscreva-se em nosso canal, vamos trazer vários vídeos novos sobre desenvolvimento.