O MySQL é um sistema de gerenciamento de banco de dados relacional
multiencadeado, de código fonte aberto e nível corporativo.
Multiencadeado porque toda vez que alguém estabelece uma conexão
com o servidor, o programa servidor cria um processo para tratar as solicitações.
Foi desenvolvido por uma empresa de consultoria na Suécia, chamada
TcX, a qual estava precisando de um sistema de banco de dados que fosse
extremamente rápido e flexível. O MySQL é basicamente
baseado em outro sistema de gerenciamento de banco de dados; mais conhecido
como MSQL.
Tornou-se muito popular no mundo Web (provedores de serviço,
Universidades, dentre outras organizações), devido a rapidez
com que processa as informações. As organizações
sem fins lucrativos são os principais usuários, porque algumas
versões do MySQL para Linux são livres.
Começando com o MySQL
Os exemplos que serão mostrados ao longo do documento são
feitos na linha de comando do cliente mysql na plataforma Linux. Os comandos
utilizados também servem para o Windows.
Para chamar a interface de linha de comandos do mysql deverá
ser chamado o cliente mysql, chamado mysql. Inicie o cliente mysql
digitando o comando no prompt do shell, como no exemplo abaixo:
[dpaula@localhost dpaula]$
mysql -u dpaula -p
Enter password:
********
Welcome to the MySQL
monitor. Commands end with ; or \g.
Your MySQL connection
id is 5 to server version: 3.22.32
Type 'help' for help.
mysql>
Os argumentos -u e -p referem-se ao usuário, no
caso dpaula, e a senha, respectivamente; a qual será solicitada,
conforme o exemplo acima.
Agora, você já está conectado ao servidor do banco
de dados. Um prompt vazio fica esperando os comandos para manipular os
dados.
Verificando que bancos de dados existem nesse servidor:
mysql> show databases;
+-----------+s
| Database |
+-----------+
| dpaula_db |
| mysql
|
| test
|
+-----------+
3 rows in set (0.00
sec)
mysql>
A resposta retornada pelo MySQL informa que há três BD,
chamados dpaula_db, mysql e test, respectivamente; retornando também
o número de linhas de retorno (3) e o tempo que o servidor precisou
para executar a consulta (0.00 segundos para dois ptos. decimais).
O banco de dados mysql (padrão) armazena todas as permissões
para todos os bancos de dados do MySQL. Algumas tabelas que compõem
o BD mysql:
-
user - armazena todos os nomes, senhas, hosts e privilégios de todos
os usuários;
-
db - contém todos os usuários, bancos de dados e nomes do
host;
-
host - contém todos os nomes do host, bancos de dados e privilégios;
Para que uma pessoa possa usufruir o MySQL, será necessário
inserir algumas informações nestas tabelas.
Se você possuir privilégios de root, poderá ver
as informações e estruturas do mysql. Veja o exemplo:
show databases - verifica os
bancos de dados existentes;
[dpaula@localhost dpaula]$
mysql -u root -p
Enter password: *********
Welcome to the MySQL
monitor. Commands end with ; or \g.
Your MySQL connection
id is 6 to server version: 3.22.32
Type 'help' for help.
mysql> show databases;
+-----------+
| Database |
+-----------+
| dpaula_db |
| mysql
|
| test
|
+-----------+
3 rows in set (0.00
sec)
mysql>
use <banco de dados> - diz
para o monitor mysql qual banco será utilizado; no exemplo, o banco
de dados mysql;
mysql> use mysql;
Reading table information
for completion of table and column names
You can turn off this
feature to get a quicker startup with -A
Database changed
mysql>
show tables - mostra as tabelas
de um banco de dados;
mysql> show tables;
+-----------------+
| Tables in mysql |
+-----------------+
| columns_priv
|
| db
|
| func
|
| host
|
| tables_priv
|
| user
|
+-----------------+
6 rows in set (0.00
sec)
mysql>
desc user - descreve a estrutura
da tabela user;
mysql> desc user;
+-----------------+---------------+------+-----+---------+-------+
| Field
| Type | Null | Key
| Default | Extra |
+-----------------+---------------+------+-----+---------+-------+
| Host
| char(60) |
| PRI | |
|
| User
| char(16) |
| PRI | |
|
| Password
| char(16) |
| |
| |
| Select_priv
| enum('N','Y') | |
| N |
|
| Insert_priv
| enum('N','Y') | |
| N |
|
| Update_priv
| enum('N','Y') | |
| N |
|
| Delete_priv
| enum('N','Y') | |
| N |
|
| Create_priv
| enum('N','Y') | |
| N |
|
| Drop_priv
| enum('N','Y') | |
| N |
|
| Reload_priv
| enum('N','Y') | |
| N |
|
| Shutdown_priv
| enum('N','Y') | |
| N |
|
| Process_priv
| enum('N','Y') | |
| N |
|
| File_priv
| enum('N','Y') | |
| N |
|
| Grant_priv
| enum('N','Y') | |
| N |
|
| References_priv |
enum('N','Y') | |
| N |
|
| Index_priv
| enum('N','Y') | |
| N |
|
| Alter_priv
| enum('N','Y') | |
| N |
|
+-----------------+---------------+------+-----+---------+-------+
17 rows in set (0.00
sec)
mysql>
Não esqueça que os comandos são finalizados com
o sinal de pontuação ponto-e-vírgula (;).
Manipulando estruturas e dados no MySQL
Para criar objetos e manipular informações será
necessário utilizar uma linguagem. O MySQL utiliza o SQL (Structured
Query Language) para tal finalidade. A SQL foi desenvolvida pela IBM
na década de 70, cujos fins eram manipular dados em um banco de
dados relacional. O intuito era criar uma linguagem de fácil utilização
que se assemelhasse ao inglês em sua sintaxe. O sucesso do SQL foi
quando a Oracle baseou o acesso de banco de dados nessa linguagem.
Lista de algumas palavras reservadas do vocabulário SQL:
create |
drop |
alter |
delete |
insert |
update |
select |
set |
from |
into |
on |
where |
order by |
group by |
join |
left join |
cross join |
full join |
right join |
and |
limit |
or |
like |
as |
Criando um banco de dados (create
database <nome>)
mysql> create database
exemplo;
Query OK, 1 row affected
(0.00 sec)
mysql> show databases;
+-----------+
| Database |
+-----------+
| dpaula_db |
| exemplo
|
| mysql
|
| test
|
+-----------+
4 rows in set (0.01
sec)
mysql>
Deletando um banco de dados (drop
database <nome>)
mysql> drop database exemplo;
Query OK, 0 rows affected (0.00 sec)
mysql> show databases;
+-----------+
| Database |
+-----------+
| dpaula_db |
| mysql
|
| test
|
+-----------+
3 rows in set (0.00
sec)
mysql>
Criando tabelas (create table <nome
tabela>)
mysql> show databases;
+-----------+
| Database |
+-----------+
| dpaula_db |
| mysql
|
| test
|
+-----------+
3 rows in set (0.01
sec)
mysql> use dpaula_db;
Database changed
mysql> show tables;
Empty set (0.00 sec)
mysql> create table usuario(u_id
int not null primary key auto_increment,
->
nome varchar(20) not null,
->
sobrenome varchar(30) not null,
->
endereco varchar(50),
->
cidade varchar(20),
->
estado varchar(2),
->
cep varchar(20),
->
email varchar(20),
->
idade int,
->
sexo enum('M','F') default 'F'
->
);
Query OK, 0 rows affected
(0.02 sec)
mysql> show tables;
+---------------------+
| Tables in dpaula_db
|
+---------------------+
| usuario
|
+---------------------+
1 row in set (0.00 sec)
mysql> desc usuario;
+-----------+---------------+------+-----+---------+----------------+
| Field
| Type | Null | Key
| Default | Extra
|
+-----------+---------------+------+-----+---------+----------------+
| u_id
| int(11) |
| PRI | 0 | auto_increment |
|
nome
| varchar(20) |
|
|
|
|
| sobrenome | varchar(30)
| | |
|
|
| endereco |
varchar(50)
| YES | | NULL
|
|
| cidade
| varchar(20) | YES | | NULL
|
|
| estado
| char(2) | YES |
| NULL |
|
| cep
| varchar(20) | YES | | NULL
|
|
| email
| varchar(20) | YES | | NULL
|
|
| idade
| int(11) | YES |
| NULL |
|
| sexo
| enum('M','F') | YES | | F
|
|
+-----------+---------------+------+-----+---------+----------------+
10 rows in set (0.01
sec)
mysql>
Excluindo tabelas (drop table <nome
tabela>)
mysql> show tables;
+---------------------+
| Tables in dpaula_db
|
+---------------------+
| usuario
|
+---------------------+
1 row in set (0.01 sec)
mysql> drop table usuario;
Query OK, 0 rows affected
(0.01 sec)
mysql> show tables;
Empty set (0.00 sec)
mysql>
Adicionando novas linhas de dados (insert)
Sintaxe
insert into <nome
da tabela> (col_x, col_y,...,col_n) values (val_x, val_y,...,val_n)
mysql> insert into usuario
values (NULL,'João','Mendes','Rua Cacique de Ramos, 317','Florianópolis',
'SC','88034-060','jm@infonoticias.com.br','25','M');
Query OK, 1 row affected
(0.01 sec)
mysql>
Os valores inseridos no caso acima, precisam obedecer à ordem
de coluna, senão um erro pode ocorrer. Para evitar este problema
pode-se utilizar o comando insert desta outra maneira:
mysql> insert into usuario
(u_id,nome,sobrenome,email) values (NULL,'João','Mendes','jm@infonoticias.com.br');
Query OK, 1 row affected
(0.01 sec)
mysql> insert into usuario
(u_id,nome,sobrenome,email) values (NULL,'Alice','Ribeiro','alice@infonoticias.com.br');
Query OK, 1 row affected
(0.00 sec)
mysql>
Desta maneira, nem a ordem e nem o número de colunas da tabela
precisam corresponder. Note também que neste caso, você poderá
escolher quais informações serão inseridas.
Retornando informações que estão contidas nas tabelas
(select)
Para se buscar informações que estejam armazenadas no
banco de dados, utiliza-se o comando select da seguinte maneira:
Sintaxe
select <nome da coluna>
from <nome da tabela> where <condição>
Buscando o endereço de email do usuario João:
mysql> select email from
usuario where nome='João';
+----------------------+
| email
|
+----------------------+
| jm@infonoticias.com.
|
+----------------------+
1 row in set (0.01 sec)
mysql>
Buscando o endereço de email e o sobrenome do usuario João:
mysql> select email,sobrenome
from usuario where nome='João';
+----------------------+-----------+
| email
| sobrenome |
+----------------------+-----------+
| jm@infonoticias.com.
| Mendes |
+----------------------+-----------+
1 row in set (0.02 sec)
mysql>
Percebe-se que para busar mais de uma coluna, devemos especificar o
nome de cada uma delas, separando-as com o caracter vírgula (,).
Pode-se ainda utilizar o caracter curinga (*) para representar
todas as colunas. Desta maneira serão retornadas todas as informações
referentes ao usuário 'João'.
mysql> select * from
usuario where nome='João';
+------+------+-----------+----------+--------+--------+------+----------------------+-------+------+
| u_id | nome |
sobrenome
| endereco | cidade | estado | cep |
email
| idade | sexo |
+------+------+-----------+----------+--------+--------+------+----------------------+-------+------+
|
1 | João | Mendes | NULL
| NULL | NULL | NULL | jm@infonoticias.com. |
NULL | F |
+------+------+-----------+----------+--------+--------+------+----------------------+-------+------+
1 row in set (0.00 sec)
mysql>
Omitindo-se a palavra reservada where teremos na saída, todos
os usuários armazenados nesta tabela. Veja o exemplo:
mysql> select * from
usuario;
+------+-------+-----------+----------+--------+--------+------+----------------------+-------+------+
| u_id |
nome
| sobrenome | endereco | cidade | estado | cep |
email
| idade | sexo |
+------+-------+-----------+----------+--------+--------+------+----------------------+-------+------+
|
1 | João | Mendes | NULL
| NULL | NULL | NULL | jm@infonoticias.com. |
NULL | F |
|
2 | Alice | Ribeiro | NULL | NULL
| NULL | NULL | alice@infonoticias.c | NULL | F
|
+------+-------+-----------+----------+--------+--------+------+----------------------+-------+------+
2 rows in set (0.02
sec)
mysql>
Excluindo registros (delete)
Sintaxe
delete from <nome
da tabela> where <condição>
A opção de deleção deve ser utilizada com
bastante cuidado, visto que, se a mesma for mal utilizada, pode-se perdar
muitas ou até mesmo todas informações contidas na
tabela em questão. Vamos deletar o usuário 'João'.
mysql> delete from usuario
where nome='João';
Query OK, 1 row affected
(0.00 sec)
mysql>
O exemplo abaixo exclui tudo na tabela usuario.
mysql> select * from
usuario;
+------+-------+-----------+----------+--------+--------+------+----------------------+-------+------+
| u_id |
nome
| sobrenome | endereco | cidade | estado | cep |
email
| idade | sexo |
+------+-------+-----------+----------+--------+--------+------+----------------------+-------+------+
|
1 | João | Mendes | NULL
| NULL | NULL | NULL | jm@infonoticias.com. |
NULL | F |
|
2 | Alice | Ribeiro | NULL | NULL
| NULL | NULL | alice@infonoticias.c | NULL | F
|
+------+-------+-----------+----------+--------+--------+------+----------------------+-------+------+
2 rows in set (0.02
sec)
mysql> delete from usuario;
Query OK, 0 rows affected
(0.02 sec)
mysql> select * from
usuario;
Empty set (0.00 sec)
mysql>
Editando os valores existentes (update)
Sintaxe
update <nome da tabela>
set <nome da coluna> = <valor> where <condição>
Este comando é muito parecido com select, mas os valores que
estão sendo selecionados, podem ser manipulados, ou seja, alterados.
Veja o exemplo:
mysql> select * from
usuario;
+------+------+-----------+---------------------------+---------------+--------+-----------+----------------------+-------+------+
| u_id | nome | sobrenome
| endereco
| cidade | estado | cep
| email
| idade | sexo |
+------+------+-----------+---------------------------+---------------+--------+-----------+----------------------+-------+------+
|
1 | João | Mendes | Rua Cacique de Ramos, 317
| Florianópolis | SC | 88034-060 | jm@infonoticias.com.
| 25 | M |
+------+------+-----------+---------------------------+---------------+--------+-----------+----------------------+-------+------+
1 row in set (0.01 sec)
mysql>
Vamos alterar a idade de João:
mysql> update usuario
set idade=33 where nome='João';
Query OK, 1 row affected
(0.00 sec)
Rows matched: 1
Changed: 1 Warnings: 0
mysql> select * from
usuario;
+------+------+-----------+---------------------------+---------------+--------+-----------+----------------------+-------+------+
| u_id | nome | sobrenome
| endereco
| cidade | estado | cep
| email
| idade | sexo |
+------+------+-----------+---------------------------+---------------+--------+-----------+----------------------+-------+------+
|
1 | João | Mendes | Rua Cacique de Ramos, 317
| Florianópolis | SC | 88034-060 | jm@infonoticias.com.
| 33 | M |
+------+------+-----------+---------------------------+---------------+--------+-----------+----------------------+-------+------+
1 row in set (0.00 sec)
mysql>
Tipos de dados no MySQL
Tipos Numéricos
Nome do tipo |
Espaço de memória |
TINYINT |
1 byte |
SMALLINT |
2 bytes |
MEDIUMINT |
3 bytes |
INT |
4 bytes |
INTEGER |
4 bytes |
BIGINT |
8 bytes |
FLOAT(X) |
4 if X <= 24 or 8 if 25 <= X <= 53 |
FLOAT |
4 bytes |
DOUBLE |
8 bytes |
DOUBLE PRECISION |
8 bytes |
REAL |
8 bytes |
DECIMAL(M,D) |
M+2 bytes if D > 0, M+1 bytes if D = 0 (D+2,
if M < D) |
NUMERIC(M,D) |
M+2 bytes if D > 0, M+1 bytes if D = 0 (D+2,
if M < D) |
Tipos de string
Nome do tipo |
Espaço de memória |
CHAR(M) |
M bytes, 1 <= M <= 255 |
VARCHAR(M) |
L+1 bytes, where L <= M and
1 <= M <=
255 |
TINYBLOB, TINYTEXT |
L+1 bytes, where L < 2^8 |
BLOB, TEXT |
L+2 bytes, where L < 2^16 |
MEDIUMBLOB, MEDIUMTEXT |
L+3 bytes, where L < 2^24 |
LONGBLOB, LONGTEXT |
L+4 bytes, where L < 2^32 |
ENUM('value1','value2',...) |
1 or 2 bytes, depending on the number of enumeration values (65535
values maximum) |
SET('value1','value2',...) |
1, 2, 3, 4 or 8 bytes, depending on the number of set members (64 members
maximum) |
Modificadores adicionais de coluna
Nome do modificador |
Tipos aplicáveis |
auto_increment |
Todos os tipos INT |
binary |
char, varchar |
default |
todos, exceto blob, text |
not null |
todos os tipos |
null |
todos os tipos |
primary key |
todos os tipos |
unique |
todos os tipos |
unsigned |
tipos numéricos |
zerofill |
tipos numéricos |
|