Mysql

CONCEITOS BÁSICOS DE MYSQL
Trabalhando com linha de comandos

Podemos manipular o banco de dados MySQL de diversas formas, entre
elas com o utilitário de linha de comando mysql, que se encontra no
diretório /bin da instalação do banco de dados. Outras formas seriam através
de IDEs ou MySQL Management (Gerenciadores do MySQL). Recomendamos o
uso junto ao PHP do phpMyAdmin como MySQL Management.
Para manipular o mysql através do prompt de comando acesse o

diretório mysql/bin e execute mysql
Ex: /mysql/bin/mysql -u root –p ou

Ex: /mysql/bin/mysql --user=root
Será solicitada a senha e depois o console do mysql será exibido.
Welcome to the MySQL monitor. Commands end with ; or \g.

Your MySQL connection id is 70 to server version: 4.0.20a-nt-max
Type 'help;' or '\h' for help. Type '\c' to clear the buffer.
mysql>
Após logado o usuário poderá buscar ajuda com os comandos digitando

a palavra help na linha de comando.
COMANDOS BÁSICOS
Atenção: Para muitos comandos do mysql é necessário enviar o

comando ao servidor, mesmo após teclar enter o prompt ficará
aguardando o comando “go” para enviar ao servidor.
A sintaxe é: comando /g
CRIAÇÃO DE BASES DE DADOS
O primeiro passo é criar uma base de dados. A síntese do MySQL para

criação de base de dados é a seguinte: CREATE DATABASE [IF NOT EXISTS]
nome_bd.
O parâmetro opcional [IF NOT EXISTS] permite que executemos o

comando de criação da base de dados sem termos a certeza de que a mesma
já não existe. Caso a base de dados já exista, o comando é ignorado.
O nome da nova base de dados será determinado pelo parâmetro

nome_db e deve seguir as regras de permissão de nomes do MySQL conforme
tabela abaixo:
Tam. máx.
Identificador Caracteres permitidos
(bytes)
Qualquer caractere que é permitido em um
Banco de dados 64
nome de diretório exceto ‘ / ' ou ‘ . '.
Qualquer caractere permitido em um nome
Tabela 64
de arquivo, exceto ‘ / ' ou ‘ . '.
Coluna 64 Todos os caracteres.
Alias 255 Todos os caracteres.
Note que em adição ao mostrado acima, você não pode ter ASCII(0) ou
ASCII(255) ou o caractere de citação (aspas) em um identificador. Por outro
lado os identificadores podem ter nomes de palavras reservadas, neste caso
temos que nos referenciar a eles com o do caractere ‘.
Tomaremos como exemplo a criação de uma base de dados com nome

de noticias.
Exemplo de criação de uma nova base de dados:

mysql> create database if not exists noticias;
Query OK, 1 row affected (0.03 sec)
mysql>
O nome de uma base de dados no MySQL representa um diretório dentro

do diretório de dados do MySQL.
Logo a base de dados que acabamos de criar ficará localizada em algo

como: /mysql/data/noticias.
EXPLORANDO AS BASES DE DADOS EXISTENTES NO SERVIDOR
O comando SHOW DATABASES nos mostra todas as bases de dados

existentes no servidor e sob domínio do usuário logado.
mysql> show databases;

+-------------------+
| Database |
+-------------------+
| locadora |
| test |
+-------------------+
2 rows in set (0.00 sec)
mysql>
TRABALHANDO COM UMA BASE 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 noticias;
Database changed
mysql>
A partir de agora todos os comandos executados afetará a base de

dados locadora.
CRIAÇÃO DE TABELAS NA BASE SELECIONADA
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 existência ou não da
tabela.
Para criarmos uma tabela bastaria 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 filmes com os seguintes
campos:
id - campo de identificação;
titulo - titulo do filme;
ano - Ano de produção;
diretor - diretor do filmes;
Para isto devemos executar o seguinte comando:
mysql> create table filmes (

-> id int(10) unsigned not null auto_increment,
-> titulo varchar(80) not null,
-> ano int(4) unsigned not null,
-> diretor varchar(80) 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.
A última definição primary key (id) define qual campo será utilizado para
realizar a identificação do registro.
Primary key Uma primary key (chave primária) é um campo de

identificação única do registro. Um campo definido como primary key não pode
ter um falor nulo ou duplicado.
Após a execução do comando temos uma nova tabela gerada. Podemos

verificar quais tabelas existem em nosso banco de dados com o comando
SHOW TABLES.
mysql> show tables;

+--------------------+
| Tables_in_locadora |
+--------------------+
| filmes |
+--------------------+
1 row in set (0.00 sec)
mysql>
O resultado é que na base de dados LOCADORA existe apenas uma

tabela, a FILMES.
SHOW TABLES Exibe os nomes das tabelas que fazem parte de uma
base de dados.
Podemos, ainda, verificar a estrutura da tabela com o comando DESC.
mysql> desc filmes;

+---------+------------------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+---------+------------------+------+-----+---------+----------------+
| id | int(10) unsigned | | PRI | NULL | auto_increment |
| titulo | varchar(80) | | | | |
| ano | int(4) unsigned | | | 0 | |
| diretor | varchar(80) | | | | |
+---------+------------------+------+-----+---------+----------------+
mysql>
Com o retorno do comando DESC podemos ver quais os campos da

tabela, qual o tipo dos campos, se aceitam ou não valores nulos, se existe uma
chave primaria, e se algum campo possui a propriedade auto_increment.
DESC Descreve a estrutura de uma tabela.
Neste artigo pudemos observar como podemos criar uma base de dados,
trabalhar com esta base de dados, criar uma tabela, consultar a existência de
tabelas na base de dados, e visualizar a descrição da estrutura de uma tabela.
Uma outra forma de visualizar a estrutura de uma tabela é utilizar o

comando SHOW FIELDS da seguinte forma:
show fields from nomedatabela
SAINDO DO MYSQL
Para finalizar uma conexão com o gerenciador de banco de dados do

mysql, basta digitar o comando: quit
INSERSÃO DE DADOS (COMANDO INSERT)
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;
+--------------------+
+--------------------+
| filmes |
+--------------------+
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 filmes (id,titulo,ano,diretor)

-> values (0,'King Kong',2006,'Peter Jackson');
Com este comando inserimos os dados do filme King Kong, do ano de

2006, do diretor Peter Jackson. Mas e o valor 0 da coluna id?
Quando criamos a tabela filmes definimos a coluna id como tendo a

característica 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 seqüê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).
Poderíamos também inserir dados omitindo os nomes das colunas e

colocando apenas os valores no comando, desde que os valores estejam na
mesma seqüência das colunas na tabela.
mysql> insert into filmes values

-> (null,'Guerra dos Mundos',2005,'Steven Spielberg');
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.
ALGUNS ERROS COMUNS AO INSERIR DADOS
ESQUECER DE COLOCAR UM VALOR DO TIPO TEXTO ENTRE ASPAS
mysql> insert into filmes (titulo,ano,diretor) values

-> ('Harry Potter e o Cálise de Fogo',2006,Mike Newell);
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 diretor, o banco de

dados não aceitou a entrada e gerou o erro 1064 e avisou que temos um erro
de síntaxe na instrução SQL próximo de (‘Newell)', ou seja, próximo ao nome
do diretor.
ATRIBUIR UM VALOR REPETIDO A UMA CHAVE PRIMÁRIA OU A UM

CAMPO ÚNICO
Na nossa tabela de exemplo não temos campos únicos, mas temos uma
chave primária, e por acidente tentemos atribuir um valor duplicado a esta
chave.
mysql> insert into filmes (id,titulo,ano,diretor) values

-> (2,'Harry Potter e o Cálise de Fogo',2006,'Mike Newell');
ERROR 1062 (23000): Entrada '2' duplicada para a chave 1
mysql>
Nesta situação tentamos inserir um registro com a chave primária 2,

mas em nossa tabela já tínhamos um registro com esta mesma chave primária,
como os campos de chave primária não aceitam valores duplicados o banco de
dados gerou um erro 1062 e avisou que a entrada 2 é duplicada para a
primeira chave primária (primeira e única no nosso exemplo) da tabela filmes.
FINALMENTE INSERIMOS O FILME HARRY POTTER
Depois de todos estes erros vamos a síntese correta novamente.
mysql> insert into filmes (id,titulo,ano,diretor) values

-> (0,'Harry Potter e o Cálise de Fogo',2006,'Mike Newell');
CONSULTA DE DADOS (COMANDO SELECT)


Database changed
mysql> show tables;
+--------------------+
+--------------------+
| filmes |
+--------------------+
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 |
+--------+
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 |
+----+---------------------------------+------+------------------+
O * (asterisco) na instrução SELECT 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 |
+----+---------------------------------+------+
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';
+----+-----------+------+
+----+-----------+------+
| 1 | King Kong | 2006 |
+----+-----------+------+
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';
+----+-------------------+------+
+----+-------------------+------+
| 1 | King Kong | 2006 |
| 2 | Guerra dos Mundos | 2005 |
+----+-------------------+------+
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;
+----+-------------------+------+------------------+
+----+-------------------+------+------------------+
+----+-------------------+------+------------------+
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 |
+--------+---------------------------------+------+
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.
ATUALIZAÇÃO DE DADOS (COMANDO UPDATE)


Database changed
mysql> show tables;
+--------------------+
+--------------------+
| filmes |
+--------------------+
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
registros que satisfaça 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 :

+----+---------------------------------+------+------------------+
+----+---------------------------------+------+------------------+
+----+---------------------------------+------+------------------+
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;

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:

+----+---------------------------------+------+------------------+
+----+---------------------------------+------+------------------+
+----+---------------------------------+------+------------------+
Perceba que todos os filmes agora têm 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 nossas
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;

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:

+----+---------------------------------+------+------------------+
+----+---------------------------------+------+------------------+
+----+---------------------------------+------+------------------+
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 valores já existentes no registro manipulado, o que
também expande nosso controle sobre os dados.
EXCLUSÃO DE REGISTROS (COMANDO DELETE)


Database changed
mysql> show tables;
+--------------------+
+--------------------+
| filmes |
+--------------------+
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 registros 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 :

+----+---------------------------------+------+------------------+
+----+---------------------------------+------+------------------+
+----+---------------------------------+------+------------------+
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;

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:

+----+---------------------------------+------+------------------+
+----+---------------------------------+------+------------------+
+----+---------------------------------+------+------------------+
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';

Neste caso o comando DELETE excluiria todos 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:

+----+---------------------------------+------+------------------+
+----+---------------------------------+------+------------------+
+----+---------------------------------+------+------------------+
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;

Como só tínhamos um registro na tabela, somente uma linha foi afetada.
A tabela filmes agora se encontra vazia.

Empty set (0.00 sec)
Podemos facilmente restaurar os registros que existiam na tabela

executando os três últimos comandos do anexo I.
mysql> INSERT INTO `filmes` VALUES (1, 'King Kong', 2006,

'> 'Peter Jackson');
mysql> INSERT INTO `filmes` VALUES (2, 'Guerra dos Mundos',
'> 2005, 'Steven Spielberg');
mysql> INSERT INTO `filmes` VALUES (3, 'Harry Potter e o
'>Cálise de Fogo', 2006,'Mike Newell');
A tabela filmes agora está como no começo:

+----+---------------------------------+------+------------------+
+----+---------------------------------+------+------------------+
+----+---------------------------------+------+------------------+
ANEXO I - Nossa base de dados
--
-- Estrutura da tabela `filmes`
--
DROP TABLE IF EXISTS `filmes`;

CREATE TABLE `filmes` (
ìd` int(10) unsigned NOT NULL,
`titulo` varchar(80) NOT NULL,
àno` int(4) unsigned NOT NULL,
`diretor` varchar(80) NOT NULL,
PRIMARY KEY (ìd`)
) TYPE=MyISAM AUTO_INCREMENT=4 ;
--
-- Dados da tabela `filmes`
--
INSERT INTO `filmes` VALUES (1, 'King Kong', 2006, 'Peter Jackson');
INSERT INTO `filmes` VALUES (2, 'Guerra dos Mundos', 2005, 'Steven Spielberg');
INSERT INTO `filmes` VALUES (3, 'Harry Potter e o C lise de Fogo', 2006, 'Mike Newell');

Mysql

Diunggah oleh

Informasi Dokumen

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Mysql

Diunggah oleh

Hak Cipta:

Format Tersedia

CONCEITOS BÁSICOS DE MYSQL

Trabalhando com linha de comandos

Para manipular o mysql através do prompt de comando acesse o

Ex: /mysql/bin/mysql -u root –p ou

Será solicitada a senha e depois o console do mysql será exibido.

Welcome to the MySQL monitor. Commands end with ; or \g.

Após logado o usuário poderá buscar ajuda com os comandos digitando

Atenção: Para muitos comandos do mysql é necessário enviar o

CRIAÇÃO DE BASES DE DADOS

O primeiro passo é criar uma base de dados. A síntese do MySQL para

O parâmetro opcional [IF NOT EXISTS] permite que executemos o

O nome da nova base de dados será determinado pelo parâmetro

Tomaremos como exemplo a criação de uma base de dados com nome

Exemplo de criação de uma nova base de dados:

O nome de uma base de dados no MySQL representa um diretório dentro

Logo a base de dados que acabamos de criar ficará localizada em algo

EXPLORANDO AS BASES DE DADOS EXISTENTES NO SERVIDOR

O comando SHOW DATABASES nos mostra todas as bases de dados

mysql> show databases;

TRABALHANDO COM UMA BASE DE DADOS

Para podermos começar a trabalhar com nossa base de dados devemos

A partir de agora todos os comandos executados afetará a base de

CRIAÇÃO DE TABELAS NA BASE SELECIONADA

A síntese de criação de tabelas do MySQL é a seguinte:

CREATE [TEMPORARY] TABLE [IF NOT EXISTS] nome_tabela

Novamente podemos nos valer do parâmetro opcional IF NOT EXISTS

Para criarmos uma tabela bastaria executar a seguinte parte da síntese:

Mas é mais comum criarmos a tabela já acompanhada de seus campos

Para isto devemos executar o seguinte comando:

mysql> create table filmes (

Os campos são definidos da seguinte forma:

nome_campo tipo [ NULL | NOT NULL ] [ DEFAULT valor_padrão]

No campo id por exemplo o tipo é int(10) com o modificador unsigned,

No campo titulo escolhemos o tipo varchar(80) o que significa que este

Primary key Uma primary key (chave primária) é um campo de

Após a execução do comando temos uma nova tabela gerada. Podemos

mysql> show tables;

O resultado é que na base de dados LOCADORA existe apenas uma

Podemos, ainda, verificar a estrutura da tabela com o comando DESC.

mysql> desc filmes;

Com o retorno do comando DESC podemos ver quais os campos da

Uma outra forma de visualizar a estrutura de uma tabela é utilizar o

show fields from nomedatabela

Para finalizar uma conexão com o gerenciador de banco de dados do

INSERSÃO DE DADOS (COMANDO INSERT)

Primeiramente acesse o utilitário de linha de comando do MySQL,

mysql> use locadora;

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 filmes (id,titulo,ano,diretor)

Com este comando inserimos os dados do filme King Kong, do ano de

Quando criamos a tabela filmes definimos a coluna id como tendo a

Interessante ressaltar que valores do tipo texto (string) são colocados

Poderíamos também inserir dados omitindo os nomes das colunas e

mysql> insert into filmes values

ALGUNS ERROS COMUNS AO INSERIR DADOS

ESQUECER DE COLOCAR UM VALOR DO TIPO TEXTO ENTRE ASPAS

mysql> insert into filmes (titulo,ano,diretor) values

Aqui esquecemos de colocar aspas no nome do diretor, o banco de

ATRIBUIR UM VALOR REPETIDO A UMA CHAVE PRIMÁRIA OU A UM

mysql> insert into filmes (id,titulo,ano,diretor) values

Nesta situação tentamos inserir um registro com a chave primária 2,

Depois de todos estes erros vamos a síntese correta novamente.