Trabalho de banco de dados

CENTRO ESTADUAL DE EDUCAÇÃO TECNOLÓGICA CENTRO PAULA SOUZA ETEC DR EMÍLIO HERNANDEZ AGUILAR MOISÉS OSTI Nº 24 JHONATAN WILLIAN Nº 17 DIOGO BERBEL CAMPAGNOLA Nº 09 VALDÉRIO DO SANTOS SOUSA Nº 32 MARIA APARECIDA DE ALMEIDA Nº 34 Trabalho de banco de dados (MySQL) Franco da Rocha 2010

SUMÁRIO História do MySQL... 3 O Banco de Dados MySQL... 4 Como adquirir o MySQL e instalá-lo em sistema Windows... 5 Instalando MySQL tools... 15 Tipos de dados... 16 Criando o banco de dados... 17 Criando Tabelas... 19 Inserir dados em uma tabela... 20 Consultar os dados inseridos em uma tabela... 22 Criando apelidos para os atributos... 24 Deletando registros nas tabelas... 25 Criando um relacionamento de tabelas... 26 Referencias Bibliográficas... 28

P á g i n a 3 História do MySQL O MySQL surgiu a partir da necessidade da equipe que criou o SGBD, de utilizar algum macanismo que permitisse a conexão de tabelas criadas na linguagem SQL para um determinado fim. A principio, o grupo iria utilizar o msql, mas logo perceberam que essa ferramenta não era tão rápida para atender as necessidades do projeto. O jeito foi criar uma solução própria. Nascia o MySQL. O MySQL foi criado por Michael Widenius na compainha Suíça TcX. Por volta de 1979 Michael desenvolveu um banco de dados chamado UNIREG, sendo rescritos em várias linguagens desde então. Em 1994, a empresa TcX começou o desenvolvimento de aplicações baseadas na Web, tendo como base o banco UNIREG, porém esse banco possuía muito overhead para obter sucesso em uma aplicação para geração de páginas dinâmicas na Web. Então a empresa TcX começou a procurar por outro banco o msql, uma ferramenta baseada em SQL mas com caraquiterísticas pobres não possuindo por exemplo suporte a índices, e com desempenho inferior ao UNIREG. Foi então que o desenvolvedor do banco UNIREG contatou o David Hughes criador do msql, para saber do interesse dele em unir os dois bancos, Sendo positivo o interesse de David, a empresa TcX resolveu desenvolver um novo banco, mas mantendoao maximo a compatibilidade com msql. TcX foi esperta o suficiente para não reinventar o que já estava bem feito, ela contruiu seu servidor baseado na estrutura que já estava montada no UNIREG e utilizou grande número de utilitários escritas para msql e fez API s para o novo servidor praticamentes iguais ao msql. Como resultado usuários do msql que decidissem mudar para o novo servidor da TcX, teriam apenas que fazer pequenas e simples mudanças nos códigos existentes. Então foi em maio de 1995 que, definitivamente, a primeira versão do MySQL foi lançada. Um dos parceiros da TcX sugeriu a distribuição do servidor na internet, o objetivo disso era a utilização de um modelo pioneiro desenvolvido por Aladdin Peter Deutsch. O resultado foi maior lexibilidade em sem copyright, que fez do MySQL mais difundido gratuitamente do que o msql.

P á g i n a 4 O Banco de Dados MySQL O MySQL foi desenvolvido pela TcX em 1996. Atualmente a MySQL AB desenvolve o programa MySQL AB é a compainha dos fundadores e principais desenvolvedores do MySQL. Eles criaram-no porque precisavam de um banco de dados relacional que pudesem tratar grandes quantidades de dados em máquinas de custo relativamente barato. O MySQL é um dos banco de dados relacionais mais rápidos do mercado, apresenta quase todas as funcionalidades dos grandes banco de dados. MySQL é uma linguagem simples, em que você facilmente pode gravar, alterar e recuperar informações num web site com segurança e rapidez. O MySQL éexecutado, principalmente, em sistemas queparticipam da filosofia UNIX, embora outros sistemas S.O também fornecem suporte, como Windows, por exemplo. O MySQL é um sistema de gerenciamento de banco de dados relacional multiencadeado, de código fonte aberto e nível corporativo. O MySQL não é apenas um banco de dados, mas sim um gerenciador de banco de dados. Como este SGBD (sistema Gerenciador de Banco de Dados), também pode ser utilizado para aplicações corporativas o qual, necessitam de varias conexões simultâneas, que possibilita 101 conexões simultâneas. Uma conexão é o tempo que leva para o usuério receber o dado solicitado. O MySQL é um sistema de gerenciamento de banco de dados relacional. Um banco de dados relacional armazena dados em tabelas separadas em vez de colocar todos os dados um só local. Isso proporciona velocidade e flexibilidade. O Servidor mysql foi desenvolvido originalmente para lidar com banco de dados muito grandes de maneira muito mais rápida que as soluções existentes e tem sido usado em ambientes de produção de alta demanda por diversos anos de maneira bem sucedida. Apesar de estar em constante desenvolvimento, o Servidor MySQL oferece hoje um rico e proveitoso conjunto de funções. A conectividade, velocidade e segurança fazem com que o MySQL seja altamente adapitável para acessar bancos na internet. O programa de Banco de Dados MySQL é um sistema cliente/servidor que consiste de um servidor SQL multitarefa que suporta acessos diferentes, diversos programas clientes e bibliotecas, ferramentas administrativas e diversas interfaces de programação (API s). Também concedemos o Servidor MySQL como uma biblioteca multitarefa que você pode ligar à sua aplicação para chegar a um profuto mais rápido, menor e mais facilmente gerenciável

P á g i n a 5 Como adquirir o MySQL e instalá-lo em sistema Windows Primeiro passo: fazer o download do banco de dados na página: http://www.mysql.com/ Clique na opção downloads e faça o download da versão MySQL Community Server (que é free). Escolha a opção de acordo com a arquitetura da sua máquina (Windows ou Windows x64). Após o download, execute o setup. Clique em Next na primeira tela: Instalando My SQL Escolha a opção Typical :

P á g i n a 6 O My SQL será instalado no seguinte diretório. Clique em Next : Instalando My SQL Aguarde a instalação:

P á g i n a 7 Clique em Next : Instalando My SQL Clique em Next novamente:

P á g i n a 8 Deixe a opção para configurar o My SQL marcada e clique em Finish : Instalando My SQL A tela de configuração irá aparecer. Clique em Next :

P á g i n a 9 Deixe a opção Detailed Configuration marcada e clique em Next : Instalando My SQL Deixe a opção Developer Machine marcada (assim o servidor não vai utilizar muito os recursos da máquina). Clique em Next :

P á g i n a 10 Deixe a opção Multifunctional Database marcada e clique em Next : Instalando My SQL Selecione o diretório onde o banco será armazenado. Por padrão, é no diretório de instalação. Se não mudar, apenas clique em Next :

P á g i n a 11 Deixe a opção Decision Support marcada. Clique em Next : Deixa as duas opções marcadas e clique em Next :

P á g i n a 12 Escolha a opção do suporte a linguagem. O padrão é a primeira opção. Clique em Next : Escolha se quer criar um serviço do Windows para o My SQL. Se desativar essa opção, lembre-se de iniciar o banco sempre que for usar. Clique em Next :

P á g i n a 13 Cria uma root password. Lembre-se de criar uma senha fácil. Clique em Next : Clique em Execute :

P á g i n a 14 Espere alguns segundos para aplicar as configurações e clique em Finish : Pronto, agora é só usar!

P á g i n a 15 Instalando MySQL tools Se você tiver apenas o My SQL instalado na máquina, vai ter que fazer todas a configurações na mão através da linha de comando, (justamente é o foco de nosso curso usar as linhas de códigos para montar o nosso banco de dados). O My SQL Tools é um conjunto de ferramentas que ajudam a administrar o banco através de interface visual. É composto de quatro ferramentas: My SQL Administrator, My SQL Migration Toolkit, My SQL Query Browser e My SQL System Tray Monitor. A instalação dessas ferramentas é opcional. Mas se quiser fazer o download, basta acessar http://dev.mysql.com/downloads/gui-tools/ e escolher a versão compatível com o servidor My SQL que está instalado na máquina. Veja a demonstração do banco de dados MySQL em visual (MySQL Query Browser).

P á g i n a 16 Tipos de dados 1- Tipos numéricos mais utilizados: Existem tipos de dados numéricos, que se podem dividir em dois grandes grupos, os que estão em vírgula flutuante (com decimais) e os que não. Bit ou Bool: um número inteiro que pode ser 0 ou 1. Float: número pequeno em vírgula flutuante de precisão simples. Os valores válidos vão desde -3.402823466E+38 até -1.175494351E-38,0 eté desde 175494351E-38 até 3.402823466E+38. xreal, Double: número em vírgula flutuante de dupla precisão. Os valores permitidos vão desde -1.7976931348623157E+308 até -2.2250738585072014E-308, 0 e desde 2.2250738585072014E-308 até 1.7976931348623157E+308 Decimal, Dec, Numeric: Número em vírgula flutuante desempacotado. O número armazena-se como uma cadeia. Tipo de Campo Tamanho de Armazenamento TINYINT 1 byte SMALLINT 2 bytes MEDIUMINT 3 bytes INT 4 bytes INTEGER 4 bytes BIGINT 8 bytes FLOAT(X) 4 ou 8 bytes FLOAT 4 bytes DOUBLE 8 bytes DOUBLE PRECISION 8 bytes REAL 8 bytes DECIMAL(M,D) M+2 bytes se D > 0, M+1 bytes se D = 0 NUMERIC(M,D) M+2 bytes se D > 0, M+1 bytes se D = 0 2- Tipos data Na hora de armazenar datas, há que ter em conta que MySQL não verifica de uma maneira estricta se uma data é válida ou não. Simplesmente comprova que o mês está compreendido entre 0 e 12 e que o dia está compreendido entre 0 e 31. Date: tipo data, armazena uma data. A margem de valores vai desde o 1 de Janeiro de 1001 ao 31 de dezembro de 9999. O formato de armazenamento é de ano-mes-dia.

P á g i n a 17 DateTime: Combinação de data e hora. A margem de valores vai desde o 1 ed Janeiro de 1001 às 0 horas, 0 minutos e 0 segundos ao 31 de Dezembro de 9999 às 23 horas, 59 minutos e 59 segundos. O formato de armazenamento é de ano-mes-dia horas:minutos:segundos Time: armazena uma hora. A margem de horas vai desde -838 horas, 59 minutos e 59 segundos. O formato de armazenamento é 'HH:MM:SS'. Year: armazena um ano. A margem de valores permitidos vai desde o ano 1901 ao ano 2155. O campo pode ter tamanho dois ou tamanho 4 dependendo de se queremos armazenar o ano com dois ou quatro algarismos. Tipo de Campo Tamanho de Armazenamento DATE 3 bytes DATETIME 8 bytes TIMESTAMP 4 bytes TIME 3 bytes YEAR 1 byte 3- Tipos de cadeia vistos aqui (Char) e (Varchar): Char(n): armazena uma cadeia de longitude fixa. A cadeia poderá conter desde 0 até 255 caracteres. VarChar(n): armazena uma cadeia de longitude variável. A cadeia poderá conter desde 0 até 255 caracteres. Dentro dos tipos de cadeia pode-se distinguir dois subtipos, os tipo Test e os tipo Blob (Binary Large Object) A diferença entre um tipo e outro é o tratamento que recebem na hora de ordená-los e compará-los. No tipo test ordena-se sem ter importância as maiúsculas e as minúsculas e no tipo blob ordenase tendo em conta as maiúsculas e minúsculas. Criando o banco de dados Podemos manipular o banco de dados MySQL de diversas formas, entre elas com o utilitário de linha de comando My SQL, que se encontra no diretório /bin da intalação do banco de dados. Outras formas seriam através de IDEs ou MySQL Management (Gerenciadores MySQL). Mas para neste curso estaremos focando o utilitário de linha de comando: Acessando no prompt o diretório MySQL/Bin e execute o MySQL

P á g i n a 18 Caso você tenha definido uma senha para o usuário root deve usar a seguinte linha de comando: /mysql/bin/mysql u root p Será solicitado 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.2a-nt-max Type help; or \h for help. Type \c to clear the buffer. Mysql> O primeiro passo é criar uma base de dados. A síntase do MySQL para a criação de base de dados é a seguinte: CREATE DATABASE[IF NOT EXISTS] nome_db. O parâmetro opcional [IF NOT EXISTS] permite que executamos o comando de criação de 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: Identificador Tam. máx. (bytes) Caracteres permitidos Banco de dados 64 Qualquer caractere que é permitido em um nome de diretório exceto / ' ou. '. Tabela 64 Qualquer caractere permitido em um nome 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 caracter de citação (aspas) em um identificador. Por outro lado os identificadores podem ter nomes de palavras reservadas, neste caso temos que nos referencias a eles com o do caracter `. mysql> SELECT * FROM `select` WHERE `select`.id > 100; Vamos então criar a nossa base de dados de exemplo. Vamos chama-lá de LOCADORA. mysql> create database if not exists locadora; 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.

P á g i n a 19 Logo a base de dados que acabamos de criar ficará localizada em algo como:/mysql/data/locadora O comando que mostra todo as bases de dados que existe no MySQL é: SHOW DATABASES; mysql> show databases; +-------------------+ Database +-------------------+ locadora test +-------------------+ 2 rows in set (0.00 sec) mysql> Neste caso temos duas base de dados disponíveis: locadora, que acamos de criar; e test. Para podermos começar a trabalhar com nossa base de dados devemos avisar ao MySQL que devemos usa-la. O comando para isto é USE nome_db; mysql> use locadora; Database changed mysql> Criando Tabelas A síntase de criação de tabelas do MySQL é a seguinte; CREATE TABLE nome_tabela Como é comum criar a tabela já acompanhada de seus campo (atributos ou fields). Vamos criar no nosso exemplo a tabela filmes com os seguintes campos; Id; (campo de identificação em outras palavras ela será a chave primária); titulo, ano e o diretor; Executado os seguintes comandos; 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

P á g i n a 20 No campo id por exemplo o tipo é int(10) com o modificador usigned, ele não aceita valores nulos (NOT NULL) e é auto_increment, ou seja, seu valor é definido automaticamente, aumentando de 1 em 1 toda vez quer o 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 em um valor Maximo determinado por nós que é de (80). O campo também não pode ser nulo. A ultima definição primary key (id) define qual campo será utilizado para realizar a identificação do registro. 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. Podemos 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) +---------+------------------+------+-----+---------+----------------+ 4 rows in set (0.19 sec) mysql> Com o retorno do DESC podemos ver quais os campos da tabela, os tipos dos campos, se aceita valores nulos ou não, se existe chave primária e se algum campo possui a propriedade auto_increment. Inserir dados em uma tabela Primeiramente acesse o utilitário 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;

P á g i n a 21 +--------------------+ Tables_in_locadora +--------------------+ filmes +--------------------+ 1 row in set (0.05 sec) mysql> A síntese básica do comando INSERT é a seguinte: INSERT INTO nome_tabela [(nome_coluna,...)] VALUES (valores). mysql> insert into filmes (id,titulo,ano,diretor) -> values (0,'King Kong',2006,'Peter Jackson'); Query OK, 1 row affected (0.08 sec) mysql> 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 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. Ressaltando os valores (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 filmes values -> (null,'guerra dos Mundos',2005,'Steven Spielberg'); 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. mysql> select * from filmes; +----+-------------------+------+------------------+ id titulo ano diretor +----+-------------------+------+------------------+ 1 King Kong 2006 Peter Jackson 2 Guerra dos Mundos 2005 Steven Spielberg +----+-------------------+------+------------------+ 2 rows in set (0.01 sec) mysql> O comando SELECT*FROM filmes; lista todos os valores adicionados nos campos. Esquecer de atribuir valor a uma coluna NOT NULL No nosso caso a tabela filmes 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 atribuira um valor automático.

P á g i n a 22 mysql> insert into filmes (titulo, ano) values -> ('Harry Potter e o Cálise de Fogo',2006); ERROR 1364 (HY000): Field 'diretor' doesn't have a default value mysql> Neste caso tentamos inserir apenas o valor do titulo e ano do filme, o banco de dados não aceitou e mostrou o erro 1364, para avisar que o campo diretor 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 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 sintese na instrução SQL próximo de 'Newell)', ou seja, próximo ao nome do diretor. Depois desses erros vamos finalmente inserir os valores corretamente. mysql> insert into filmes (id,titulo,ano,diretor) values -> (0,'Harry Potter e o Cálise de Fogo',2006,'Mike Newell'); Query OK, 1 row affected (0.23 sec) mysql> Os valores da tabela filme ficou assim: 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.02 sec) Consultar os dados inseridos em uma tabela 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 realizar consultas ao banco de dados é o comando SELECT.

P á g i n a 23 SELECT (colunas) FROM nome_tabela WHERE definição_where Vamos para um exemplo prático em nossa tabela; 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, 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.

P á g i n a 24 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) 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). Criando apelidos para os atributos 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

P á g i n a 25 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, vale lembrar também q esses comandos visto acima, são comandos básicos do SELECT. Deletando registros nas tabelas 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. no MySQL 3.23, o comando retorna zero. A partir do MySQL 4.0.0 a exclusão em multi-tabelas é suportada. 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'. 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. 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.

P á g i n a 26 Criando um relacionamento de tabelas O relacionamento de tabelas é necessário quando temos mais de uma tabela com informações que podem e precisam ser cruzadas, por exemplo; Categorias e produtos... Cada registro na tabela produtos estará ligado a um registro da tabela categorias. existem três níveis de relacionamento: nosso exemplo será um relação de 1:N (fala-se um pra N ou um para muitos ) onde cada categoria (1) contém um ou mais produtos (N) Há também o 1:1 onde cada registro de uma tabela (1) está ligado a um e somente um registro de outra tabela (1) E há outro nível de relacionamento, mais complexo, que é o N:N onde um ou mais registros de uma tabela (N) estão relacionados a um ou mais registros de outra tabela (N), que seria o exemplo de duas tabelas produtos e tags onde um produto tem várias tags e vários produtos pertencem a uma tag. Como já vimos como cria o banco e as tabelas já com seus atributos e inserimos dados nela. Vamos criar duas tabelas um pouco mais complexa. Para o exemplo utilizaremos a tabela categorias e produtos CREATE TABLE `categorias` ( `id` INT NOT NULL AUTO_INCREMENT PRIMARY KEY, `nome` VARCHAR( 255 ) NOT NULL ) CREATE TABLE `produtos` ( id` INT NOT NULL AUTO_INCREMENT PRIMARY KEY, `categoria_id` INT NOT NULL, `nome` VARCHAR( 255 ) NOT NULL, `preco` DECIMAL( 10,2 ) NOT NULL ) Inserindo os dados: -- Extraindo dados da tabela `categorias` INSERT INTO `categorias` VALUES(1, 'Camisetas'); INSERT INTO `categorias` VALUES(2, 'Canecas');

P á g i n a 27 -- Extraindo dados da tabela `produtos` INSERT INTO `produtos` VALUES(1, 1, 'Camiseta Social', 15.00); INSERT INTO `produtos` VALUES(2, 1, 'Camiseta Regata', 11.99); INSERT INTO `produtos` VALUES(3, 2, 'Caneca Grande', 12.00); Reparem que na tabela produtos temos uma coluna especial, que é a categoria_id (INT) Ela é quem ajudará a fazer a relação das duas tabelas Nessa coluna entrará o ID da categoria a qual o produto pertence Ou seja: as duas camisetas pertencem a categoria Camisetas (ID 1) e o terceiro produto (a Caneca Grande) pertence a categoria Canecas (ID 2) e é na coluna categoria_id que armazenamos esses IDs que identificam as categorias. Esse campo responsável pela relação é normalmente chamado de foreing key (fk) ou chave estrangeira.

P á g i n a 28 Referencias Bibliográficas www.hospedia.com.br www.loiane.com/downloads/instalando www.criarweb.com/artigos/118.php http://blog.thiagobelem.net/mysql/relacionamento-de-tabelas-no-mysql