Upload
lucilio-carvalho
View
286
Download
3
Embed Size (px)
Citation preview
Relacionamento de Tabelas no MySQL
Opa opa! Hoje vamos a mais um tutorial “step by step” onde vou falar e mostrar como fazer
relacionamento entre tabelas no MySQL.
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.
Só pra vocês saberem, 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.
Não vou me aprofundar muito no assunto… Vou falar apenas da relação mais comum (1:N) e dar
exemplos de como trabalhar com elas.
Para o nosso exemplo de hoje usaremos duas tabelas, chamadas “categorias” e “produtos”:
01 CREATE TABLE `categorias` (
02 `id` INT NOT NULL AUTO_INCREMENT PRIMARY KEY ,
03 `nome` VARCHAR( 255 ) NOT NULL
04 ) ENGINE = MYISAM;
05
06 CREATE TABLE `produtos` (
07 `id` INT NOT NULL AUTO_INCREMENT PRIMARY KEY ,
08 `categoria_id` INT NOT NULL ,
09 `nome` VARCHAR( 255 ) NOT NULL ,
10 `preco` DECIMAL( 10,2 ) NOT NULL
11 ) ENGINE = MYISAM;
E vamos inserir alguns dados para exemplo:
1 -- Extraindo dados da tabela `categorias`
2 INSERT INTO `categorias` VALUES(1, 'Camisetas');
3 INSERT INTO `categorias` VALUES(2, 'Canecas');
4
5 -- Extraindo dados da tabela `produtos`
6 INSERT INTO `produtos` VALUES(1, 1, 'Camiseta Social', 15.00);
7 INSERT INTO `produtos` VALUES(2, 1, 'Camiseta Regata', 11.99);
8 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”.
Mas qual a utilidade dessa tal “relação”?
Sem usar o relacionamento você poderia pegar todos os produtos e depois pegar as informações das
categorias com uma segunda consulta, assim:
01 <?php
02
03 // Consulta que pega todos os produtos
04 $sql = "SELECT * FROM `produtos` ORDER BY `nome` ASC";
05 $query = mysql_query($sql);
06 while ($produto = mysql_fetch_assoc($query)) {
07 // Aqui temos o array $produto com todos os valores do produto
08
09 // Consulta para pegar os dados da categoria:
10 $sqlC = "SELECT * FROM `categorias` WHERE `id` =
" .$produto['categoria_id'];
11 $queryC = mysql_query($sqlC);
12 $categoria = mysql_fetch_assoc($queryC);
13
14 echo 'Titulo: ' . $produto['nome'] . '<br />';
15 echo 'Preço: ' . $produto['preco'] . '<br />';
16 echo 'Categoria: ' . $categoria['nome']. '<br />';
17 echo '<hr />';
18 }
19
20 ?>
Até aí tudo bem… Não tem nenhum pecado nisso… Mas imagine que você tem uma loja com 1000
produtos (o que não é muito), seria executada 1 consulta para todos os produtos e, dentro do loop
(while) seriam executadas outras 1000 consultas para pegar o nome da categoria a qual o produto
pertence… Ou seja, 1001 consultas, o que é um absurdo.
A mágica da relação
Agora vamos montar uma consulta que DE UMA SÓ VEZ irá pegar os dados de cada produto e
também o nome da categoria… Com isso reduziremos nossas 1001 consultas pra… uma só! Sem
mistérios, sem sub-consultas, nem consultas dentro do while()!
Mas antes de mostrar o script vou ajudar a vocês entenderem como a relação é feita… Antes a nossa
consulta que pega apenas os produtos era assim:
SELECT * FROM `produtos` ORDER BY `nome` ASC
Sua tradução seria: SELECIONAR todas as colunas da TABELA `produtos` ORDENADO
PELO `nome` ASCENDETEMENTE
Agora usaremos uma nova “palavra” do MySQL que é o JOIN (tradução: “unir”) e serve para unir
resultados de duas tabelas..
Existem três tipos de JOIN mas não vou falar dos outros dois pois eles são MUITO pouco usados…
Falaremos do “INNER JOIN” que exige que haja um registro que corresponda a relação nas duas
tabelas, ou seja: se houver um produto sem categoria ou a categoria não existir na tabela categorias
esse produto é omitido dos resultados.
A nossa consulta ficará assim:
SELECT `produtos`.* FROM `produtos` INNER JOIN `categorias` ON`produtos`
.`categoria_id` = `categorias`.`id` ORDER BY `produtos`.`nome` ASC
Sua tradução seria: SELECIONAR todas as colunas [da tabela produtos] da TABELA
`produtos` UNINDO A TABELA `categorias` ONDE a coluna `categoria_id` [da tabela
produtos] É IGUAL a coluna `id` [da tabela categorias] ORDENADO PELO `nome` [da tabela
produtos] ASCENDETEMENTE
A nossa “regra de relação” acontece ali entre o ON e o ORDER BY, dizemos que a relação entre as
tabelas usará como referencia a coluna “categoria_id” da tabela “produtos” sendo igual a coluna “id”
da tabela “categorias”… Se você fosse usar algum WHERE ele entraria depois do ON e antes do
ORDER BY.
Pra quem ainda não entendeu, o ON é como o WHERE de uma consulta normal… É a regra da
relação.
Repare que agora precisamos usar um formato diferente para identificar as colunas
usando: `tabela`.`coluna`… Isso é necessário pois agora estamos trabalhando com duas tabelas.
Da forma que a nossa consulta está ainda não estamos pegando o nome da categoria… fazemos isso
adicionando mais um campo na parte do SELECT, assim:
SELECT `produtos`.*,
`categorias`.`nome` FROM `produtos` INNER JOIN`categorias` ON `produtos`
.`categoria_id` = `categorias`.`id` ORDER BY`produtos`.`nome` ASC
Agora estamos pegando também o valor da coluna “nome” do registro encontrado (pela relação) na
tabela “categorias”.
Só que agora temos um novo problema… Nas duas tabelas existe uma coluna chamada “nome”, e
quando estivermos lá no PHP, dentro do while, não teríamos como identificar de qual tabela
pegamos as informações (veja a próxima imagem), pois as duas seriam$produto['nome']…
Precisamos então renomear esse novo campo que adicionamos a busca, assim:
SELECT `produtos`.*,
`categorias`.`nome` AS categoria FROM `produtos` INNERJOIN `categorias`
ON `produtos`.`categoria_id` =
`categorias`.`id` ORDER BY`produtos`.`nome` ASC
Agora o resultado de `categorias`.`nome` estará presente nos resultados como “categoria” e não
“nome”… Sei que parece complicado de início mas vocês vão entender já já.
E por fim, faremos mais uma modificação, pra evitar ficar usando `tabela`.`coluna` também
podemos renomear as tabelas, e com isso diminuir otamanho da consulta:
SELECT p.*,
c.`nome` AS categoria FROM `produtos` AS p INNER JOIN`categorias` AS c ON
p.`categoria_id` = c.`id` ORDER BY p.`nome` ASC
Nesse caso p representará a tabela “produtos” e c representará a “categorias”.
Sei que parece uma consulta maior e mais complicada… Mas você fará o MySQL trabalharmuito
menos se fizer assim, com JOINS, do que fazer uma 2ª consulta dentro do while… Essa é a forma
mais correta de fazer consultas quando precisamos de informações vindas de mais de uma tabela.
Agora vamos ao nosso novo script de PHP que, sem dúvidas, é bem mais prático e eficiente:
01 <?php
02
03 // Consulta que pega todos os produtos e o nome da categoria de cada
um
04 $sql = "SELECT p.*, c.`nome` AS categoria FROM `produtos` AS p INNER JOIN `categorias` AS c ON p.`categoria_id` = c.`id` ORDER BY
p.`nome` ASC";
05 $query = mysql_query($sql);
06 while ($produto = mysql_fetch_assoc($query)) {
07 // Aqui temos o array $produto com todos os dados encontrados
08 echo 'Titulo: ' . $produto['nome'] . '<br />';
09 echo 'Preço: ' . $produto['preco'] . '<br />';
10 echo 'Categoria: ' . $produto['categoria']. '<br />';
11 echo '<hr />';
12 }
13
14 ?>
Os outros tipos de JOINs
Existem também outros dois tipos de JOIN: o LEFT JOIN e o RIGHT JOIN:
Se usássemos o LEFT JOIN seriam retornados todos os produtos, independente se eles estão
ligados a uma categoria (na tabela categorias) existente ou não.
Já o RIGHT JOIN seria exatamente o contrário: seriam retornados todos os produtos que pertencem
categorias existentes e também o nome das outras categorias que não tem ligação com nenhum
produto.
O uso desses outros tipos de JOIN é muito raro e acho que não vale a pena ficar filosofando sobre
eles enquanto se aprende sobre relacionamentos.
E a relação com mais de duas tabelas?
Só pra exemplo, essa seria a consulta que pega os produtos, as categorias e o nome do usuário que
cadastrou o produto e filtrando apenas pelos produtos ativos:
SELECT p.*, c.`nome` AS categoria,
u.`nome` AS usuario FROM `produtos` AS pINNER JOIN `categorias` AS c ON p.
`categoria_id` = c.`id` INNER JOIN`usuarios` AS u ON p.`usuario_id` =
u.`id` WHERE (p.`ativo` = 1) ORDER BYp.`nome` ASC
Sim.. eu adoro consultas gigantescas.
Compartilhe:
Curtir isso:
This entry was posted in Artigos, MySQL, Otimização, PHP and
tagged JOIN, MySQL, PHP,Relacionamento on 15 de agosto de 2009 by Thiago Belem.
About Thiago Belem
Desenvolvedor a mais de 10 anos, trabalha como freelancer criando sites, sistemas e portais utilizando
PHP, MySQL, CakePHP, WordPress e jQuery.
View all posts by Thiago Belem →
Post navigation ← PHP: As 10 melhores práticas pra um inicianteProgramação em par →
58 thoughts on “Relacionamento de Tabelas no MySQL”
1. Alvaro9 de julho de 2013 at 9:02
Grande cara, mais uma vez ajudando de maneira exemplar… Valeu fera, tirou 1 semana de trampo para fazer o sistema de carnês que estou finalizando…
2. RenanPro4 de julho de 2013 at 14:15
Eita… mais uma vez Thiago salvando minha vída, depois de horas pesquisando e não dava certo… agora saiu como eu queria! Parabéns de novo, estou aprendendo demaissss com seu blog!
3. jonalan de lima3 de julho de 2013 at 14:39
Como faço pra tirar um produto de uma tabela e colocar em outra tabela? transferir os dados de uma pra outra!
4. Michael25 de junho de 2013 at 12:59
amigos, alguém poderia me ajudar…
estou com um problema de SELECT com esse “inner join”
tenho a tabela “filiado” e a tabela “inscricoes”
eu consegui juntar as duas com o inner join mas preciso que mostre somente os resultados que entrariam no WHERE.. por exemplo
$query = mysql_query(“SELECT f.*, i.* FROM filiado f INNER JOIN inscricao i ON (f.id = i.id_filiado) WHERE f.faixa=‟$faixa‟ and i.d_peso=‟$pes and i.status=‟1′ ORDER BY i.id DESC”);
preciso do nome, da faixa, e do sexo, que está na tabela filiado e na inscrição preciso da categoria e do peso..
para mostrar somente as pessoas que tem essas opções do WHERE
e jogo no while para mostrar somente os benditos…
só que já mudei ali lá e não consegui…
creio eu que tenha alguma maneira de fazer, mas eu até o momento não consegui encontrar…
1. Global Ideias27 de junho de 2013 at 11:14
Como tá a estrutura das 2 tabelas?
5. Nuno Aleixo9 de junho de 2013 at 15:37
Muito bom tutorial. Sou iniciante na programação por isso não se riam da minha pergunta. Imaginemos que temos 2 tabelas mas em vez de fazer consulta, precisamos de inserir dados. Exemplo:
Tabelas Pais e tabela Filhos
CREATE TABLE `pais` ( `id` INT NOT NULL AUTO_INCREMENT PRIMARY KEY , `nome` VARCHAR( 255 ) NOT NULL, `morada` VARCHAR( 255 ) NOT NULL ) ENGINE = MYISAM;
CREATE TABLE `filhos` ( `id` INT NOT NULL AUTO_INCREMENT PRIMARY KEY , `pais_id` INT NOT NULL , `nome` VARCHAR( 255 ) NOT NULL , `morada` VARCHAR( 255 ) NOT NULL ) ENGINE = MYISAM;
Agora através de um formulario tensiono inserir os registos. Registo um pai, e através do mesmo registo posso registrar os dados do filho na tabela filhos. Como faço? Posso usar o INNER JOIN para INSERT? Como devo fazer para que o campo id_pais da tabela filhos receba o id da tabela pais?
Peço desculpa colocar a mesma questão, postei no sitio errado:S
Obrigado Thiago
1. Bryan Budelon Dorneles10 de junho de 2013 at 2:25
Olá amigo. Você pode usar a chave estrangeira.
Mais ou menos isso:
CREATE TABLE `filhos` ( `id` INT NOT NULL AUTO_INCREMENT PRIMARY KEY , `pais_id` INT NOT NULL , `nome` VARCHAR( 255 ) NOT NULL , `morada` VARCHAR( 255 ) NOT NULL, FOREIGN KEY(pais_id) REFERENCES pais(id) ON DELETE CASCADE ON UPDATE CASCADE); ) ENGINE = MYISAM;
Isso vai fazer com que pais_id fique associado com o id da tabela pais.
Aí poderás obter quem é filho de quem através do INNER JOIN, que Thiago posto.
Espero que tenha te ajudado. Se não conseguir, me pergunte ou me adicione no facebook.
Até mais!
1. Nuno Aleixo10 de junho de 2013 at 11:21
Ola Bryan, obrigado pela resposta. até aí consegui compreender, o que quero saber é no caso de querer fazer um INSERT, como é que adiciono os dados nas duas tabelas?? utilizo o mysql_insert_id()? Ou crio um link para o pai, pego o id do pai, armazeno numa variavel e faço a query será que tenho de fazer duas querys? ou também é possivel usar o INNER JOIN para o INSERT?
Não sei se estão a perceber o que quero dizer…
O objectivo é eu poder efectuar um registro de um pai e do seu filho, mas imagine que um pai pode ter varios filhos a estudar na mesma escola, durante uma inscrição posso registrar um pai e um filho. através de um formulario.
Espero que tenha explicado bem
Obrigado pela atenção
2. Bryan Budelon Dorneles10 de junho de 2013 at 14:24
Eu não sei como funciona seu sistema, mas se tiver alguma coisa de login e o pai é quem for cadastrar o filho, pode usar session. Que aí na hora de
cadastrar, ele pega o id da session da pessoa logada. Mas isso não se aplica se não for o pai quem irá fazer o cadastro.
3. Nuno Aleixo12 de junho de 2013 at 22:51
Exatamente, a pessoa que irá fazer o cadastro será um administrador, neste caso. E é aí que me perco….Não sei como o fazer. :S
4. Bryan Budelon Dorneles12 de junho de 2013 at 23:03
Cara, me adicione no facebook que lhe ajudo. Vai ser mais fácil e rápido!
5. Nuno Aleixo13 de junho de 2013 at 14:48
Oi ammigo, já o adicionei no meu facebook. Obrigado
2. Michael25 de junho de 2013 at 11:51
amigos, alguém poderia me ajudar…
estou com um problema de SELECT com esse “inner join”
tenho a tabela “filiado” e a tabela “inscricoes”
eu consegui juntar as duas com o inner join mas preciso que mostre somente os resultados que entrariam no WHERE.. por exemplo
$query = mysql_query(“SELECT f.*, i.* FROM filiado f INNER JOIN inscricao i ON (f.id = i.id_filiado) WHERE f.faixa=‟$faixa‟ and i.d_peso=‟$pes and i.status=‟1′ ORDER BY i.id DESC”);
preciso do nome, da faixa, e do sexo, que está na tabela filiado e na inscrição preciso da categoria e do peso..
para mostrar somente as pessoas que tem essas opções do WHERE
e jogo no while para mostrar somente os benditos…
só que já mudei ali lá e não consegui…
creio eu que tenha alguma maneira de fazer, mas eu até o momento não consegui encontrar…
3. Lincoln Coutinho5 de julho de 2013 at 16:54
Ou simplesmente você faz duas querys de INSERT, a do pai, e insere a do filho com um campo de ID do pai (chave estrangeira),
6. Fabio25 de maio de 2013 at 23:22
Thiago, tudo bem? O post é velho e me esclareceu sobre o INNER JOIN, porém não sei como aplicar ao que eu preciso. Direto ao ponto, usando um exemplo simples o que eu tenho é:
2 tabelas: usuarios e produtos usuarios possui “id”, “email” (tem outras coisas, mas é o que eu preciso pra isso) detalhes possui “id”, “id_usuario”, “dia”, “mes” Tenho vários detalhes por usuário.
Preciso listar o detalhe com o ID mais baixo dentre os IDs de cada usuário (por exemplo “nome”) desde que tenha “dia” = $d e “mes” = $m
1. Nuno Aleixo9 de junho de 2013 at 10:51
Muito bom tutorial. Sou iniciante na programação por isso não se riam da minha pergunta. Imaginemos que temos 2 tabelas mas em vez de fazer consulta, precisamos de inserir dados. Exemplo:
Tabelas Pais e tabela Filhos
CREATE TABLE `pais` ( `id` INT NOT NULL AUTO_INCREMENT PRIMARY KEY , `nome` VARCHAR( 255 ) NOT NULL, `morada` VARCHAR( 255 ) NOT NULL ) ENGINE = MYISAM;
CREATE TABLE `filhos` ( `id` INT NOT NULL AUTO_INCREMENT PRIMARY KEY , `pais_id` INT NOT NULL , `nome` VARCHAR( 255 ) NOT NULL , `morada` VARCHAR( 255 ) NOT NULL ) ENGINE = MYISAM;
Agora através de um formulario tensiono inserir os registos. Registo um pai, e através do mesmo registo posso registrar os dados do filho na tabela filhos. Como faço? Posso usar o INNER JOIN para INSERT? Como devo fazer para que o campo id_pais da tabela filhos receba o id da tabela pais?
7. Lúcio19 de abril de 2013 at 17:00
Thiago, gostei muito do seu post e conseguir buscar a relação entre as tabelas. Mas eu gostaria de saber se você tem algum post ensinando como inserir, editar e excluir referente á estas relações?
8. Darlecio Almeida18 de abril de 2013 at 21:06
Cara, gostei do resumo das consultas com JOIN muito bem explicado. parabéns!!
9. Edson Ferreira11 de novembro de 2011 at 17:00
Boa tarde Thiago, me de uma dica, eu to fazendo o site da empresa onde trabalho e estou tentado fazer um sistema onde o funcionario possa visualizar seu hollerith online, então criei duas tabelas uma com o cadastro do usuario e a outra para inserir os holleriths mas nao estou conseguindo chamar na pagina a visualização dos holleriths por funcionario, ou sai todos ou nao sai nenhum o que posso fazer?
10. Rodrigo21 de outubro de 2011 at 13:51
Ainda não percebi uma coisa, aquela ligação que vemos no motor de base de dados Access na qual mostra um para muitos não existe aqui em SQL pois não?
11. Fernando Carvalho26 de setembro de 2011 at 12:22
opa, muito boa a aula. estou com problemas para inserir os dados via insert into tambem em tabelas diferentes por meus forms, como faço?
Obrigado.
12. Eduardo9 de setembro de 2011 at 15:48
Olá Thiago!
Gostaria de tirar um duvida… no caso acima, como eu poderia inserir um novo produto (via php) já escolhendo a categoria pre existente? Por exemplo, tenho uma página onde crio a categoria “Bermudas”. Depois tenho outra página onde crio o produto, só que nessa página, teria um select para escolher a categoria. To tentando mas sem resultado…
Abs e excelente topico!
13. thiago9 de junho de 2011 at 17:16
ai chará, não tem nenhum tutorial sobre o relacionamento n:n ? to precisando dele (: se poder me ajudar, agradeço desde já
14. omor25 de abril de 2011 at 15:54
Olá Thiago blz? Tiago tenho 3 tabelas clientes, pedidos, itens_pedidos, estou querendo relacionar, no formulario itens_pedidos estou querendo que imprima, o nome do cliente e seus respectivos dados pessoais, os dados do pedido e o stauts do pedido.
minha estrutura do sql tabela itens_pedidos tá assim:
$sql = mysql_query(“SELECT * FROM itens_pedidos INNER JOIN clientes INNER JOIN pedidos ON clientes.id_cliente = pedidos.id_cliente and pedidos.id_cliente =itens_pedidos.id_cliente and clientes.id_cliente = itens_pedidos.id_cliente”); $linha = mysql_fetch_array($sql);
$id_pedido = $_GET['id_pedido']; $sql = mysql_query(“SELECT * FROM pedidos INNER JOIN itens_pedidos INNER JOIN clientes ON pedidos.id_pedido=itens_pedidos.id_pedido and pedidos.id_cliente = clientes.id_cliente”);
só que não está relacionando pois aparece os dados do cliente diferente do id_pedido, ou seja, aparece id_pedido de um cliente e o nome do cliente de outro. obrigado!
15. Jonathan22 de abril de 2011 at 21:16
Depois de procurar e muito pela web atrás de uma explicação sobre os relacionamentos de tabelas, e no meu caso é muito importante pois utilizo o ORM Doctrine, o seu blog foi o
único que me deu uma luz
Porém eu estou ainda com problemas para entender se um relacionamento entre uma tabela user e friends é 1:N ou N:N Um usuário pode ter Vários Amigos. Porém Muitos usuários podem ser amigos de vários Usuários. Confudiu :X
Dá uma luz aew o/
16. Fábio13 de fevereiro de 2011 at 15:50
Muito boa a dica, estava com umas duvidas aqui e me ajudou bastante.
17. Douglas Nogueira1 de fevereiro de 2011 at 16:48
eu sabia que existia uma forma correta de fazer isso, muito obrigado pelo post.
18. André Luiz Zilz28 de janeiro de 2011 at 14:34
Muito interessante seu artigo. Mas estou com uma dúvida cruel: Como faria se quisesse ter um produto com duas ou mais categorias?
1. Thiago BelemPost author29 de janeiro de 2011 at 11:13
Aí você precisa criar uma terceira tabela pra uma relação HABTM (Has And Belongs To Many)… Falarei sobre isso outro dia.
19. Fabio Gialorenço29 de novembro de 2010 at 17:05
Thiago… Minha duvida sobre relacionamento é a seguinte Voce criou duas tabelas MyIsam que na pratica não estão relacionadas, o relacionamento é feito via php? É isso?
Não existe a possibilidade da criação do fk e assim manter a integridade dos dados?
Tem alguma apostila que você poderia me indicar que trata desse assunto.Gostaria de me aprofundar
Abraços
20. Diego Vilela24 de novembro de 2010 at 17:28
Vendo isso aqui deu até vergonha de como eu fazia pesquisas desse tipo. Quem tá aprendendo quer logo desenvolver alguma coisa, aí acaba „esquecendo‟ de melhorar ;]
O blog tá nos meus favoritos aqui, parabéns.
21. J Barbosasilva19 de novembro de 2010 at 13:45
Gostei muito do seu trabalho neste blog, esta de parabens!!!!
22. Alex Torres27 de outubro de 2010 at 14:25
Cara, execelente o Codigo !!! era o que faltava para meus sistemas, eu vinha fazendo tudo consultas dentro do while.. Valeu mesmo,
23. Kadu17 de janeiro de 2010 at 10:42
Olá, fiquei na duvida de como colocar um LIMIT em somente um dos bancos na consulta… teria como? Valew
24. Edivan1 de janeiro de 2010 at 10:19
primeira vez que entro em um site que o dono se procupou em passar uma informação clara atrávés de texto, detalhe os outros podem yer a mesma ideia mais ainda ficou obscura pra min … porém nesse site clareou bastante. valeu mano vc tem uma mente aberta mesmo parabéms
25. João Paulo Rodrigues16 de dezembro de 2009 at 11:17
Parabéns, muito boa a explicação!
26. Alex10 de dezembro de 2009 at 16:55
parabens tiagão…ótimo tutorial…brother, e para inserir ?? ex: tenho tabela estado, cidade e bairro e quero cadastrar um novo bairro…mas q qdo eu informar o bairro e der um cadastrar, ele vai de acordo com o estado e cidade que eu escolhi…manda essa pra gente !!!
27. Gilmar Angelo9 de dezembro de 2009 at 2:41
Muito bom cara! Muito bom mesmo… ja adcionei nos favoritos.
28. Jackson Jorge19 de outubro de 2009 at 9:30
Olá Thiago, parabéns pelo artigo, está super explicado! Só tenho uma dúvida ou curiosidade que gostaria de tirar.
Normalmente esses relacionamentos mais simples como esse, eu fazia usando apenas o WHERE e sempre funcionou blz, isso muda alguma coisa com relação ao desempenho das consultas do mysql?
1. Thiago Belem19 de outubro de 2009 at 12:52
@Jackson Acredito que fazer com o JOIN seja mais correto já que o WHERE é pra filtrar os
resultados.
29. S-Bay15 de outubro de 2009 at 9:53
Hello tiago , parabens muito bom Estou aqui com uma duvida. Como é que eu poderia ver por exemplo só todas as camisetas?
30. Edvaldo da Rosa29 de setembro de 2009 at 12:33
Parabéns, seu blog é muito bom!
Sempre procurei algo desse tipo e sempre achei coisas complexas e estranhas. Você explicou tudo de forma bem clara.
31. Jardim15 de setembro de 2009 at 21:41
Muito bom mesmo Thiago ! Estou aprendendo ainda mas foi possível entender sim ! Já corri muito a net mas foi esse teu post que me fez entender ! E com relação ao uso de FK com com banco do tipo InnoDB, vc tem algum post que trata disso de forma tão clara quanto este aqui postado ?
Valeu !
32. Cida15 de setembro de 2009 at 18:05
Parabéns Thiago! Pela sua forma clara e pelo seu desprendimento em compartilhar o seu conhecimento.
Acredito nas pessoas inteligentes e seguras como você, sem medo de ser feliz…
Sucesso cada vez mais!
33. Rogerio11 de setembro de 2009 at 17:42
muito grato, ja uso mysql a algum tempo, mas de forma bem rustica, sempre que precisei usar selects maiores sempre faço dentro do while e while… mas essa sua dica foi muito boa. agradeço!
34. Seyfertt8 de setembro de 2009 at 4:14
Thiago, tudo bom? Tenho uma dúvida…
Estou fazendo relacionamento 1:1, só que tenho um pequeno problema… É impossível deixar 2 colunas em “auto increment”, sempre que adiciono um novo usuário no banco de dados o ID de usuário fica certo, porem o Config_ID, fica sempre em 0. Tem alguma idéia de como posso arrumar isso?
35. williams5 de setembro de 2009 at 20:21
Parabéns e continue assim /
36. Thiago Silva3 de setembro de 2009 at 0:33
Irmão, parabéns! vc tem uma metodologia de ensino muito boa. Relmente vc sabe ensinar de uma forma prática e objetiva. Tô entrando nessa área de desenvolvimento de websites e gosto muito dessa área. Já faz algum tempo q eu tava querendo aprender como acontece o relacionamente entre tabelas no mysql e o seu artigo tirou muitas dúvidas minhas. Sou técnico em informática na área de programação e não tive muitas aulas de programação web, mas tô aprendendo estudando sozinho… Ano q vem vou começar o curso superior de programação web. Parabéns pelos artigos. São excelentes. Um abraço.
37. Seyfertt28 de agosto de 2009 at 20:04
Ótimo artigo Thiago, agora sim entendo como fazer uma relação em tabelas.
Grande abraço
38. Robson Ramos Barreto26 de agosto de 2009 at 19:50
Thiago Parabéns, Agradeço pelos vários ótimos Post !!
Abraço
39. Thiago Machado26 de agosto de 2009 at 0:04
Parabéns pelo artigo muito bem explicado, sempre que possivel visitarei o blog.
40. Tulio21 de agosto de 2009 at 0:21
Parabéns pelo blog, todos os artigos são muito interessantes. Somente uma pergunta: Não seria interessante utilizar nos casos com integridade referencial Engine = InnoDB e definir uma chave estrangeira?
1. Thiago Belem21 de agosto de 2009 at 16:13
@Tulio Realmente existe essa parte de integridade referencial, mas eu acho que pra quem tá começando isso pode parecer muito complexo… Essas relações acabam obrigando o usuário a seguir uma ordem de raciocinio e ações caso eles queiram fazer alguma alteração direto no BD. Mas assim que possível falarei sobre. :]
41. Fillipe Moraes18 de agosto de 2009 at 23:53
Eu sempre usei (agora vejo que erroneamente) um while dentro de outro.. mas vejo que sempre cometi esse erro por não ter alguma boa explicação como essa.. entendi absolutamente tudo e achei mto fácil!
Agradeço e estou visitando seu blog pelo menos 3x por semana! Valeu!
42. Renato Reis17 de agosto de 2009 at 22:48
Muito bem explicado mesmo, gosto mto do JOIN, realmente torna as paradas mais legais, e a forma que você explica, não só mostrando o código, mas sim mostrando a gente como tudo funcionando (“ensinando a pescar e não dando o peixe”) acho muito interessante. Vou tentar executar mais esse português literal pra programação que ajuda bastante na hora de pensar. Parabéns!
43. Evandro17 de agosto de 2009 at 20:59
se vc tivesse postado isso no seu blog enqt eu tava tentando aprender o funcionamento de JOIN, com toda certeza não teria demorado 2h pra entender hehehehehehehe, parabéns pela iniciativa… excelente blog
44. Evandro17 de agosto de 2009 at 16:51
Thiago, um artigo melhor do que o outro.
PARABÉNS! TRABALHO FANTÁSTICO
45. André D. Molin15 de agosto de 2009 at 21:47
Muito bem explicado. Não tem quem não vá entender.
Valeu.
Pessoal ESTOU a tentar Fazer UMA Relação Entre Duas Colunas los Tabelas Diferentes, alguem Percebe o Opaco ESTOU uma Fazer de mal?
CREATE TABLE pat123 (
id int ( 11 ) NOT NULL AUTO_INCREMENT ,
Pat_Numb varchar ( 10 ) DEFAULT NULL ,
dados varchar ( 11 ) DEFAULT NULL ,
up_by varchar ( 45 ) DEFAULT NULL ,
PRIMARY KEY ( id ),
FOREIGN KEY ( Pat_Numb )
Referências visitas ( Pat_Numb ) delimitador $ $
) ENGINE = InnoDB PADRÃO CHARSET = utf8 $ $
Ja ágora Como Faço par relacionar Este campo com o MESMO EM 4 Tabelas? Obrigado
º 2 Prog
Farnel
Enterprise Search Specialist
5,142 mensagens
Postado 17 de Setembro de 2012 - 10:38
Qual a MENSAGEM de Erro? Pat_Numb dez Que servi fazer MESMO TIPO de e tamanho in TODAS como Tabelas.
º 3 razs
razs
511 mensagens
Postado 17 de Setembro de 2012 - 11:23
Este è o Erro, O Campo Pat_Numb E TODAS in Igual como Tabelas.
Citar
0 15:22:53 CREATE TABLE pat123 (id int (11) NOT NULL AUTO_INCREMENT, Pat_Numb varchar (10) NULL DEFAULT, dados varchar (11) NULL DEFAULT, up_by varchar (45) DEFAULT NULL, PRIMARY KEY (id), FOREIGN CHAVE (Pat_Numb) Referências Visitas (Pat_Numb),) código de erro: 1064. Você tem um erro em sua sintaxe SQL; verifique o manual que corresponde à sua versão do servidor MySQL para a sintaxe direita ao uso próximo ')' na linha 9
a Linha 9 e uma ultima ENGINE = InnoDB PADRÃO charset = utf8 $ $ Obrigado
Editado POR razs, 17 de Setembro de 2012 - 11:24.
º 4 Prog
Farnel
Enterprise Search Specialist
5,142 mensagens
Postado 17 de Setembro de 2012 - 11:29
No final, fazer Seu Comando HÁ UMA vírgula Que parece Que Localidade: Não Deveria Estar Los Angeles. FOREIGN KEY (Pat_Numb) Referências visitas (Pat_Numb) , )
º 5 razs
razs
511 mensagens
Postado 17 de Setembro de 2012 - 12:11
continua na MESMA: s
Citar
0 16:10:13 CREATE TABLE pat123 (id int (11) NOT NULL AUTO_INCREMENT, Pat_Numb varchar (10) NULL DEFAULT, dados varchar (11) NULL DEFAULT, up_by varchar (45) DEFAULT NULL, PRIMARY KEY (id), FOREIGN CHAVE (Pat_Numb) Referências Visitas (Pat_Numb)) ENGINE = InnoDB PADRÃO charset = utf8 Código de erro: 1005. Não é possível criar tabela 'corc2.pat123' (errno: 150)
º 6 Prog
Farnel
Enterprise Search Specialist
5,142 mensagens
Postado 17 de Setembro de 2012 - 00:21
MESMA Coisa Nao, Erros Diferentes. Suá Tabela visita EXISTE? Ja verificou se o Tipo e tamanho estao Iguais?
Citar
Se você recriar uma tabela que foi apagada, ela deve ter uma definição que está em conformidade com as restrições de chave estrangeira referenciando-lo. Ele deve ter os nomes das colunas certas e tipos, e deve ter os índices na chave referenciada como indicado anteriormente. Se estas medidas não forem satisfeitas, MySQL retorna erro de número 1005 e se refere ao erro 150 na mensagem de erro. Se o MySQL informa um erro de número 1005 de uma instrução CREATE TABLE, ea mensagem de erro refere-se ao erro 150, a criação da tabela falhou porque uma chave estrangeira restrição não foi formada corretamente. Da mesma forma, se uma ALTER TABLE falhar e se referir ao erro 150, o que significa uma definição de chave estrangeira foi formada incorretamente na tabela alterada. Para apresentar uma explicação detalhada sobre o mais recente InnoDB erro de chave estrangeira no servidor, questão Show de INNODB STATUS.
Fonte: http://dev.mysql.com...onstraints.html
# 7 razs
razs
511 mensagens
Postado 17 de Setembro de 2012 - 13:13
sim, o pat_numb ESTA Igual.
º 8 Motta
Motta
Motta
6,435 mensagens
Postado 17 de Setembro de 2012 - 14:14
Publica uma Descrição de visitas .
Editado POR Motta, 17 de Setembro de 2012 - 14:15.
# 9 razs
razs
511 mensagens
Postado 18 de Setembro de 2012 - 05:22
Aqui vao como Duas Tabelas
CREATE TABLE `pat` (
`id` int ( 11 ) NOT NULL AUTO_INCREMENT ,
`Pat_Numb` varchar ( 10 ) PADRÃO NULL ,
`data` varchar ( 11 ) PADRÃO NULL ,
`up_by` varchar ( 45 ) PADRÃO NULL ,
PRIMARY KEY ( `id` )
) ENGINE = InnoDB PADRÃO CHARSET = utf8 $ $
CREATE TABLE `visitas` (
`id` int ( 11 ) NOT NULL AUTO_INCREMENT ,
`visit_n` varchar ( 5 ) PADRÃO NULL ,
`arquivo` varchar ( 100 ) PADRÃO NULL ,
`exame` varchar ( 85 ) PADRÃO NULL ,
`Pat_Numb` varchar ( 10 ) DEFAULT NULL ,
`data` varchar ( 11 ) DEFAULT NULL ,
`up_by` varchar ( 45 ) PADRÃO NULL ,
PRIMARY KEY ( `id` )
) ENGINE = InnoDB PADRÃO CHARSET = utf8 $ $
º 10 Prog
Farnel
Enterprise Search Specialist
5,142 mensagens
Postado 18 de Setembro de 2012 - 08:40
Você. Quer CRIAR UMA chave Estrangeira Entre Campos Que Localidade: Não São chave?
º 11 razs
razs
511 mensagens
Postado 18 de Setembro de 2012 - 09:39
ESTOU perdido: s parágrafo Fazer uma Relação Os Dois campos TEM de serviços chave?
º 12 Motta
Motta
Motta
6,435 mensagens
Postado 18 de Setembro de 2012 - 10:08
Uma Chave Estrangeira da Tabela "Filha" aponta par uma chave primária da Tabela "mãe".
# 13 razs
razs
511 mensagens
Postado 18 de Setembro de 2012 - 10:30
entao tenho de Fazer Algo Tipo IstoÉ?
CREATE TABLE `pat` (
`id` int ( 11 ) NOT NULL AUTO_INCREMENT ,
`Pat_Numb` varchar ( 10 ) PADRÃO NULL ,
`data` varchar ( 11 ) PADRÃO NULL ,
`up_by` varchar ( 45 ) PADRÃO NULL ,
PRIMARY KEY ( `Pat_Numb` )
) ENGINE = InnoDB PADRÃO CHARSET = utf8 $ $
CREATE TABLE `visitas` (
`id` int ( 11 ) NOT NULL AUTO_INCREMENT ,
`visit_n` varchar ( 5 ) PADRÃO NULL ,
`arquivo` varchar ( 100 ) PADRÃO NULL ,
`exame` varchar ( 85 ) PADRÃO NULL ,
`Pat_Numb` varchar ( 10 ) DEFAULT NULL ,
`data` varchar ( 11 ) PADRÃO NULL ,
`up_by` varchar ( 45 ) PADRÃO NULL ,
PRIMARY KEY ( `id` )
FOREIGN KEY ( Pat_Numb )
Referências visitas ( Pat_Numb )
) ENGINE = InnoDB PADRÃO CHARSET = utf8 $ $
º 14 DiegoAngra07
DiegoAngra07
383 mensagens
Postado 18 de Setembro de 2012 - 11:26
Bom dia amigo, POR QUE VOCE NAO relaciona Ø ID da Tabela pat com hum Campo idPat nd Tabela visitas ? ASSIM:
CREATE TABLE `pat` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`Pat_Numb` varchar(10) DEFAULT NULL,
`data` varchar(11) DEFAULT NULL,
`up_by` varchar(45) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 $$
CREATE TABLE `visits` (
`id` int(11) NOT NULL AUTO_INCREMENT,
` visit_n` varchar(5) DEFAULT NULL,
`file` varchar(100) DEFAULT NULL,
`exam` varchar(85) DEFAULT NULL,
`idPat` int(11) DEFAULT NULL,
`data` varchar(11) DEFAULT NULL,
`up_by` varchar(45) DEFAULT NULL,
PRIMARY KEY (`id`)
FOREIGN KEY (idPat)
REFERENCES pat (id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 $$
Porqué se tu Fizer Como Disse, o id na tua Tabela pat Praticamente se tornará Inútil POIs elementos Localidade: Não Será, Mais PK. Tu Localidade: Não PODE Fazer ASSIM Como eu postei? E a forma Mais Comum, a gente relaciona como Tabelas Pelos IDs e DEPOIS tu PODE buscar o campo Que Quiser. Espero Que SEJA util, abraço.
º 15 razs
razs
511 mensagens
Postado 18 de Setembro de 2012 - 13:05
Obrigado, Vou experimentar. Abraço consegui parágrafos UMA VISITA mas Pará como OUTRAS nao consegui ...
CREATE TABLE `pat` (
`id` int ( 11 ) NOT NULL AUTO_INCREMENT ,
`idPat` varchar ( 10 ) PADRÃO NULL ,
`data` varchar ( 11 ) PADRÃO NULL ,
`up_by` varchar ( 45 ) PADRÃO NULL ,
PRIMARY KEY ( `idPat` )
) ENGINE = InnoDB PADRÃO CHARSET = utf8
CREATE TABLE `visitas` (
`id` int ( 11 ) NOT NULL AUTO_INCREMENT ,
`visit_n` varchar ( 5 ) PADRÃO NULL ,
`arquivo` varchar ( 100 ) PADRÃO NULL ,
`exame` varchar ( 85 ) PADRÃO NULL ,
`idPat` int ( 11 ) DEFAULT NULL ,
`data` varchar ( 11 ) DEFAULT NULL ,
`up_by` varchar ( 45 ) PADRÃO NULL ,
PRIMARY KEY ( `id` )
FOREIGN KEY ( idPat )
REFERÊNCIAS pat ( idPat )
) ENGINE = InnoDB PADRÃO CHARSET = utf8
CREATE TABLE `outubro` (
`id` int ( 11 ) NOT NULL AUTO_INCREMENT ,
`visit_n` varchar ( 5 ) PADRÃO NULL ,
`campo1` varchar ( 85 ) PADRÃO NULL ,
`campo2` varchar ( 85 ) PADRÃO NULL ,
`campo3` varchar ( 85 ) DEFAULT NULL ,
`field4` varchar ( 85 ) DEFAULT NULL ,
`idPat` int ( 11 ) PADRÃO NULL ,
`data` varchar ( 11 ) PADRÃO NULL ,
`up_by` varchar ( 45 ) DEFAULT NULL ,
PRIMARY KEY ( `id` )
FOREIGN KEY ( idPat )
REFERÊNCIAS pat ( idPat )
) ENGINE = InnoDB PADRÃO CHARSET = utf8
CREATE TABLE `mfERG` (
`id` int ( 11 ) NOT NULL AUTO_INCREMENT ,
`visit_n` varchar ( 5 ) PADRÃO NULL ,
`campo1` varchar ( 85 ) PADRÃO NULL ,
`campo2` varchar ( 85 ) PADRÃO NULL ,
`campo3` varchar ( 85 ) DEFAULT NULL ,
`field4` varchar ( 85 ) DEFAULT NULL ,
`idPat` int ( 11 ) PADRÃO NULL ,
`data` varchar ( 11 ) PADRÃO NULL ,
`up_by` varchar ( 45 ) DEFAULT NULL ,
PRIMARY KEY ( `id` )
FOREIGN KEY ( idPat )
REFERÊNCIAS pat ( idPat )
) ENGINE = InnoDB PADRÃO CHARSET = utf8
º 16 DiegoAngra07
DiegoAngra07
383 mensagens
Postado 18 de Setembro de 2012 - 14:18
Dá sândalo Erro de sintaxe? Eu so tinha copiado o Código Que tu postou Acima e mudei OS campos.
º 17 Prog
Farnel
Enterprise Search Specialist
5,142 mensagens
Postado 18 de Setembro de 2012 - 14:44
DEPOIS de PRIMARY KEY (`id`) DEVE Haver UMA vírgula.
Editado POR Prog, 18 de Setembro de 2012 - 14:44.
º 18 razs
razs
511 mensagens
Postado 19 de Setembro de 2012 - 06:24
continua na MESMA: s CADA Vez percebo Menos DISTO ...
º 19 Prog
Farnel
Enterprise Search Specialist
5,142 mensagens
Postado 19 de Setembro de 2012 - 08:27
O Diego JÁ questionou sobre a MENSAGEM de Erro, Ha alguma? Cara ... . Vou passar hum pente fino nenhum script Seu, mas ó, equacionaríamos-se hum privilegiado, Nao costumo dar ESSE Tipo de Ajuda Primeiro Problema:
Citar CREATE TABLE `pat` ( `id` int (11) NOT NULL AUTO_INCREMENT, `idPat` varchar (10) Padrão
NULL, ... PRIMARY KEY (`idPat`)
Se a Coluna idPat ESTA Marcada parágrafo Ser uma chave Primária, Você. Localidade: Não Precisa Mais da Coluna ID. Colunas com AUTO_INCREMENT São permitidas apenas los Chaves Primárias. No roteiro removedor final, Vou a Coluna idPat fazer roteiro ea Coluna id Será, uma chave Primária. Segundo Problema:
Citar
CREATE TABLE `mfERG` ( ... `idPat` int (11) DEFAULT NULL, ... PRIMARY KEY (`id`) , KEY (idPat) ESTRANGEIROS Referências
pat (idPat)
Sobre como vírgulas eu JÁ falei. Em TODAS como Tabelas Voce esta criando um parágrafo Referência a chave Estrangeira corretamente, SE VOCE NAO tivesse cometido Ø equívoco de colocar Diferentes tipos . Na Tabela patidPat E varchar . Pará Este Problema Vamos substituir uma Referência da chave Estrangeira POR id , POIs JÁ alteramos a Tabela pat . No final, de CADA comando, acrescente hum ponto-e-vírgula. Segue roteiro completo e correto:
CREATE TABLE `pat` (
`id` int ( 11 ) NOT NULL AUTO_INCREMENT ,
`data` varchar ( 11 ) PADRÃO NULL ,
`up_by` varchar ( 45 ) DEFAULT NULL ,
PRIMARY KEY ( `id` )
) ENGINE = InnoDB PADRÃO CHARSET = utf8 ;
CREATE TABLE `visitas` (
`id` int ( 11 ) NOT NULL AUTO_INCREMENT ,
`visit_n` varchar ( 5 ) PADRÃO NULL ,
`arquivo` varchar ( 100 ) PADRÃO NULL ,
`exame` varchar ( 85 ) PADRÃO NULL ,
`idPat` int ( 11 ) DEFAULT NULL ,
`data` varchar ( 11 ) DEFAULT NULL ,
`up_by` varchar ( 45 ) PADRÃO NULL ,
PRIMARY KEY ( `id` ),
FOREIGN KEY ( idPat )
REFERÊNCIAS pat ( id )
) ENGINE = InnoDB PADRÃO CHARSET = utf8 ;
CREATE TABLE `outubro` (
`id` int ( 11 ) NOT NULL AUTO_INCREMENT ,
`visit_n` varchar ( 5 ) PADRÃO NULL ,
`campo1` varchar ( 85 ) PADRÃO NULL ,
`campo2` varchar ( 85 ) PADRÃO NULL ,
`campo3` varchar ( 85 ) DEFAULT NULL ,
`field4` varchar ( 85 ) DEFAULT NULL ,
`idPat` int ( 11 ) PADRÃO NULL ,
`data` varchar ( 11 ) PADRÃO NULL ,
`up_by` varchar ( 45 ) DEFAULT NULL ,
PRIMARY KEY ( `id` ),
FOREIGN KEY ( idPat )
REFERÊNCIAS pat ( id )
) ENGINE = InnoDB PADRÃO CHARSET = utf8 ;
CREATE TABLE `mfERG` (
`id` int ( 11 ) NOT NULL AUTO_INCREMENT ,
`visit_n` varchar ( 5 ) PADRÃO NULL ,
`campo1` varchar ( 85 ) PADRÃO NULL ,
`campo2` varchar ( 85 ) PADRÃO NULL ,
`campo3` varchar ( 85 ) DEFAULT NULL ,
`field4` varchar ( 85 ) DEFAULT NULL ,
`idPat` int ( 11 ) PADRÃO NULL ,
`data` varchar ( 11 ) PADRÃO NULL ,
`up_by` varchar ( 45 ) DEFAULT NULL ,
PRIMARY KEY ( `id` ),
FOREIGN KEY ( idPat )
REFERÊNCIAS pat ( id )
) ENGINE = InnoDB PADRÃO CHARSET = utf8 ;
Paz e Bem!
Editado POR Prog, 19 de Setembro de 2012 - 08:55.
# 20 razs
razs
511 mensagens
Postado 19 de Setembro de 2012 - 09:27
Muito obrigado funcionou Bem. Diz assim UMA ultima Coisa parágrafo Fazer Mais Que UMA Relação basta replicar OS Comandos Certo CREATE TABLE `outubro` ( `id` int (11) NOT NULL AUTO_INCREMENT, `visit_n` varchar (5) PADRÃO NULL, `campo1 `varchar (85) DEFAULT NULL, `campo2` varchar (85) PADRÃO NULL, `campo3` varchar (85) PADRÃO NULL, `field4` varchar (85) PADRÃO NULL, `idPat` int (11) DEFAULT NULL, `data `varchar (11) DEFAULT NULL, `up_by` varchar (45) PADRÃO NULL, PRIMARY KEY (`id`), FOREIGN KEY (idPat) REFERÊNCIAS pat (id), FOREIGN KEY (visit_n)Referências visitas (visit_n) ) ENGINE = InnoDB PADRÃO charset = utf8;