View
215
Download
0
Category
Preview:
Citation preview
Gerenciando banco de dados com MySQL
1. Introdução
Sistema de banco de Dados
Um sistema de banco de dados é um ambiente de hardware e de software, composto por dados armazenados em um banco de dados (BD), o software de gerência do banco de dados (SGBD) e os programas de aplicação.
Banco de Dados
São conjuntos de dados (versáteis, compartilháveis e integrados) armazenados em computador.
Características dos SGBDs
Os SGBDs não são caracterizados tão-somente pelos seus modelos de banco de dados, um SGBD também é caracterizado por suas funções, que implementam um conjunto básico de facilidades e serviços que definem a capacidade de banco de dados que um sistema deve possuir para ser considerado um banco de dados. Um SGBD deve também prover mecanismos de segurança de acesso para consulta ou atualização dos objetos persistentes. Em geral, estes mecanismos são implementados por meio de comandos de concessão/revogação de privilégios de acesso a usuários individuais ou grupos de usuários. Dependendo da aplicação, o nível de segurança pode ser de coleções de dados (tabelas e registros ou linhas), atributos isolados (campos ou colunas) e até mesmo de conteúdo (valores de dados).
Um banco de dados deve estar sempre num estado consistente, satisfazendo permanentemente algumas condições de consistência, chamado restrições de integridade. O SGBD tem a incumbência de garantir a integridade do banco de dados na passagem de um estado para outro, que ocorre ao final de cada transação.
Classes de usuários
Um sistema de banco de dados faz parte de um sistema mais amplo, conhecido como sistema de informação, cujos componentes, além da tecnologia, são a organização ou empresa e os recursos humanos.
Os componentes humanos podem ser classificados em três grandes classes de usuários do banco de dados:
Administradores;
Desenvolvedores;
Usuários Finais.
2. A Linguagem SQL e seus componentes
DDL (Data Definition Language)
A SQL DDL fornece comandos para definição e modificação de esquemas de relação, remoção de relações e criação de índices. Os principais comandos que fazem parte da DDL são:
CREATE;
ALTER;
DROP.
DML (Data Manipulation Language)
A SQL DML inclui uma linguagem de consulta baseada na álgebra relacional e no cálculo relacional. Compreende também comandos para inserir, remover e modificar informações em um banco de dados. Os comandos básicos da DML são:
SELECT;
INSERT;
UPDATE;
DELETE.
Sintaxe de um comando SQL
Um comando SQL é composto de cláusulas, algumas opcionais e outras obrigatórias. Para maior inteligibilidade, é conveniente iniciar uma cláusula em uma nova linha, mas isso não é obrigatório. As palavras que compõem um comando devem ser separadas por espaços ou tabs e o comando para ser executado deve terminar com ";" (ponto e vírgula).
Por exemplo:
SELECT * FROM ALUNOS;
Sobre o MySQL
O banco de dados MySQL é um sério competidor para os maiores sistemas de banco de dados existentes para aplicações de pequeno e médio porte. Uma das grandes vantagens do MySQL é suportar mais de uma dúzia de tipos de dados.
Desta forma, o MySQL é altamente recomendado para aqueles que irão desenvolver aplicações de pequeno e médio porte e querem bons resultados a um custo reduzido.
Utilizando o MySQL
Para utilizarmos o MySQL, devemos digitar o comando mysql -p, em seguida será solicitado a senha e após pressionar o Enter, se esta estiver correta, você irá ver o prompt do MySQL, desta forma:
# mysql -p
Enter password:
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 3 to server version: 4.0.11a-gamma
Type 'help;' or '\h' for help. Type '\c' to clear the buffer.
mysql>
OBS: Se você desejar encerrar as atividades do MySQL, basta usar o comando EXIT para fechá-lo.
Agora que o MySQL está carregado, poderemos começar a criar nossa base de dados, mas antes, vamos conhecer os tipos de dados suportados para elaborar nossas tabelas.
Tipo Descrição
INT Valor inteiro
REAL Valor de ponto flutuante
CHAR(tamanho) Valor de caractere de tamanho fixo. Valor inferior ao definido será deixado em branco.
TEXT(tamanho) Valor de caractere de tamanho variável.
VARCHAR(tamanho) Valor de caractere de tamanho variável. Valores inferiores ao definido serão suprimidos.
DATE Valor para datas do tipo (AAAA-MM-DD)
TIME Valor de tempo padrão
DATETIME Valor para data e hora agregados.
Veremos agora como é a sintaxe para se criar uma tabela:
CREATE TABLE nome_tabela (
campo1 tipo(tamanho) null/not null,
campo2 tipo(tamanho) null/not null,
campo3 tipo(tamanho) null/not null,
PRIMARY KEY (campo));
Esclarecendo as informações da sintaxe acima:
CREATE TABLE comando para se criar uma tabela
nome_tabela o nome que você dará a esta tabela
campo1..3 nome do campo dentro da tabela
tipo tipo de dado para este campo da tabela
tamanho tamanho para ser digitados os dados do tipo escolhido
null/not null deve-se escolher um dos dois para indicar se o campo aceita valores nulos ou não
PRIMARY KEY comando que informará qual é o campo chave na tabela
campo nome do campo que será o campo chave da tabela
Agora que você sabe os tipos de dados suportados e a sintaxe de como criar uma tabela, é fundamental que você saiba o que deseja criar, isto é, como será a sua base de dados e como todo bom analista de sistemas elabora uma documentação de projeto antes de meter a mão na massa, vamos a cola do nosso modelo da base de dados.
Iremos desenhar o modelo para a criação de uma base de dados simples, que seria o início do controle das informações de um colégio. Nossa base de dados será chamada de COLEGIO e nela teremos as tabelas ALUNOS, CURSOS e DISCIPLINAS. Vamos então ao modelo.
Tabela ALUNOS:
Nome do campo Tipo de dado
matricula varchar(5) *
nome varchar(50)
endereco varchar(50)
cidade varchar(30)
codcurso char(2)
Obs: O * asterisco, significa que o campo é chave.
Tabela CURSOS:
Nome do campo Tipo de dado
codcurso char(2) *
nomecurso varchar(50)
coddisc1 char(2)
coddisc2 char(2)
coddisc3 char(2)
Tabela DISCIPLINAS:
Nome do campo Tipo de dado
coddisciplina char(2) *
nomedisciplina varchar(30)
Mas o que é Campo Chave?
Campo chave é o campo mais importante de nossa tabela, pois este é o campo que irá identificar a posição de todos os outros dados de um registro. Os dados deste campo são exclusivos, isto é, não poderá existir dois registros deste campo em sua tabela com o mesmo valor. Por isso, toda tabela deve ter um campo designado como chave primária para o controle dos registros.
Criando a base de dados
Para podermos criar a base de dados a partir de nosso modelo, observe a sintaxe a seguir:
CREATE DATABASE nome_base_de_dados;
Esclarecendo as informações da sintaxe a cima:
CREATE DATABASE comando para se criar uma base de dados
nome_base_de_dados o nome que você dará a sua base de dados
Agora vamos meter a mão na massa. Lembre-se que o ";" (ponto e vírgula) serve para encerrar a linha de comando e após ele, deve-se pressionar "Enter" para que o comando seja executado. O texto que será apresentado abaixo da linha de comando é a confirmação de que o comando foi executado com êxito, neste nosso caso.
A partir do prompt do MySQL, digite o comando abaixo:
mysql> create database COLEGIO;
Query OK, 1 row affected (0.29 sec) // Isto indica que sua base foi criada.
Para utilizar agora esta base de dados, use o comando abaixo:
mysql> use COLEGIO;
Database changed // Isto indica que sua base está em uso.
Agora que já criamos a base de dados e ela está em uso, poderemos criar as nossas tabelas.
Criando a tabela Alunos:
mysql> create table ALUNOS (
-> matricula varchar(5) not null,
-> nome varchar(50) not null,
-> endereco varchar(50) null,
-> cidade varchar(30) null,
-> primary key(matricula) );
Query OK, 0 rows affected (0.21 sec)
Criando a tabela Cursos:
mysql> create table CURSOS (
-> codcurso char(2) not null,
-> nomecurso varchar(30) not null,
-> coddisc1 char(2) not null,
-> coddisc2 char(2) not null,
-> coddisc3 char(2) not null,
-> primary key(codcurso) );
Query OK, 0 rows affected (0.00 sec)
Criando a tabela Disciplinas:
mysql> create table DISCIPLINAS (
-> coddisciplina char(2) not null,
-> nomedisciplina varchar(30) not null,
-> primary key(coddisciplina) );
Query OK, 0 rows affected (0.00 sec)
Muito bem! Todas as tabelas foram criadas com sucesso.
Alterando a base de dados
Observe que houve erros durante a digitação, pois esquecemos o campo codcurso na tabela Alunos e trocamos o valor de 50 para 30 do tipo varchar do campo nomecurso da tabela Cursos.
Para corrigirmos isso, iremos utilizar o comando ALTER TABLE e usar os parâmetros ADD e CHANGE.
Adicionando o campo "codcurso" na tabela Alunos:
mysql> alter table ALUNOS
-> add codcurso char(2) not null;
Query OK, 0 rows affected (0.00 sec)
Records: 0 Duplicates: 0 Warnings: 0
Alterando o tamanho do campo "nomecurso" na tabela Cursos:
mysql> alter table CURSOS
-> change nomecurso nomecurso varchar(50);
Query OK, 0 rows affected (0.00 sec)
Records: 0 Duplicates: 0 Warnings: 0
Muito bem! Agora nossas tabelas estão de acordo com o modelo proposto.
Visualizando a estrutura de nossa base de dados
Veremos agora como ficou a estrutura de nossa base de dados.
Digite o comando a seguir para saber quais são as tabelas da base de dados COLEGIO:
mysql> show tables;
+-------------------+| Tables_in_COLEGIO |+-------------------+| ALUNOS || CURSOS || DISCIPLINAS |+-------------------+3 rows in set (0.00 sec)
OBS: Como já estávamos com a base de dados COLEGIO em uso, não foi preciso especificar seu nome.
Agora vamos ver como estão nossas tabelas, digite o comando abaixo:
mysql> show fields from ALUNOS;
+-----------+-------------+------+-----+---------+-------+| Field | Type | Null | Key | Default | Extra |+-----------+-------------+------+-----+---------+-------+| matricula | varchar(5) | | PRI | | || nome | varchar(50) | | | | || endereco | varchar(50) | YES | | NULL | || cidade | varchar(30) | YES | | NULL | || codcurso | char(2) | | | | |+-----------+-------------+------+-----+---------+-------+5 rows in set (0.00 sec)
mysql> show fields from CURSOS;
+-----------+-------------+------+-----+---------+-------+| Field | Type | Null | Key | Default | Extra |+-----------+-------------+------+-----+---------+-------+| codcurso | char(2) | | PRI | | || nomecurso | varchar(50) | YES | | NULL | || coddisc1 | char(2) | | | | || coddisc2 | char(2) | | | | || coddisc3 | char(2) | | | | |+-----------+-------------+------+-----+---------+-------+5 rows in set (0.00 sec)
mysql> show fields from DISCIPLINAS;
+----------------+-------------+------+-----+---------+-------+| Field | Type | Null | Key | Default | Extra |+----------------+-------------+------+-----+---------+-------+| coddisciplina | char(2) | | PRI | | || nomedisciplina | varchar(30) | | | | |+----------------+-------------+------+-----+---------+-------+2 rows in set (0.00 sec)
E aí, fez a comparação entre o modelo e o resultado da estrutura da criação de nossas tabelas? Se fez, você constatou que elas são equivalentes e o nosso trabalho está perfeito!
Mas só para ser do contra, vamos simular um problema
Digamos que o analista (oh, este analista não sou eu não tá, hehehe!!), cometeu um erro no projeto e especificou um campo há mais na tabela CURSOS, pois deveria ter apenas 2 "coddisc" e ele acabou especificando 3.
Devemos então apagar este campo, para isto use o comando abaixo:
mysql> alter table CURSOS -> drop coddisc3;Query OK, 0 rows affected (0.00 sec)Records: 0 Duplicates: 0 Warnings: 0
Como visto acima, o parâmetro DROP é utilizado para apagar um campo dentro de uma tabela. Use o comando show fields from CURSOS; para ver novamente a estrutura da tabela.
3. Manipulando dados nas tabelasAgora que já temos a nossa estrutura de tabelas prontas, é hora de começar a
inserir dados nelas, pois é para isso que elas servem, armazenar dados para que estes sejam trabalhados mais tarde.
Inserindo Dados
O comando utilizado para inserir dados nas tabelas é o INSERT, veja a sintaxe abaixo para se usar este comando:
INSERT INTO tabela VALUES (valor_campo1, valor_campo2, ..., valorcampoN);
OBS: Insere valores na ordem correta de todos os campos da tabela.
Vamos agora para a inserção de dados. Iremos começar com a tabela DISCIPLINAS, sendo assim, a partir do prompt do MySQL, digite os comandos abaixo:
mysql> insert into DISCIPLINAS values ('10','Matematica');Query OK, 1 row affected (0.30 sec)
mysql> insert into DISCIPLINAS values ('20','Portugues');Query OK, 1 row affected (0.00 sec)
mysql> insert into DISCIPLINAS values ('30','Quimica');Query OK, 1 row affected (0.00 sec)
mysql> insert into DISCIPLINAS values ('40','Biologia');Query OK, 1 row affected (0.00 sec)
OBS: O uso de aspas simples é obrigatório por se tratar de um valor não numérico. Lembre-se que '10' foi para o campo "coddisciplina" e que 'Matematica' foi para o campo "nomedisciplina", de acordo com a ordem dos campos da tabela.
Vamos agora para a tabela CURSOS:
mysql> insert into CURSOS values ('01', 'Ensino Medio', '30', '40');Query OK, 1 row affected (0.00 sec)
mysql> insert into CURSOS values ('02', 'Ensino Fundamental', '10', '20');Query OK, 1 row affected (0.00 sec)
OBS: Lembre-se que '01' foi para o campo "codcurso", 'Ensino Medio' para "nomecurso", '30' para "coddisc1" e '40' para "coddisc2".
Vamos agora para a tabela ALUNOS:
mysql> insert into ALUNOS values ('100', 'Jefferson Estanislau da Silva', 'Rua Alberto Braune - 150', 'Nova Friburgo', '01');
Query OK, 1 row affected (0.00 sec)
mysql> insert into ALUNOS values ('200', 'Leila Maria Muniz da Silva', 'Rua General Osorio - 90', 'Nova Friburgo', '01');
Query OK, 1 row affected (0.00 sec)
mysql> insert into ALUNOS values ('300', 'Camila Silva Perez', 'Rua Barata Ribeiro - 570', 'Rio de Janeiro', '02');
Query OK, 1 row affected (0.00 sec)
mysql> insert into ALUNOS values ('400', 'Victor Estanislau da Silva', 'Rua Galdino do Valle - 200', 'Nova Friburgo', '02');
Query OK, 1 row affected (0.00 sec)
OBS: Lembre-se que '100' foi para o campo "matricula", 'Jefferson Estanislau da Silva' foi para "nome", 'Rua Alberto...' para "endereco", 'Nova...' para "cidade" e '01' para "codcurso".
Muito bem! Acabamos de inserir dados em nossa base de dados. Mas e agora?
Visualizando dados
Não iria fazer sentido você armazenar dados se não pudesse visualizá-los quando fosse preciso, correto? Por isso, iremos aprender agora como visualizar estes dados. O comando a ser utilizado é o SELECT, veja a sintaxe dele abaixo:
SELECT {campo(s)} FROM {tabela(s)}
WHERE {condição}
ORDER BY {campo(s)}
GROUP BY {campo(s)}
Esclarecendo as informações da sintaxe a cima:
SELECT - comando para se chamar a visualização de registros
campo(s) - campos da tabela, para referência da visualização dos registros
FROM - chamada para indicar a tabela
tabela(s) - tabela ou tabelas a serem utilizadas
WHERE - chamada para uma condição
Condição - condição que deve ser verdadeira para que os registro sejam visualizados
ORDER BY - permite ordenar a visualização de registros em função de um campo especifico
GROUP BY - permite agrupar a visualização de registros em função de um campo especifico
Obs: O "*" (asterisco), terá um papel importante neste comando.
Exemplo1: Visualizar os nomes da tabela alunos quando a matricula for igual a '100'.
mysql> select nome from ALUNOS -> where matricula='100';+-------------------------------+| nome |+-------------------------------+| Jefferson Estanislau da Silva |+-------------------------------+1 row in set (0.46 sec)
Exemplo2: Visualizar os nomes da tabela alunos quando a codcurso for igual a '01'.
mysql> select nome from ALUNOS
-> where codcurso='01';
+-------------------------------+| nome |+-------------------------------+| Jefferson Estanislau da Silva || Leila Maria Muniz da Silva |+-------------------------------+2 rows in set (0.00 sec)
Exemplo3: Visualizar os nomes e endereço da tabela alunos quando a cidade for igual a 'Nova Friburgo'.
mysql> select nome, endereco from ALUNOS -> where cidade='Nova Friburgo';+-------------------------------+----------------------------+| nome | endereco |+-------------------------------+----------------------------+| Jefferson Estanislau da Silva | Rua Alberto Braune - 150 || Leila Maria Muniz da Silva | Rua General Osorio - 90 || Victor Estanislau da Silva | Rua Galdino do Valle - 200 |
+-------------------------------+----------------------------+3 rows in set (0.00 sec)Exemplo4: Visualizar todos os campos da tabela alunos.
mysql> select * from ALUNOS;
...
Exemplo5: Visualizar todos os campos da tabela alunos, ordenando-os pelo campo nome.
mysql> select * from ALUNOS -> order by nome;...
Visualizando dados de várias tabelas
Para que isto ocorra, será fundamental o campo chave, que ajudará a fazer a ligação com um campo comum de outra tabela, mas que tem o mesmo tipo de dado. Veja a sintaxe a seguir:
select TABELA1.campo, TABELA2.campo from TABELASwhere TABELA1.campo_chave = TABELA2.campo_comumand TABELA.campo = valor;
Esclarecendo as informações da sintaxe a cima:
tabela1.campo campo a ser exibido
tabela2.campo campo a ser exibido
tabelas nome das tabelas a serem usadas
tabela1.campo_chave campo chave para junção
tabela2.campo_comum campo comum para junção
tabela.campo qualquer uma das tabelas indicadas
valor valor para referência da condição
Exemplo6: Visualizar o campo "nome" da tabela alunos e o campo "nomecurso" da tabela cursos, retirado das tabelas alunos e cursos, quando codcurso da tabela alunos for igual a codcurso da tabela cursos e a cidade da tabela alunos seja igual a 'Nova Friburgo'.
mysql> select ALUNOS.nome, CURSOS.nomecurso from ALUNOS, CURSOS -> where ALUNOS.codcurso = CURSOS.codcurso -> and ALUNOS.cidade='Nova Friburgo';+-------------------------------+--------------------+| nome | nomecurso |+-------------------------------+--------------------+| Jefferson Estanislau da Silva | Ensino Medio || Leila Maria Muniz da Silva | Ensino Medio |
| Victor Estanislau da Silva | Ensino Fundamental |+-------------------------------+--------------------+3 rows in set (0.35 sec)Alterando dados
Outra coisa importante é você poder alterar uma informação, quando visualizado que esta foi cadastrada erroneamente, para isso iremos utilizar o comando UPDATE, como mostra a sintaxe abaixo:
UPDATE tabela SET campo = valor WHERE {condição};Vamos a uma explicação prática desta sintaxe:
mysql> update ALUNOS-> set cidade='Salvador'-> where matricula='300';Query OK, 1 row affected (0.00 sec)Rows matched: 1 Changed: 1 Warnings: 0
O exemplo acima significou que: usando a tabela alunos, altere a cidade para 'Salvador' quando a matricula for igual a '300'.
Para ver a alteração, use o comando: select * from ALUNOS;
Neste próximo exemplo, usando a tabela alunos, iremos mudar o nome para 'Joao Vieira da Silva' quando a cidade for igual a 'Salvador'.
mysql> update ALUNOS-> set nome='Joao Vieira da Silva'-> where cidade='Salvador';Query OK, 1 row affected (0.00 sec)Rows matched: 1 Changed: 1 Warnings: 0
Para ver a alteração, use o comando: select * from ALUNOS;
Apagando dados
Como toda a informação pode se tornar inútil ou desnecessária, devemos aprender como apagar um dado de nossa tabela. Para isso, iremos utilizar o comando DELETE, veja a sintaxe a seguir:
DELETE FROM tabela WHERE {condição};
Vamos a uma explicação prática desta sintaxe:
mysql> delete from ALUNOS-> where matricula='300';Query OK, 1 row affected (0.41 sec)
Observe que usei para esta condição o número da matrícula, mas poderia ter usado o valor de qualquer campo.
4. Restrições de integridade
São regras que servem para prevenir a entrada de informações inválidas pelos usuários. Para isso, o SGBD provê ferramentas para regras de integridade, afim de evitar a inconsistência dos dados que nele serão armazenados.
Valores nulos
Para evitar que um campo possa conter valor nulo (ou não conter valor algum) deve-se utilizar a cláusula NOT NULL após a definição da coluna, como já demonstrado anteriormente:
mysql> CREATE TABLE alunos (-> nome VARCHAR(50) NOT NULL, // não aceita valor nulo-> endereco VARCHAR(50) NULL // aceita valor nulo);
Valores Duplicados
Há situações onde o valor armazenado em um campo de um registro deve ser único em relação a todos os registros da tabela, para isso usamos a cláusula UNIQUE:
mysql> CREATE TABLE alunos (-> nome VARCHAR(50) NOT NULL,-> CPF INT(11) UNIQUE, // não deve haver dois registro com o mesmo CPF...);
Valores Inválidos
Há situações onde o valor de um campo deve obedecer a uma regra. Para que ele fique restrito a um conjunto de valores, utiliza-se a cláusula CHECK:
mysql> CREATE TABLE alunos (-> nome VARCHAR(50) NOT NULL,-> sexo CHAR(1) CHECK(sexo IN ("M", "F")), // obriga usar M ou F...);
Valores default
Pode-se definir um valor padrão para um campo acrescentando à sua definição a cláusula DEFAULT:
mysql> CREATE TABLE alunos (-> nome VARCHAR(50) NOT NULL,
-> cidade VARCHAR(30) DEFAULT "Nova Friburgo") ...
Campo chave ou chave primária
Como já comentado anteriormente, o campo chave é um campo muito importante para nossa tabela. Sua função é identificar univocamente uma linha do registro da tabela. Toda tabela deve possuir um campo chave. Quando este é definido, fica implícito as cláusulas UNIQUE e NOT NULL para este campo, não sendo necessário a especificação destas.
mysql> CREATE TABLE alunos (-> matricula VARCHAR(5) NOT NULL,-> nome VARCHAR(50) NOT NULL,-> PRIMARY KEY(matricula)); // define o campo matricula como chave
Visualizando dados de maneira mais organizada
Como já vimos, o comando SELECT é o responsável por fazer a exibição dos dados registrados em nossas tabelas, veremos agora como utilizar uma melhor aplicação deste recurso.
Evitando a exibição de linhas duplicadas
Para que isso não ocorra, é necessário a indicação da palavra DISTINCT imediatamente após o comando SELECT:
mysql> SELECT DISTINCT cidade FROM alunos;
Ordenando os dados
Já vimos anteriormente que para isto é necessário usar a cláusula ORDER BY. Por default está cláusula ordena os dados em ASCENDING (crescente), mas se você necessitar visualizar os dados na ordem decrescente, utilize as siglas DESC após a cláusula:
mysql> SELECT nome FROM alunos ORDER BY nome DESC;
Utilizando alias (apelidos)
Existem duas maneiras de se utilizar os Alias (apelidos) em uma cláusula do MySQL, são elas: apelido para o nome exibido no título da coluna de uma tabela e apelido para simplificar um nome de tabela que será constantemente utilizado em uma cláusula SELECT.
Exemplos 1: apelido para o título
mysql> SELECT nome FROM ALUNOS;+-------------------------------+| nome |+-------------------------------+| Jefferson Estanislau da Silva |
| Leila Maria Muniz da Silva || Victor Estanislau da Silva |+-------------------------------+
// observe que é apresentado o nome real da coluna.
mysql> SELECT nome AS INSCRITOS FROM ALUNOS;+-------------------------------+| INSCRITOS |+-------------------------------+| Jefferson Estanislau da Silva || Leila Maria Muniz da Silva || Victor Estanislau da Silva |+-------------------------------+//observe que o nome real foi substituido pelo apelido Inscritos.
Exemplo 2: apelido para uma tabela constante em uma cláusula:
mysql> SELECT ALUNOS.nome, CURSOS.nomecurso FROM ALUNOS, CURSOS -> where ALUNOS.codcurso = CURSOS.codcurso -> and ALUNOS.cidade='Nova Friburgo';
// observe que o nome das tabelas ALUNOS e CURSO são repetidos constantemente dentro desta cláusula.
mysql> SELECT A.nome, C.nomecurso FROM ALUNOS AS A, CURSOS AS C -> where A.codcurso = C.codcurso -> and A.cidade='Nova Friburgo';
// observe que foi utilizado o apelido A para AlUNOS e C para CURSOS, simplificando assim o código.
// As duas formas apresentam este resultado:
+-------------------------------+--------------------+| nome | nomecurso |+-------------------------------+--------------------+| Jefferson Estanislau da Silva | Ensino Medio || Leila Maria Muniz da Silva | Ensino Medio || Victor Estanislau da Silva | Ensino Fundamental |+-------------------------------+--------------------+
Utilizando condições
Já vimos que para que se faça o uso de condições deve se usar o comando WHERE. Veremos agora várias formas de se aplicar estas condições.
NOTA: é possível utilizar operadores de comparação lógica, estes estão divididos em duas classes:
Operadores de linha Única
= igual a
! diferente de > maior que >= maior ou igual a < menor que <= menor ou igual a
mysql> SELECT nome FROM alunos WHERE matricula='300';
Operadores de várias linhas AND e OR ou NOT não
mysql> SELECT nome FROM aluno WHERE cidade='Salvador' AND matricula='300';
mysql> SELECT nome FROM aluno WHERE cidade='Salvador' OR matricula='300';
Precedência de operadores
Uma cláusula WHERE pode combinar vários operadores AND e OR.
O operador AND tem maior precedência que o operador OR.
Os operadores de comparação tem maior precedência que os conectivos AND e OR.
Todos os operadores de comparação tem a mesma precedência.
Operadores de igual precedência são calculados da esquerda para a direita.
A precedência de operadores pode ser cancelada através de parênteses:
mysql> SELECT nome FROM alunos WHERE matricula > '100' AND (cidade = 'Nova Friburgo' OR codcurso='01');
Operador LIKE
Busca valores alfanuméricos incompletos a partir de um ou mais caracteres:
% - corresponde a uma seqüência qualquer de 0 ou mais caracteres.
"_" - corresponde a qualquer caracter.
mysql> SELECT nome FROM alunos WHERE nome LIKE 'J%';
// lista todos os nomes que comecem com J
mysql> SELECT nome FROM alunos where nome LIKE '_________';
// lista todos os nomes que possuem exatamente 9 caracteres.
Operador BETWEEN
Busca valores entre uma faixa especificada:
mysql> SELECT nome FROM alunos WHERE matricula BETWEEN '100' AND '300';
Operador IN
Utiliza-se o operador IN para testar valores em uma lista específica:
mysql> SELECT nome FROM alunos WHERE codcurso IN ('01', '02');
Uso de funções
Concatenando dados
sintaxe: CONCAT(campo1, campo2)
mysql> SELECT matricula, nome, CONCAT(matricula, nome) FROM alunos;
Arredondando valores
ROUND (col/value,n) - Arredonda campo, expressão ou valor para n casas decimais, se n for omitido, as casas decimais também serão omitidas. Caso n seja negativo , os números à esquerda da vírgula serão arredondados:
mysql> SELECT ROUND (90.999, 1) FROM tabela;// arredondará o valor 90,999 para 90,9
mysql> SELECT ROUND (campo, 2) FROM tabela;// arredondará o valor do campo para 2 casas decimais 0,00
Truncando valores
TRUNC (col/value,n) - Trunca campo, expressão ou valor para n casas decimais, se n for omitido, todas as casas decimais serão omitidas. Caso n seja negativo, o número à esquerda da vírgula será truncados para zero:
mysql> SELECT TRUNC (90.999, 2) FROM tabela;// arredondará o valor 90,999 para 90,99
mysql> SELECT TRUNC (campo, 1) FROM tabela;
// arredondará o valor do campo para 1 casas decimais 0,0
Encontrando valores
CEIL (col/value) - Encontra o menor inteiro maior ou igual a campo, expressão ou valor:
mysql> SELECT CEIL(campo) FROM tabela;
// encontra o menor inteiro deste campo
mysql> SELECT CEIL(99.9) FROM tabela;
// encontra o menor inteiro a partir de 99.9
Raiz quadrada de um valor
SQRT (col/value) - Raíz do campo, expressão ou valor:
mysql> SELECT SQRT(campo) FROM tabela;
// encontra a raiz quadrada dos valores deste campo
mysql> SELECT SQRT(81) FROM tabela;
// encontra a raiz quadrada de 81
Retornando valor para comparação
SIGN (col/value) - Retorna -1 se a campo, expressão ou valor é um número negativo, retorna zero se o número é zero e +1 se o número é positivo:
mysql> SELECT SIGN(campo) FROM tabela;
OBS: É uma opção interessante para se testar previamente um valor.
Resto de Divisão
MOD (value1,value2) - Determina o resto da divisão de value1 dividido por value2:
mysql> SELECT MOD(valor1, valor2) FROM tabela;mysql> SELECT MOD(campo1, campo2) FROM tabela;
OBS: É uma função que pode se tornar muito útil.
Soma
SUM (campo) - Retorna a soma dos valores de um campo dos registros de um tabela:
mysql> SELECT SUM(campo) FROM tabela;
Média
AVG (campo) - Retorna a média dos valores de um campo dos registros de um tabela:
mysql> SELECT AVG(campo) FROM tabela;
Valor Máximo
MAX (campo) - Retorna o maior valor entre todos os valores de um campo dos registros de um tabela:
mysql> SELECT MAX(campo) FROM tabela;
Valor Mínimo
MIN (campo) - Retorna o menor valor entre todos os valores de um campo dos registros de um tabela:
mysql> SELECT MIN(campo) FROM tabela;
Retornando o número de linhas (registros) de uma tabela ou campo
COUNT(*) - Retorna o número de linhas em uma tabela, incluindo linhas duplicadas e linhas contendo valores NULL.
COUNT(campo) - Retorna o número de linhas não NULL no campo identificada.
mysql> SELECT COUNT(*) FROM tabela;// retorna a quantidade de registros da tabela
mysql> SELECT COUNT(campo) FROM tabela;// retorna a quantidade de registros não nulos deste campo
mysql> SELECT COUNT(campo) FROM tabela where "condição";// retorna a quantidade de registros do campo sobre determinada condição
mysql> SELECT COUNT(DISTINCT(cidade)) FROM tabela;// retorna a quantidade de registros do campo cidade sem a duplicação de
nomes
Recommended