comandos-do

CRIANDO BANCO DE DADOS E TABELAS.
Neste exemplo temos a base de dados disponível: Elvis, que acabamos de criar:
SHOW DATABASES Exibe os nomes das bases de dados de um determinado banco
de dados.
Para podermos começar a trabalhar com nossa base de dados devemos avisar ao
MySQL que vamos usá-la. O comando para isto é: USE nome_db;
mysql> use elvis;
Database changed
mysql>
A partir de agora todos os comandos executados afetarão a base de dados Elvis.
USE Indica que iremos trabalhar com uma determinada base de dados.
Veremos agora como criar as tabelas, onde os dados serão armazanados.
A síntese de criação de tabelas do MySQL é a seguinte:
CREATE [TEMPORARY] TABLE [IF NOT EXISTS] nome_tabela
[(definição_create,...)] [table_options] [select_statement]
Novamente podemos nos valer do parâmetro opcional IF NOT EXISTS para
executarmos o comando sem termos certeza da existencia ou não da tabela.
Para criarmos uma tabela bastariamos executar a seguinte parte da síntese: CREATE
TABLE nome_tabela.
Mas é mais comum criarmos a tabela já acompanhada de seus campos (fields). Vamos
criar no nosso exemplo a tabela cad_aluno com os seguintes campos:
id - campo de identificação;
nome – Nome do aluno;
idade – Idade do aluno;
Para isto devemos executar o seguinte comando:
mysql> create table cad_aluno (
-> id int(3) unsigned not null auto_increment,
-> nome varchar(50) not null,
-> idade int(3) unsigned not null,
-> primary key (id));
Query OK, 0 rows affected (0.14 sec)
mysql>
Os campos são definidos da seguinte forma:
nome_campo tipo [ NULL | NOT NULL ] [ DEFAULT valor_padrão] [
AUTO_INCREMENT ]
No campo id por exemplo o tipo é int(10) com o modificador unsigned, ele não aceita
valores nulos (not null) e é auto_increment, ou seja, seu valor é definido
automaticamente, aumentando de 1 (um) em 1 (um) toda vez que um novo registro é
adicionado. Para fazer uso desta funcionalidade é necessário adicionar o valor 0 ou null
neste campo.
No campo titulo escolhemos o tipo varchar(80) o que significa que este campo aceita
caracteres alfanuméricos num máximo determinado por nós de 80. O campo também
não pode ser nulo.
Primeiramente acesse o utilitário de linha de comando do MySQL, selecione a base de
dados Elvis e verifique a existência da tabela cad_aluno.
mysql> use elvis;
Database changed
mysql> show tables;
+--------------------+
| Tables_in_elvis |
+--------------------+
| cad_aluno
|
+--------------------+
1 row in set (0.05 sec)
mysql>
INSERINDO DADOS NAS TABELAS:
A síntese básica do comando INSERT é a seguinte:
INSERT INTO nome_tabela [(nome_coluna,...)] VALUES (valores)
Vamos inserir os dados de um filme em nossa tabela.
mysql> insert into cad_aluno (id,nome,idade)
-> values (0,’elvis’,23');
Query OK, 1 row affected (0.08 sec)
mysql>
Com este comando inserimos os dados do nome elvis, da idade 23. Mas e o valor 0 da
coluna id?
Quando criamos a tabela cad_aluno definimos a coluna id como tendo a caracteristica
de ser auto_increment, ou seja, seu valor é incrementado automaticamente, não
precisamos nos preocupar com o valor inserido por último para decidirmos qual o valor
a ser inserido agora. Com esta característica podemos criar sequências de valores como
1,2,3,4,5,6... Para podermos aproveitar esta facilidade não podemos atribuir um valor
válido a coluna id, devemos inserir 0 ou NULL para que o banco de dados saiba que
desejamos que ele calcule sozinho o próximo valor válido.
Interessante ressaltar que valores do tipo texto (string) são colocados entre aspas
(simples ou dupla).
Poderiamos, também, inserir dados omitindo os nomes das colunas e colocando apenas
os valores no comando, desde que os valores estejam na mesma sequência das colunas
na tabela.
mysql> insert into cad_aluno values
-> (null,'fernando',28);
Query OK, 1 row affected (0.01 sec)
mysql>
Note que desta vez não colocamos os nomes das colunas antes da instrução VALUES.
Outra mudança que fizemos foi atribuir o valor null a coluna id.
Vamos ver como está nossa tabela no momento com o auxílio do comando SELECT.
mysql> select * from cad_aluno;
+----+-------------------+------+------------------+
| id | nome
|idade|
|
+----+-------------------+------+------------------+
| 1 | elvis
| 23 | |
| 2 | Fernando
| 28 | |
+----+-------------------+------+------------------+
2 rows in set (0.01 sec)
mysql>
SELECT comando SELECT realiza uma consulta ao banco de dados e retorna o
resultado desta consulta.
Observe que a coluna id contém uma sequência de valores, sequência esta gerada
automáticamente pelo banco de dados.
Vamos ver agora alguns erros que podem ser cometidos ao inserir dados.
ESQUECER DE ATRIBUIR VALOR A UMA COLUNA NOT NULL
No nosso caso a tabela cad_alunos possui apenas colunas que não aceitam valores
nulos (podemos verificar isto com o comando DESC nome_tabela), ou seja, geraremos
um erro se omitirmos qualquer valor, exceto o da coluna id, que neste caso atribuirá um
valor automático.
mysql> insert into cad_aluno (nome) values
-> ('Harry Potter');
ERROR 1364 (HY000): Field 'idade' doesn't have a default value
mysql>
Neste caso tentamos inserir apenas o valor do nome, o banco de dados não aceitou e
mostrou o erro 1364, para avisar que o campo idade não tem nenhum valor padrão (não
pode ser nulo, no caso) para ser atribuido.
ESQUECER DE COLOCAR UM VALOR DO TIPO TEXTO ENTRE ASPAS
mysql> insert into cad_aluno(nome,idade) values
-> (Harry Potter,19);
ERROR 1064 (42000): Você tem um erro de sintaxe no seu SQL
pr¾ximo a 'Newell)' na linha 2
mysql>
Aqui esquecemos de colocar aspas no nome do aluno, o banco de dados não aceitou a
entrada e gerou o erro 1064 e avisou que temos um erro de sintese na instrução SQL.
FINALMENTE INSERIMOS O ALUNO
Depois de todos estes erros vamos a síntese correta novamente.
mysql> insert into filmes (id,nome,idade) values
-> (0,'Harry Potter’,19);
Query OK, 1 row affected (0.23 sec)
mysql>
COMANDOS ALTER TABLE:
create table clientes
(id int unsigned not null auto_increment primary key,
nome char(80) not null,
fone int not null,
endereco char(160) not null);
O comando básico para se alterar colunas é o ALTER TABLE, seguido do nome da tabela. Então,
qualquer query de alteração da nossa tabela clientes começará da seguinte forma:
ALTER TABLE clientes
1. Adicionando colunas:
Para adicionar colunas a uma tabela MySQL use o comando ADD, seguido do nome e dos
atributos da coluna que será adicionada, e da sua posição dentro da tabela, com o auxílio do
parâmetro AFTER. Considerando que adicionaremos a coluna email à tabela clientes, nosso
código fica assim:
ALTER TABLE clientes ADD email char(80) not null AFTER fone;
Para ver o resultado das alterações, dê o comando DESCRIBE clientes.
2. Eliminando colunas:
O comando básico para se eliminar colunas de uma tabela é DROP, seguido do nome da
coluna. Use este comando com cuidado, pois todas as informações contidas dentro da coluna
serão perdidas. Assim, para eliminar nossa recém criada coluna email, usaremos a seguinte
query:
ALTER TABLE clientes DROP email;
Testaram? Simples e legal.
3. Alterando colunas:
O comando básico para alteração de atributos e nome de colunas é CHANGE, seguida da
denominação da coluna a ser alterada e dos novos atributos. Para mudar os atributos da
coluna fone, utilizaremos a seguinte query:
ALTER TABLE clientes CHANGE fone fone char(30) not null;
Vocês devem ter percebido que a palavra 'fone' foi utilizada duas vezes. Isso ocorre porque se
indica primeiro a coluna e depois seus novos atributos, e o nome da coluna é um de seus
atributos.
Supomos que queiramos agora somente mudar o nome da coluna, e manter seus demais
atributos:
ALTER TABLE clientes CHANGE fone telefone char(30) not null;
Veja as alterações com DESCRIBE clientes;
Muito cuidado ao se alterar atributos de colunas, especialmente datatypes, pois todas as
informações que não podem ser interpretadas como características do novo datatype serão
perdidas.
DELETANDO DADOS.
Primeiramente acesse o utilitário de linha de comando do MySQL, selecione a base de
dados Locadora e verifique a existência da tabela filmes.
mysql> use locadora;
Database changed
mysql> show tables;
+--------------------+
| Tables_in_locadora |
+--------------------+
| filmes
|
+--------------------+
1 row in set (0.05 sec)
O comando SQL que nos permite excluir dados no MySQL é o comando DELETE.
A sintaxe básica do comando DELETE é a seguinte:
DELETE FROM table_name [WHERE definição_where]
O comando DELETE é aplicado a uma tabela e pode ou não ter uma cláusula WHERE
que restringe os registro nos quais ele atuará.
Este comando retorna o número de registros excluídos da tabela.
Se não for especificada uma cláusula WHERE o comando DELETE apagará todos os
registros da tabela. Neste caso, no MySQL 3.23, o comando retorna zero.
A partir do MySQL 4.0.0 a exclusão em multi-tabelas é suportada.
Vamos para um exemplo prático. Primeiro visualizaremos que dados temos em nossa
tabela filmes :
mysql> select * from filmes;
+----+---------------------------------+------+------------------+
| id | titulo
| ano | diretor
|
+----+---------------------------------+------+------------------+
| 1 | King Kong
| 2006 | Peter Jackson
|
| 2 | Guerra dos Mundos
| 2005 | Steven Spielberg |
| 3 | Harry Potter e o Cálise de Fogo | 2006 | Mike Newell
|
+----+---------------------------------+------+------------------+
3 rows in set (0.11 sec)
Como já haviamos visto em artigos anteriores o comando SELECT * FROM filmes
retorna todos os registros da tabela filmes.
Neste caso temos três registros de filmes. Para ilustrar a utilização mais comum do
comando DELETE vamos excluir um destes registros com o uso de algum critério.
Poderíamos ter um critério único, que excluiria apenas um registro (por exemplo usando
o campo id), ou um critério múltiplo, que poderia apagar mais de um registro (por
exemplo, neste caso, usando o campo ano).
Vamos optar por usar o campo ano e excluir todos os filmes de anos anteriores a '2006',
o comando seria o seguinte:
DELETE FROM filmes WHERE ano<2006;
mysql> DELETE FROM filmes WHERE ano<2006;
Query OK, 1 row affected (0.08 sec)
O comando DELETE foi executado com sucesso ("Query Ok") e afetou apenas uma
linha (registro) da tabela, ou seja, existia apenas um filme na tabela com data anterior a
'2006'.
Vamos ver como ficaram os registros:
mysql> select * from filmes;
+----+---------------------------------+------+------------------+
| id | titulo
| ano | diretor
|
+----+---------------------------------+------+------------------+
| 1 | King Kong
| 2006 | Peter Jackson
|
| 3 | Harry Potter e o Cálise de Fogo | 2006 | Mike Newell
|
+----+---------------------------------+------+------------------+
2 rows in set (0.00 sec)
Fica claro que agora só temos filmes do ano de '2006' na tabela.
Vamos agora apagar um registro com base em um campo string. Executaremos o
seguinte comando:
DELETE FROM filmes WHERE diretor LIKE '%Jackson'
mysql> DELETE FROM filmes WHERE diretor LIKE '%Jackson';
Query OK, 1 row affected (0.08 sec)
Neste caso o comando DELETE excluiria tudos os registros cujo campo diretor
terminasse com o sobrenome 'Jackson' (todos os campos que se parecessem com isto).
Novamente o comando retornou sucesso e avisou que uma linha foi afetada, ou seja,
tínhamos um registro que satisfazia a condição.
Vamos ver como ficaram os registros:
mysql> select * from filmes;
+----+---------------------------------+------+------------------+
| id | titulo
| ano | diretor
|
+----+---------------------------------+------+------------------+
| 3 | Harry Potter e o Cálise de Fogo | 2006 | Mike Newell
|
+----+---------------------------------+------+------------------+
1 rows in set (0.00 sec)
Uma situação especial para o comando DELETE ocorre quando ele é aplicado sem
nenhuma cláusula WHERE, neste caso todos os registros serão excluídos.
DELETE FROM filmes
mysql> DELETE FROM filmes;
Query OK, 1 row affected (0.00 sec)
Como só tínhamos um registro na tabela, somente uma linha foi afetada.
A tabela filmes agora se encontra vazia.
mysql> select * from filmes;
Empty set (0.00 sec)
Podemos facilmente restaurar os registros que existiam na tabela executando os três
últimos comandos.
mysql> INSERT INTO `filmes` VALUES (1, 'King Kong', 2006,
'> 'Peter Jackson');
Query OK, 1 row affected (0.02 sec)
mysql> INSERT INTO `filmes` VALUES (2, 'Guerra dos Mundos',
'> 2005, 'Steven Spielberg');
Query OK, 1 row affected (0.00 sec)
mysql> INSERT INTO `filmes` VALUES (3, 'Harry Potter e o
'>Cálise de Fogo', 2006,'Mike Newell');
Query OK, 1 row affected (0.00 sec)
A tabela filmes agora está como no começo deste artigo:
mysql> select * from filmes;
+----+---------------------------------+------+------------------+
| id | titulo
| ano | diretor
|
+----+---------------------------------+------+------------------+
| 1 | King Kong
| 2006 | Peter Jackson
|
| 2 | Guerra dos Mundos
| 2005 | Steven Spielberg |
| 3 | Harry Potter e o Cálise de Fogo | 2006 | Mike Newell
|
+----+---------------------------------+------+------------------+
3 rows in set (0.00 sec)
CONCLUSÃO
O comando SQL DELETE nos possibilita excluir, com enorme precisão, registros de
uma tabela MySQL. Esta precisão se deve ao fato de ele aceitas a cláusula WHERE e
todos os benefícios de filtragem de dados que ela possui. Sem o uso de WHERE, temos
um comando capaz de excluir de uma só vez todos os dados de uma tabela, algo que não
ocorre com freqüência, mas que pode ser útil em determinadas circunstâncias,
principalmente quando desejamos saber quantos registro foram apagados.
ATUALIZANDO DADOS
Primeiramente acesse o utilitário de linha de comando do MySQL, selecione a base de
dados Locadora e verifique a existência da tabela filmes.
mysql> use locadora;
Database changed
mysql> show tables;
+--------------------+
| Tables_in_locadora |
+--------------------+
| filmes
|
+--------------------+
1 row in set (0.05 sec)
O comando SQL que nos permite atualizar dados no MySQL é o comando UPDATE.
A sintaxe básica do comando UPDATE é a seguinte:
UPDATE nome_tabela SET nome_coluna1=expr1 [, nome_coluna2=expr2 ...]
[WHERE definição_where]
UPDATE é aplicado a uma tabela e a cláusula SET atribui a um campo o valor de uma
expressão que pode ou não conter o valor de um campo da própria tabela. A cláusula
WHERE restringe as atualizações apenas aos registro que satisfação suas condições.
A partir da MySQL Versão 4.0.4, você também pode realizar operações UPDATE que
cobrem múltiplas tabelas.
Vamos para um exemplo prático. Primeiro visualizaremos que dados temos em nossa
tabela filmes :
mysql> select * from filmes;
+----+---------------------------------+------+------------------+
| id | titulo
| ano | diretor
|
+----+---------------------------------+------+------------------+
| 1 | King Kong
| 2006 | Peter Jackson
|
| 2 | Guerra dos Mundos
| 2005 | Steven Spielberg |
| 3 | Harry Potter e o Cálise de Fogo | 2006 | Mike Newell
|
+----+---------------------------------+------+------------------+
3 rows in set (0.11 sec)
Como já vismos no artigo anterior o comando SELECT * FROM filmes retorna todos
os registros da tabela filmes.
Vamos supor que desejássemos mudar todos os filmes para o ano de '2006', o comando
UPDATE seria o seguinte:
UPDATE filmes SET ano=2006
mysql> UPDATE filmes SET ano=2006;
Query OK, 1 row affected (0.17 sec)
Linhas que combinaram: 3 - Alteradas: 1 - Avisos: 0
O resultado do comando UPDATE notifica que três linhas combinaram com o comando
(uma vez que temos três registros na tabela e não utilizamos a cláusula WHERE), e
destas três, uma foi alterada (atualizada). Vamos ver como ficaram os registros:
mysql> select * from filmes;
+----+---------------------------------+------+------------------+
| id | titulo
| ano | diretor
|
+----+---------------------------------+------+------------------+
| 1 | King Kong
| 2006 | Peter Jackson
|
| 2 | Guerra dos Mundos
| 2006 | Steven Spielberg |
| 3 | Harry Potter e o Cálise de Fogo | 2006 | Mike Newell
|
+----+---------------------------------+------+------------------+
3 rows in set (0.00 sec)
Perceba que todos os filmes agora tem o valor '2006' no campo 'ano'. Os filmes que já
tinham o valor '2006' para 'ano' foram ignorados pelo comando UPDATE.
Neste primeiro exemplo não utilizamos a cláusula WHERE, e o comando UPDATE
tentou mudar todo e qualquer registro para o ano de '2006', é claro que isto não é um
comportamento ideal para a maioria de nossa necessidades.
Vamos realizar uma atualização de um só registro desta vez. Para isto vamos restringir o
comando UPDADE com a cláusula WHERE.
mysql> UPDATE filmes SET ano=ano-1 WHERE id=2;
Query OK, 1 row affected (0.08 sec)
Linhas que combinaram: 1 - Alteradas: 1 - Avisos: 0
Neste exemplo a instrução ' WHERE id=2' restringe a atualização apenas ao registro
que possuir a chave primária 'id' com o valor '2', no caso o filme 'Guerra dos Mundos'.
Outro ponto importante neste exemplo é que utilizamos o próprio valor do campo 'ano'
para atualizá-lo. 'SET ano=ano-1' atualiza o valor de 'ano' para '2005', uma vez que
'ano' tinha o valor de '2006' (2006 - 1 = 2005).
A tabela filmes ficou com os seguintes dados:
mysql> select * from filmes;
+----+---------------------------------+------+------------------+
| id | titulo
| ano | diretor
|
+----+---------------------------------+------+------------------+
| 1 | King Kong
| 2006 | Peter Jackson
|
| 2 | Guerra dos Mundos
| 2005 | Steven Spielberg |
| 3 | Harry Potter e o Cálise de Fogo | 2006 | Mike Newell
|
+----+---------------------------------+------+------------------+
3 rows in set (0.00 sec)
Exatamente como começamos :)
CONCLUSÃO
O comando SQL UPDATE utilizado com a cláusula WHERE torna-se uma ferramenta
poderosa para desenvolvedores manipularem dados no MySQL. O fato de a cláusula
SET aceitar atribuição de valores de expressões possibilita que trabalhemos com o
valores já existentes no registro manipulado, o que também expande nosso controle
sobre os dados.
REALIZANDO CONSULTAS
mysql> use locadora;
Database changed
mysql> show tables;
+--------------------+
| Tables_in_locadora |
+--------------------+
| filmes
|
+--------------------+
1 row in set (0.05 sec)
O comando SQL que nos permite realizar consultas ao banco de dados é o comando
SELECT.
Como dissemos, o comando SELECT serve para realizar consultas ao banco de dados
(como um todo), e não somente a uma tabela. É por isto que a instrução abaixo funciona
apesar de não estarmos consultando nenhuma tabela.
mysql> select 4/2;
+--------+
| 4/2
|
+--------+
| 2.0000 |
+--------+
1 row in set (0.05 sec)
Nesta instrução estamos consultando o banco de dados sobre a divisão dos valores 4 por
2, e ele retornou o valor 2.0000, que é o resultado da divisão.
Depois de esclarecido isto, vamos ver a sintaxe básica do comando SELECT.
SELECT (colunas) FROM nome_tabela WHERE definição_where
Vamos para um exemplo prático em nossa tabela filmes.
mysql> select * from filmes;
+----+---------------------------------+------+------------------+
| id | titulo
| ano | diretor
|
+----+---------------------------------+------+------------------+
| 1 | King Kong
| 2006 | Peter Jackson
|
| 2 | Guerra dos Mundos
| 2005 | Steven Spielberg |
| 3 | Harry Potter e o Cálise de Fogo | 2006 | Mike Newell
|
+----+---------------------------------+------+------------------+
3 rows in set (0.11 sec)
A instrução SELECT * FROM nome_tabela já foi vista no artigo anterior, mas vamos
esclarecer melhor como funciona esta instrução.
O * (asterisco) substitui os nomes de todas colunas, e todas serão selecionadas para o
resultado da consulta. A instrução FROM indica de qual tabela estamos buscando
dados, no nosso exemplo a tabela filmes. Como a instrução WHERE (que funciona
como um filtro) não foi declarada, não temos nenhuma restrição aos dados pesquisados,
e a consulta retornará todo o conteúdo da tabela filmes.
Caso não fosse de nosso desejo mostrar todas as colunas no resultado da consulta,
bastaria nomear as colunas que deveriam aparecer no lugar do * (asterisco) e separadas
por vírgula.
Vamos agora realizar a mesma consulta só que com um filtro, uma restrição aos dados
que serão exibidos no resultado da consulta. Desta vez também selecionaremos apenas
as colunas id, titulo e ano para o resultado.
mysql> select id,titulo,ano from filmes where ano = 2006;
+----+---------------------------------+------+
| id | titulo
| ano |
+----+---------------------------------+------+
| 1 | King Kong
| 2006 |
| 3 | Harry Potter e o Cálise de Fogo | 2006 |
+----+---------------------------------+------+
2 rows in set (0.03 sec)
A instrução SELECT id,titulo,ano FROM filmes WHERE ano = 2006 possui os
principais pontos de uma consulta. Determinamos quais colunas (campos) deveriam
aparecer no resultado da consulta, e filtramos o resultado para aparecerem apenas os
registros cujo campo ano tenha o valor igual a 2006. Note que apenas os filmes de 2006
estão presentes no resultado da consulta.
O filtros da cláusula WHERE podem ser mais complexos e determinarem mais de uma
condição, como no exemplo a seguir.
mysql> select id,titulo,ano from filmes
-> where ano = 2006 and titulo = 'King Kong';
+----+-----------+------+
| id | titulo
| ano |
+----+-----------+------+
| 1 | King Kong | 2006 |
+----+-----------+------+
1 row in set (0.00 sec)
Neste caso selecionamos apenas os registros que possuem o ano igual a 2006 e o titulo
igual a King Kong. Neste caso a cláusula WHERE é auxiliada pelo AND que cria uma
interseção no resultado da consulta entre os registro que possuem o ano 2006 e o titulo
King Kong. Podemos também criar uma união entre os resultados com OR.
mysql> select id,titulo,ano from filmes
-> where ano = 2005 or titulo = 'King Kong';
+----+-------------------+------+
| id | titulo
| ano |
+----+-------------------+------+
| 1 | King Kong
| 2006 |
| 2 | Guerra dos Mundos | 2005 |
+----+-------------------+------+
2 rows in set (0.00 sec)
Aqui aparecem tanto o registro que possui o titulo King Kong como o registro do filme
de 2005, ou seja, uma união.
OPERADORES DE COMPARAÇÃO
A Cláusula WHERE também aceita como operadores de comparação além do =
(igual): < (menor), <= (menor ou igual), > (maior), >= (maior ou igual), <> (diferente).
Também temos as comparações especiais IS NULL e IS NOT NULL.
Vamos a um exemplo com o comparador <> (diferente).
mysql> select * from filmes
-> where ano <> 2006;
+----+-------------------+------+------------------+
| id | titulo
| ano | diretor
|
+----+-------------------+------+------------------+
| 2 | Guerra dos Mundos | 2005 | Steven Spielberg |
+----+-------------------+------+------------------+
1 row in set (0.11 sec)
O banco de dados selecionou todos os registro cujo ano seja diferente de 2006, em
nosso exemplo, apenas o filme Guerra dos Mundos.
Apesar de não termos nenhum valor nulo (null) em nossa tabela podemos fazer a
seguinte consulta com o operador IS NULL.
mysql> select * from filmes
-> where ano is null;
Empty set (0.01 sec)
Como não temos nenhum registro com o campo ano com valor nulo (null), a consulta
retorna vazío (empty).
APELIDOS
Uma outra funcionalidade interessante do comando SELECT é a possibilidade de
darmos um apelido as denominações dos campos ou até mesmo da tabela.
Se quisermos, por exemplo, que a tabela id apareça como codigo no resultado da
pesquisa podemos fazer assim:
mysql> select id as codigo,titulo,ano from filmes;
+--------+---------------------------------+------+
| codigo | titulo
| ano |
+--------+---------------------------------+------+
|
1 | King Kong
| 2006 |
|
2 | Guerra dos Mundos
| 2005 |
|
3 | Harry Potter e o Cálise de Fogo | 2006 |
+--------+---------------------------------+------+
3 rows in set (0.00 sec)
Perceba que o nome do campo id vem seguido da instrução as codigo, e no resultado da
consulta a palavra codigo aparece no cabeçalho da coluna id.
CONCLUSÃO
O comando sql SELECT é de fundamental importância para qualquer banco de dados,
e no MySQL não é diferente, ele constitui uma ferramenta poderosa para recuperarmos
dados importante e localizarmos apenas o que nos interessa no momento. O que vimos
aqui foram apenas os tipos de consultas mais básicas do comando SELECT, mas
suficientes para que possamos começar a explorar melhor todo o potencial do MySQL.