DOCÊNCIA EM

SQL PARA O BANCO DE DADOS MySQL

SAÚDE
Copyright © Portal Educação

2012 – Portal Educação

Todos os direitos reservados

R: Sete de setembro, 1686 – Centro – CEP: 79002-130

Telematrículas e Teleatendimento: 0800 707 4520
Internacional: +55 (67) 3303-4520
1
atendimento@portaleducacao.com.br – Campo Grande-MS
Endereço Internet: http://www.portaleducacao.com.br

Dados Internacionais de Catalogação na Publicação - Brasil

Triagem Organização LTDA ME
Bibliotecário responsável: Rodrigo Pereira CRB 1/2167
Portal Educação

P842s SQL para o banco de dados MySQL / Portal Educação. - Campo Grande:
Portal Educação, 2012.

89p. : il.

Inclui bibliografia
ISBN 978-85-8241-563-4

1. Linguagem de programação. 2. SQL – Banco de Dados. 3. MySQL. I.

Portal Educação. II. Título.

CDD 005.74
 SUMÁRIO

1 CONCEITOS DE BANCOS DE DADOS RELACIONAIS ..........................................................4

2
1.1 O que são Banco de Dados .....................................................................................................4

2 INTEGRIDADE DOS DADOS ....................................................................................................5

3 BANCOS DE DADOS RELACIONAIS .......................................................................................7

4 OBJETO DO MATERIAL: MYSQL ............................................................................................9

5 A INTERFACE GRÁFICA phpMyAdmin ..................................................................................10

6 O QUE É SQL ...........................................................................................................................17

6.1 Como utilizar ............................................................................................................................17

6.2 Criando um banco de dados ..................................................................................................18

6.3 Criando uma tabela .................................................................................................................20

7 MODIFICANDO DADOS E COMPORTAMENTO .....................................................................25

7.1 Inserindo dados numa tabela .................................................................................................25

7.2 Atualizando dados de uma tabela ..........................................................................................28

7.3 Removendo dados de uma tabela ..........................................................................................31

7.3.1 Interface phpMyAdmin para remover os dados ....................................................................33

7.4 Removendo todos os dados da tabela ..................................................................................36

8 USO DE ÍNDICES .....................................................................................................................38

9 BUSCANDO DADOS ................................................................................................................41

9.1 Selecionando dados de uma tabela .......................................................................................41

9.2 A sintaxe nomeTabela.nomeCampo ......................................................................................42

9.3 A cláusula WHERE ..................................................................................................................45

9.4 Busca de padrão de caracteres ..............................................................................................46

9.5 Operadores lógicos: AND, OR, NOT ......................................................................................48

9.6 Operadores Relacionais..........................................................................................................50

10 JUNTANDO DADOS DE DUAS OU MAIS TABELAS ..............................................................52

11 USANDO A INTERFACE GRÁFICA PARA RODAR COMANDOS SELECT ..........................55

3
12 ORDENANDO O RESULTADO DE UMA CONSULTA ............................................................59

12.1 Agrupando dados de uma consulta .......................................................................................60

12.2 Trocando o nome de uma coluna no resultado ....................................................................61

12.3 Mostrando dados sem repetição ............................................................................................62

12.4 Funções de Agregação ...........................................................................................................62

13 TÓPICOS SELECIONADOS, VIEWS E TRIGGERS ................................................................66

13.1 O que é uma view e sua utilidade...........................................................................................66

13.1.1 Como definir uma view ..............................................................................................................66

13.1.2 Como utilizar um view................................................................................................................68

13.2 O que é e para que serve um trigger......................................................................................69

13.2.1 Definindo um trigger ..................................................................................................................69

13.3 Exportando sua base ..............................................................................................................71

13.3.1 Importando os dados de uma base ...........................................................................................74

13.3.2 Permissões de acesso...............................................................................................................77

REFERÊNCIAS ...................................................................................................................................83
1 CONCEITOS DE BANCOS DE DADOS RELACIONAIS

1.1 O que são Banco de Dados

4
Bancos de dados são entidades computacionais responsáveis por armazenar
informações para que elas não se percam com o tempo ou quando o computador é desligado.
Esses dados são armazenados num disco rígido, normalmente com uma alta capacidade para
que não existam problemas de falta de espaço.

Dessa forma, toda aplicação que de alguma forma precise manter algum tipo de
informação armazenada através do tempo e não possa fazer por meio de arquivos textos (por
uma série de limitações de crescimento, segurança e consistência) deve ter uma conexão com
banco de dados para que esse armazenamento, bem como a consulta aos dados, possa ocorrer.

Internamente, a estrutura utilizada pelos bancos de dados mais modernos utiliza

árvores B (uma estrutura extremamente complexa), em que o acesso a alguma informação não
seja demorada do ponto de vista do usuário, visto que recuperar informações de um disco-rígido
é muito mais demorado se comparado com a operação de acesso aos dados já na memória.
Não é necessário esse tipo de conhecimento, visto que as linguagens de acesso aos dados
escondem boa parte dessa implementação, deixando-o livre para pensar na solução do
problema em si.

Os bancos de dados são utilizados em muitas aplicações, abrangendo praticamente

todos os programas de computador, sendo o método de armazenamento preferencial para
aplicações com vários usuários simultâneos, nas quais é necessário haver coordenação entre
eles. Entretanto, são convenientes também para indivíduos, e muitos programas de correio
eletrônico e organizadores pessoais baseiam-se em tecnologias padronizadas de bancos de
dados.
2 INTEGRIDADE DOS DADOS

Para garantir que os dados sejam mantidos de forma consistente, as operações

executadas sobre os dados precisam seguir algumas regras, o que muitas vezes chama-se 5
transação, pois para garantir que os dados continuem a serem úteis, os comandos precisam ser
entendidos como únicos pelo sistema. A integridade de uma transação depende de quatro
propriedades, conhecidas como ACID.

Atomicidade: Todas as ações que compõem a unidade de trabalho da transação

devem ser concluídas com sucesso, para que seja efetivada. Se ocorrer qualquer ação que
constitui falha na unidade de trabalho a transação deve ser desfeita (rollback). Quando todas as
ações são efetuadas com sucesso, a transação pode ser efetivada (commit). Dessa forma, ainda
que uma série de operações seja feita para se chegar a um resultado comum, todas elas
precisam resultar em sucesso para que o processo inteiro termine. O exemplo mais direto dessa
situação é de uma transação bancária, em que tanto o saldo quanto a entrega do dinheiro
precisam ser efetuadas (duas operações separadas que equivalem a uma) para que seja
registrado um sucesso ou então nenhuma delas deve ser feita, sob o risco de se causar uma
inconsistência nos dados.

Consistência: Nenhuma operação do banco de dados de uma transação pode ser

parcial. O resultado de uma transação deve ser implementado na íntegra. Para comandos
independentes isso acaba nem sendo problema, mas quando se agrupa várias operações para
resultar num resultado único, cada uma das operações que compõe o todo devem ser operadas
corretamente.

Isolamento: Cada transação funciona completamente à parte de outras estações.

Todas as operações são parte de uma transação única. Nenhuma outra transação, operando no
mesmo sistema, pode interferir no funcionamento da transação corrente. Outras transações não
podem visualizar os resultados parciais das operações de uma transação em andamento.

Durabilidade: Significa que os resultados de uma transação são permanentes e

podem ser desfeitos somente por uma transação subseqüente. Por exemplo: todos os dados e
6
status relativos a uma transação devem ser armazenados num repositório permanente, não
sendo passíveis de falha de hardware.

Na prática, alguns SGBDs (Sistemas Gerenciados de Bancos de Dados) relaxam na

implementação de algumas destas propriedades buscando desempenho. A grande dificuldade é
encontrar o ponto de equilíbrio entre desempenho e resultados errados que possam
comprometer a aplicação como um todo.

Controle de concorrência é um método usado para garantir que as transações sejam

executadas de uma forma segura, e segue as regras ACID. Os SGBD devem ser capazes de
assegurar que nenhuma ação de transações completadas com sucesso seja perdida ao desfazer
transações abortadas.

Uma transação é uma unidade que preserva consistência. Requeremos, portanto, que
qualquer escalonamento produzido ao se processar um conjunto de transações
concorrentemente seja computacionalmente equivalente a um escalonamento produzindo e
executando essas transações serialmente em alguma ordem.
3 BANCOS DE DADOS RELACIONAIS

O conceito de bancos de dados relacionais está na forma em que eles são

implementados, que estabelece uma relação lógica entre os dados, para que a repetição de 7
dados (redundância) seja a menor possível, economizando espaço em disco e aumentando a
velocidade de consulta dos dados.

Um banco de dados relacional possui como entidade central tabelas, onde as colunas
armazenam os tipos de dados e as linhas um caso específico de dados, sendo chamada de tupla
ou registro. Também é importante o conceito de chave, que identifica unicamente um registro.

O modelo relacional é uma teoria matemática desenvolvida por Edgar Frank Codd para
descrever como as bases de dados devem funcionar. Embora esta teoria seja a base para o
software de bases de dados relacionais, poucos sistemas de gestão de bases de dados seguem
o modelo de forma restrita, e todos têm funcionalidades que violam a teoria, desta forma
variando a complexidade e o poder. A discussão se esses bancos de dados merecem ser
chamados de relacional ficou esgotada com o tempo, com a evolução dos bancos existentes.

De acordo com a arquitetura ANSI/SPARC em três níveis, os Bancos de Dados

Relacionais consistem de três componentes:

 Tabelas: uma coleção de estruturas de dados, formalmente chamadas de relações, ou

informalmente tabelas, compondo o nível conceitual;

 Operações: uma coleção dos operadores, a álgebra e o cálculo relacionais, que

constituem a base da linguagem SQL;

 Chaves: uma coleção de restrições da integridade, definindo o conjunto consistente de

estados de base de dados e de alterações de estados.
 As bases de dados relacionais permitem aos utilizadores (incluindo programadores)
escreverem consultas, reorganizando e utilizando os dados de forma flexível e não
necessariamente antecipada pelos projetistas originais. Esta flexibilidade é especialmente
importante em bases de dados que podem ser utilizadas durante décadas, tornando as bases de
dados relacionais muito populares no meio comercial.

Um dos pontos fortes do modelo relacional de banco de dados é a possibilidade de 8

definição de um conjunto de restrições de integridade. Estas definem os conjuntos de estados e
mudanças de estados consistentes do banco de dados, determinando os valores que podem e
os que não podem ser armazenados.

Bancos de Dados existentes

Existem muitos bancos de dados sendo utilizados atualmente, porém, segundo uma
visão de mercado, eles podem ser divididos em dois grandes grupos:

 Os comerciais, que cobram um valor de licença para serem usados;

 Os livres, que possuem distribuição livre, inclusive do código fonte, não implicando em
nenhum custo adicional.

Dentre os bancos de dados comerciais, três possuem um destaque maior devido a sua
relevância: o Oracle, que é um dos mais famosos do mundo, sendo indicado principalmente para
aplicações médias e grandes, onde a possibilidade de crescimento é muito importante; o
Microsoft SQLServer, que vêm ganhando importância; e o DB2 da IBM, que começa a ganhar
destaque.

Nos bancos de dados de distribuição livre se destacam o MySQL, uma das primeiras
iniciativas na área, que possui um grande alcance no mercado e vem evoluindo a cada ano, e o
PostGreSQL, que pode ser utilizado desde aplicações pequenas até médias, com uma série de
recursos que permite um crescimento razoável para soluções que a adotam.
4 OBJETO DO MATERIAL: MYSQL

O MySQL é um sistema de gerenciamento de banco de dados (SGBD), que utiliza a

linguagem SQL (Structured Query Language - Linguagem de Consulta Estruturada) como 9
interface de acesso aos seus dados. É atualmente um dos bancos de dados mais populares,
com mais de 10 milhões de instalações pelo mundo.

O MySQL foi criado na Suécia por dois suecos e um finlandês, que têm trabalhado
juntos desde a década de 1980. Hoje seu desenvolvimento e manutenção empregam
aproximadamente 70 profissionais no mundo inteiro, e mais de mil contribuem testando o
software, integrando-o a outros produtos, e escrevendo a respeito dele.

No dia 16 de Janeiro de 2008, a MySQL AB, desenvolvedora do MySQL foi adquirida

pela Sun Microsystems, por US$ 1 bilhão, um preço jamais visto no setor das licenças livres. O
sucesso do MySQL deve-se em grande medida à fácil integração com o PHP incluído, quase
que obrigatoriamente, nos pacotes de hospedagem de sites da Internet oferecidos atualmente.
5 A INTERFACE GRÁFICA phpMyAdmin

Existem diversas formas de se trabalhar com os bancos de dados atuais, no que toca o
acesso às suas funcionalidades, iniciando desde interfaces texto, próximas dos terminais 10
existentes nos primeiros micros (e que ainda são tão poderosas e presentes em sistemas Linux),
passando por interfaces cliente, onde é necessário instalar algum tipo de cliente localmente
(como por exemplo, o Squirrel) ou ainda ferramentas de acesso remoto baseadas na web, cujo
maior expoente para o MySQL é o chamado phpMyAdmin.

O phpMyAdmin é uma ferramenta livre, escrita na tecnologia PHP, e que é acessada

através de um navegador web, como o Microsoft Internet Explorer ou o Mozilla Firefox. Ele pode
ser instalado tanto localmente quanto num servidor remoto para ser acessado através da
Internet. O que o torna tão famoso é a sua facilidade de uso e distribuição em conjunto com
versões de instaladores para se trabalhar com a tecnologia PHP, como o EasyPHP ou o
XAMPP.

Para os interessados em trabalhar com o banco MySQL e que não estão interessados
em perder muito tempo instalando os componentes individualmente, recomenda-se escolher um
dos instaladores para que ele forneça a infra-estrutura mínima. Ao final deste módulo seguem
alguns links para que as ferramentas possam ser baixadas e instaladas. Neste documento, será
utilizada a versão disponível pelo XAMPP, mas qualquer outra distribuição pode ser utilizada.
Numa instalação padrão, deve-se acessar o ambiente através do seguinte endereço:
http://localhost/phpmyadmin/

Ao entrar no endereço acima, chega-se a uma tela parecida com a seguinte:

 11

Na parte da esquerda são mostrados eventuais bancos de dados instalados nesse

gerenciador, bem como as tabelas de algum banco selecionado para detalhamento. Na parte da
direita, são exibidas as informações de configuração do ambiente e operações de suporte e
manutenção do ambiente. Na prática, essa é apenas uma interface gráfica para facilitar o acesso
ao banco, sem que sejam necessários grandes conhecimentos de linha e comando.
 12

Uma vez selecionada alguma instância de banco de dados, todas as tabelas existentes
dentro dele serão listados no menu da esquerda. Escolher outro valor implica em atualizar o
valor, trocando as tabelas exibidas naquele momento. A parte da direita, por sua vez, é alterada
trazendo mais informações de cada tabela e operações gerais que podem ser feitas sobre os
dados de cada tabela. Dentre as possibilidades, vale destacar os diversos comandos que podem
ser realizados sobre as estruturas, como remoção e alteração, comandos esses que só vêm
servir de intermediários para os reais comandos, que continuam sendo escritos em SQL
(maiores informações a seguir).
 13

Ao clicar em alguma das tabelas que apareceram na parte da esquerda, chega-se à

seguinte tela, onde são mostrados detalhes da tabela selecionada, como quais colunas são
usadas na sua definição, restrições de chaves, índices e operações em geral, que vão desde o
manuseio dos dados até a modificação da estrutura da tabela, seja alterando as suas definições,
seja removendo uma coluna (e todos os seus dados) dela.

Neste ponto já deve estar claro que a unidade básica de qualquer banco de dados
relacional é a tabela, sendo que o conjunto de tabelas (com suas definições de colunas e
chaves) define o chamado modelo relacional, que traz o mapeamento das diversas entidades do
sistema para um plano estrutural, permitindo que as informações possam ser guardadas em
forma tabular e recuperadas através de linguagens próprias para isso, como o próprio SQL que
será visto no próximo tópico.
 14

Uma tela particularmente importante para o restante do material é aquela aberta ao se

clicar na aba SQL, no topo da página de uma determinada tabela. É dentro desse campo (cuja
interface pode variar de versão para versão) que os comandos de acesso aos dados serão
digitados e executados. Uma vez que o comando tenha sido digitado, ao apertar o botão
Executar (ou o equivalente em outras versões) o processo de busca é disparado e o resultado
mostrado em seguida (caso a consulta tenha sido construída corretamente e não possua
nenhum tipo de erro de sintaxe).

Essa interface fica próxima da encontrada em outras interfaces de acesso ao

ambiente, a única diferença é que através desse ponto que se pode acessar ao banco MySQL
que essa configuração aponta. O resultado encontrado ficaria próximo do seguinte:
 15

No resultado, além do comando executado, é mostrada uma lista (ou tabela) com todos
os dados encontrados na busca, caso isso se aplique numa consulta. Esses dados são
mostrados de forma paginada, de tal forma que a navegação seja facilitada. Pode-se realizar
operações nos dados, como uma eventual consulta adicional ou mesmo a sua remoção, de
forma mais segura e controlada, se comparada com outras possibilidades, como a remoção
direta feita através de um comando Delete (que será visto em instantes).
 16

Caso um erro no comando seja encontrado, será mostrada uma tela como a de cima,
indicando o erro e a provável linha em que o comando falhou. Além dos tradicionais erros de
sintaxe (palavras reservadas escritas erradas ou fora do lugar), os erros podem ser ocasionados
pela inexistência de uma coluna ou a utilização errada de um determinado label para consulta
naquele momento. Ao clicar no item Voltar, pode-se corrigir a consulta e executar novamente.
Um erro muito mais difícil de encontrar e também corrigir, é aquele relacionado ao desempenho
de uma consulta, pois operações no banco de dados são sempre caras de desempenho por
fazerem acesso ao disco.
6 O QUE É SQL

A sigla SQL significa “Structured Query Language”, ou seja, Linguagem Estruturada de

Consulta. Ela foi a forma encontrada para que a comunicação com um banco de dados pudesse 17
ser feita de uma maneira descomplicada, ágil e que pudesse ser facilmente entendida e
aprendida pelos desenvolvedores. Seus comandos permitem a escrita de códigos que criam
novas estruturas (tabelas, visões, restrições, índices), permitem a inserção e modificações de
dados e a sua posterior consulta. Na geração de relatórios, o último item, de consulta de dados,
acaba sendo o mais importante e utilizado, com uma grande quantidade de variações.

Ela possui uma sintaxe padrão que é implementada pela maioria dos bancos de dados,
porém cada banco de dados a aumenta da maneira que lhe é mais interessante ou que forneça
um maior número de recursos para os usuários, o que leva à situação de não ser tão fácil mudar
de um banco de dados para outro (portabilidade), principalmente por causa de detalhes ou
funções pré-definidas.

Na parte de acesso aos dados, pode-se resumir as operações em quatro: Inserção

(INSERT), Atualização (UPDATE), Remoção (DELETE) e Consulta (SELECT). Vale destacar
que ainda que durante o material sejam utilizadas palavras em maiúsculas para os comandos
SQL, a maioria dos bancos de dados (inclusive o MySQL) não fazem distinção entre elas,
podendo ser usadas da maneira que melhor se adéqüem ao projeto em questão.

6.1 Como utilizar

 Cada linguagem de programação implementa isso de uma forma específica, mas todas
elas possuem alguns pontos semelhantes. De modo geral, os passos a seguir são comuns,
todos implementados dentro da própria aplicação:

 O comando SQL é escrito como uma cadeia de caracteres da linguagem e armazenado

numa variável;
 Uma conexão com o banco de dados da aplicação é criada (através de uma rede local 18
ou da Internet) e a referência fica armazenada numa outra variável;
 A variável de conexão deve possuir alguma função que dado um comando SQL (que
neste momento está armazenado numa variável) o manda para o banco e fica
esperando o resultado;
 Uma terceira variável recebe o resultado da consulta, sendo que essas informações
podem ser trabalhadas da maneira que a aplicação quiser/puder para se exibir ou então
realizar alguma computação;
 Ao final do processo, é interessante finalizar a conexão com o banco de dados, que
normalmente não está no mesmo computador que executou a operação.

Vale destacar ainda que todas essas operações que foram descritas como sendo
realizadas de dentro de uma aplicação, podem ser realizadas diretamente de um terminal que
forneça acesso ao banco de dados. No nosso exemplo, esses comandos serão executados a
partir do phpMyAdmin, que fará as vezes de aplicação, servindo como “casca” para acesso ao
banco de dados desejado.

6.2 Criando um banco de dados

Existem duas formas de se criar um banco de dados, diretamente do terminal ou então

de dentro de outro banco de dados já existente, sendo em seguida necessário se conectar ao
outro banco de dados. Utilizaremos como exemplo para o primeiro caso um banco de dados
MySQL, mas funções similares são fornecidas para outros bancos.

CREATE DATABASE teste

19

No segundo caso, de dentro de algum banco de dados já criado e que se tem acesso,
o seguinte comando deveria ser escrito:

CREATE DATABASE “bdCurso” WITH ENCODING = ‘LATIN1’

Vale destacar ainda que a sintaxe do SQL não faz diferenciação entre maiúsculas e
minúsculas, sendo o seu uso indiscriminado.

Tipos de dados

Da mesma forma que em outras linguagens de programação existe a definição de tipos

de dados em SQL, e a sua obrigatoriedade de definição durante o momento em que o banco de
dados está sendo criado, da mesma forma, caso o sistema tente inserir um dado incompatível
numa determinada coluna, o banco de dados deverá retornar uma mensagem de erro.

A SQL padrão possui um grupo de dados básico e cada banco de dados implementa
uma série de variações delas, para permitir uma maior flexibilidade para o usuário. Tomando
novamente como exemplo o caso do PostGreSQL, os tipos de dados existentes mais comuns
são:
 Tipo de Dado Descrição

BIGINT Inteiro com precisão de 8 bytes

BOOLEAN Valor de verdadeiro ou falso

VARCHAR(n) Cadeia de caracteres de tamanho variável

CHAR(n) Cadeia de caracteres de tamanho fixo

20
DATE Data

INTEGER Inteiro com 4 bytes

DECIMAL (p, s) Ponto flutuante de precisão variável

REAL Ponto flutuante de precisão simples

SMALLINT Inteiro com precisão de 2 bytes

SERIAL Inteiro auto-incremental

TEXT Cadeia de caracteres de tamanho variável

TIME Hora

TIMESTAMP Data e hora

6.3 Criando uma tabela

Como já mencionado, uma tabela é um dos conceitos mais importantes existentes no

modelo de banco de dados relacional. São nas tabelas que os dados são armazenados e
acessados por diferentes aplicações que precisam ter informações a respeito delas.
Normalmente, as tabelas são definidas inicialmente no projeto, antes que existam dados. Uma
tabela pode ser criada como:
CREATE TABLE pessoa

CPF VARCHAR (12) NOT NULL,

Nome VARCHAR (80) NOT NULL,

Nascimento DATE, 21

Altura REAL,

Filhos INTEGER,

PRIMARY KEY (cpf)

Neste exemplo, é criada uma tabela que representa uma pessoa, com alguns atributos
que fazem referência aos dados de uma pessoa. O item de chave primária será explicado
abaixo, mas indica que o atributo não poderá ser repetido em nenhum outro registro desta
tabela, caso contrário um erro será devolvido e por fim, o modificador NOT NULL, indica que
esses campos são de preenchimento obrigatório.

Ao se executar esse comando, uma tabela sem dados com essa definição é criada e
está pronta para receber dados, ou seja, pronta para inserir novas pessoas no cadastro.

Definindo campos

Para cada atributo (que no modelo relaciona, chama-se coluna) que deverá existir
numa tabela, deve-se dar um nome, um tipo e opcionalmente um modificador, como por
exemplo, que esse atributo criado não possa ser vazio quando for inserido algum dado. Não é
interessante que esses campos tenham um nome muito grande, pois dificulta a sua posterior
utilização.

Essas colunas é que irão armazenar os dados, informações a serem manuseadas,

posteriormente, pelas aplicações. Uma boa definição dessas colunas, seus tipos e eventuais
restrições traz uma grande quantidade de informações para o modelo, ajudando no
entendimento do problema como um todo. Eventuais modificações nessas colunas podem ser 22
feitas posteriormente, através de comandos que alteram a estrutura das tabelas, mas correndo o
risco de alterar os dados de forma permanente (removendo uma coluna, por exemplo) ou com
um custo de processamento muito grande (alterar uma coluna de uma tabela com uma
quantidade muito grande de registros, necessitando a atualização de todos eles).

Chave primária

Chave primária é um conceito muito importante que está diretamente ligado à

possibilidade de se consultar dados de tabelas do banco de dados. Uma chave primária é um
atributo ou conjunto de atributos que identifica unicamente um registro na tabela e que por isso
não pode ser repetido, pois caso contrário não teria como diferenciar um registro de outro
quando fossemos consultá-los.

Podemos definir um atributo como sendo chave primária explicitamente, ou seja,

incluímos um campo contador que é incrementado em um a cada novo registro inserido ou então
algum atributo que temos certeza que identifica unicamente um registro, como o número do CPF
num cadastro de pessoa.

CREATE TABLE produto

Código INTEGER NOT NULL auto_increment,

Descrição VARCHAR (80) NOT NULL,

 PRIMARY KEY (código)

No exemplo, foi criada uma tabela para armazenar informações de produtos, cujo
campo chave é do tipo inteiro, não pode armazenar valores vazios e possui um valor interno que
permite ir incrementando o valor do próximo registro baseado no último que já foi colocado.
23

Chave estrangeira

Muitas vezes desejamos dividir os dados de uma tabela em várias outras para que não
aconteça a duplicação de dados no sistema, e uma maneira de se fazer isso é utilizando chaves
estrangeiras. Por exemplo, imagine que uma pessoa possa ter de um a três números de
telefone, mas só gostaríamos de colocar um atributo telefone na tabela principal, pessoa.

Se quiséssemos inserir mais de um número de telefone, teríamos que ou separar os

diferentes números por algum caractere especial, como vírgulas ou então inserir novos registros
mudando apenas o número de telefone, só que para isso teríamos que definir a chave primária
da tabela como sendo o CPF e o número do telefone, pois poderiam ocorrer telefones diferentes
com o mesmo número de CPF.

Uma solução para este caso é manter a tabela pessoa como ela está e criar uma nova
tabela, chamada telefones, como segue:

CREATE TABLE telefones

CPF VARCHAR (12),

Telefone VARCHAR (10)

PRIMARY KEY (CPF, telefone),

 FOREIGN KEY (CPF) REFERENCES pessoa

Neste exemplo, o conjunto CPF e telefone compõe a chave primária da tabela,

portanto não podem se repetir e a chave estrangeira é o CPF, que indica que deve existir um
número de CPF na outra tabela, pessoa, antes de inserir um registro nesta tabela. Para alguns
tipos de computação são necessárias consultas muito rápidas e esse tipo de modelagem é muito
importante, sendo o processo realizado ao se dividir informações entre tabelas de normalização. 24
Como extrair dados de tabelas modeladas usando esse padrão será visto durante a parte de
SELECT.
7 MODIFICANDO DADOS E COMPORTAMENTO

7.1 Inserindo dados numa tabela

25

A inserção de dados numa tabela é uma das operações mais simples e importantes
que podem ser realizadas utilizando a SQL. É através dela que uma tabela pode ser populada
com novas informações para posterior acesso através de relatórios. Em geral, essas
informações serão preenchidas a partir de um formulário disponível ao usuário através de
alguma aplicação.

Uma vez que o usuário tenha digitado os dados nos respectivos campos, um botão de
confirmação é disparado, e os dados ali digitados devem ser traduzidos em código SQL antes de
serem enviados ao banco de dados para interpretação e execução. Uma vez que o comando
tenha sido executado com sucesso, uma nova linha na tabela estará inserida.

Alguns pontos merecem destaque neste comando: deve-se declarar qual a tabela em
que estão sendo inseridos os dados, bem como a ordem em que os atributos serão colocados (a
parte dos atributos é opcional, mas se não for colocada a ordem dos dados deve seguir a ordem
dos campos na tabela). Em seguida vêm os dados propriamente ditos, sendo que caracteres
devem vir entre aspas, o formato de data é Ano-Mês-Dia e o valor decimal utiliza ponto e não
vírgula. Além disso, todos os valores são separados por vírgula.

Nesse exemplo, o nome das colunas está explícito, o que permitiria que a ordem em
que os dados são inseridos fosse alterada conforme o desejo ou necessidade. Assim, eventuais
campos cujo preenchimento não é obrigatório poderiam ser omitidos ou ainda os valores padrão
poderiam ser adotados, como é o caso dos campos chave-primária com auto-incremento, que
quando omitidos pegam o último valor inserido acrescido de um.
 Ainda em relação aos campos de auto-incremento (normalmente utilizados como
chave-primária), eles devem ser definidos diretamente na definição da tabela, indicando qual a
coluna que deverá ter esse tipo de comportamento:

CREATE TABLE produto

26

id INTEGER NOT NULL auto_increment,

nome_produto VARCHAR(80) NOT NULL,

PRIMARY KEY (id)

No exemplo, foi criada uma tabela chamada produto, cujo campo chave-primária é o id,
do tipo inteiro, que não aceita valores NULL (chaves-primárias, por definição, não podem ter
valores vazios) e mais o modificador auto_increment, que indica que essa coluna poderá ser
incrementada automaticamente. Na prática, não será inserido qualquer valor nessa coluna,
fazendo com que o valor seja inserido conforme o último que já o fora.
 27

A partir da interface do phpMyAdmin, depois de escolhida alguma instância de banco

de dados e em seguida uma tabela dentro dessa instância, nas abas superiores da parte da
direita, aparecem os vários comandos que podem ser executados. Um desses comandos é o de
inserção. Ao clicar nesse item, chega-se à próxima imagem.

Os valores podem ser inseridos diretamente nos respectivos campos e depois, ao final,
apertado o botão executar. Esse botão irá montar os dados conforme os comandos
demonstrados anteriormente e em seguida executar o comando no Sistema Gerenciador de
Banco de Dados. Existe ainda a opção de retornar para inserir um novo registro ou retornar para
a tela de entrada, para que uma nova opção possa ser feita. Essa possibilidade é especialmente
importante, pois dá uma visão gráfica dos comandos e evita que erros e inconsistências sejam
inseridos em alguma tabela.
7.2 Atualizando dados de uma tabela

Existem situações em que é desejado que um registro já inserido seja atualizado, com
alguns de seus valores modificados. Para esta situação existe o operador UPDATE, que atualiza 28
um determinado registro ou grupo de registros de uma tabela. É importante ressaltar que esta
operação irá atuar em todos os registros caso nenhuma restrição usando WHERE seja definida.
Assim, se quisermos modificar o número de filhos de todas as pessoas para 1, escreveríamos:

UPDATE pessoa SET filhos = 1;

Agora, se quiséssemos que apenas aqueles que tenham um determinado CPF

tivessem o número de filhos modificados, escreveríamos:

UPDATE pessoa SET filhos = 1 WHERE cpf = ‘123456789012’;

Neste exemplo, apenas um registro será modificado, pois estamos utilizando uma
chave-primária para restringir os registros que serão modificados. Maiores informações de como
montar uma cláusula WHERE serão dadas em breve, quando a parte de SELECT for discutida,
uma vez que o comportamento é mesmo em todos esses casos.

Pode-se atualizar mais de uma coluna por vez dentro do mesmo UPDATE, bastando
para isso separar as colunas com os novos valores usando vírgula (atenção para não confundir
com o uso do operador lógico AND que será discutido durante a parte do SELECT).

Exemplo: UPDATE pessoa SET filhos = 1, idade = 23 WHERE cpf = ‘123’;

 No exemplo, tanto a coluna filhos quanto a coluna idade da linha cujo CPF seja 123
serão alteradas para os novos valores definidos no comando. Reforçando, o comando alterará o
valor de todas as linhas que satisfizerem à condição, de zero até todas. A não colocação da
restrição fará com que todas as linhas sejam modificadas. Ao se restringir usando uma chave-
primária, garante-se que apenas um registro (ou eventualmente nenhum, caso ele não exista)
será modificado pelo comando como um todo, limitando eventuais erros e problemas que o
29
comando possa vir a executar.

Exemplo: UPDATE pessoa SET filhos = filhos + 1 WHERE cpf = ‘123’;

Por fim, pode-se montar o comando tomando como base os valores originais da
coluna, como no exemplo acima, em que o novo valor da coluna filhos foi definido tendo como
base o valor antigo e somado de 1.

Em geral, sempre que algum registro é modificado, ele é colocado no final da tabela,
mas não se pode usar esse comportamento como garantia de que o registro estará lá. Para
forçar e ter certeza de onde os dados serão colocados deve-se usar uma cláusula ORDER BY
(explicadas em detalhes em seguida) para indicar qual a ordem dos dados de saída. Outro ponto
de destaque está que apenas uma tabela por vez pode ter os seus dados alterados, não sendo
possível juntar as alterações de duas ou mais tabelas num mesmo comando.

Buscando dados para alteração no phpMyAdmin

Antes de se alterar um registro através da interface fornecida e sem usar os comandos

apresentados anteriormente, de atualização, deve-se fazer uma busca pelos dados já existentes.
Como a parte de SELECT ainda não foi vista (e ela é fundamental na busca, seja direta, seja via
sistemas), é preciso de alguma forma acessar a parte dos dados já inseridos, para passar a
posterior alteração dos dados.
 30

Ao clicar no item Visualizar, todos os dados da tabela anteriormente selecionada serão

exibidos, facilitando a busca, sem maiores filtros ou parâmetros de entrada.
 31

Os dados serão mostrados numa tabela (que é a representação mais natural desse
conjunto de dados) com todas as colunas que a compõe e com algumas colunas adicionais no
início delas, indicando operações que podem ser realizadas com os registros. Para alterar uma
única linha, clica-se no ícone de um lápis, o que leva à seguinte página.

Repare que agora os campos estão todos preenchidos, com os valores originais já
existentes em cada coluna da tabela. Ao clicar em executar um comando UPDATE é montado e
executado no sistema, atualizando a informação. De novo, essa é apenas uma facilidade no
manuseio dos comandos. Durante a implementação desse código em aplicações, é necessário o
conhecimento desses comandos para que eles possam ser inseridos corretamente no código e
possam se comportar da maneira desejada.

7.3 Removendo dados de uma tabela

A sintaxe para a remoção de registros de uma tabela é muito parecida com a

atualização de dados da tabela, a diferença está que o registro será removido definitivamente do
sistema. Daí é de extrema importância a utilização da cláusula WHERE, caso contrário, todos os
registros da tabela serão apagados, o que pode ser desastroso para uma aplicação. A sintaxe
básica é:

DELETE FROM pessoa;

32

Nesse comando, todos os registros da tabela pessoa seriam removidos, o que

dificilmente é interessante para uma aplicação real (a menos de alguma reinicialização do
sistema). O seguinte comando é bem mais útil:

DELETE FROM pessoa WHERE cpf = ‘123456789012’;

Nesse caso, apenas o registro que tenha como CPF o valor especificado seria
removido da tabela. Operações desse tipo, baseadas em chave-primária, são muito mais
seguras, pois garantem que zero ou no máximo um registro será removido (pela própria
definição de chave-primária, que só permite a existência de uma por tabela), limitando eventuais
erros de digitação. Essa outra consulta poderia ser utilizada para remover determinados registros
da tabela telefones:

DELETE FROM telefones WHERE cpf = ‘123456789012’;

Como na tabela de telefones podem existir mais de um telefone para o mesmo CPF,
vários registros podem ser removidos com o mesmo comando. Um item importante para
ressaltar com esse comando é a importância de manter a consistência dos dados, ou seja, não
podem ser mantidos numa tabela dados de chave-estrangeira se os dados da chave-primária
correspondente na tabela inicial tenham sido removidos, causando um erro na consulta.
Idealmente, deve-se primeiro remover os dados das tabelas filhas para só depois remover os
dados da tabela onde a chave-primária foi definida.

Outro ponto importante seria adotar o conceito de transação, quer dizer, todos os
comandos de remoção deveriam ser executados com sucesso para que a operação resultasse
em sucesso, mas se ao menos um dos comandos desse erro, todo o processo seria abortado e
o estado original dos dados deveria ser remontado, mantendo assim a sua consistência. 33

Maiores informações de como montar uma cláusula WHERE serão dadas em breve,
quando a parte de SELECT for discutida, uma vez que o comportamento é mesmo em todos
esses casos. Outro ponto de destaque está que apenas uma tabela por vez pode ter os seus
dados removidos, não sendo possível juntar as remoções de duas ou mais tabelas num mesmo
comando.

7.3.1 Interface phpMyAdmin para remover os dados

Com a interface do phpMyAdmin, pode-se da mesma forma usá-la para rodar algum
tipo de comando que faz a remoção dos dados. A próxima tela exemplifica o acesso ao
comando.
 34

Através do mesmo comando visualizar, chega-se à mesma tela, só que o interessante

agora é notar que além do ícone do lápis, existe também o ícone de um “xis” vermelho,
representando o comando de remoção daquele registro. Ao clicar nele, prossegue-se ao
comando de remoção.
 Antes que o comando seja efetivado, o comando montado é exibido na tela e a
confirmação do usuário é pedida, visto que esse tipo de operação é potencialmente danoso para
todo o ambiente. Além disso, como se pode desejar remover mais de um registro numa única
operação, as caixas de seleção múltipla ajudam no processo de remover um grande conjunto de
dados de uma única vez.

35

No final da página, existe a operação de editar ou remover todos os selecionados. No

exemplo, depois de marcar um conjunto de linhas e apertar o botão destacado acima, chega-se
ao seguinte comando:
 36

Cada comando existente para uma das linhas é traduzido para um código SQL de
remoção equivalente e uma pergunta, se o usuário realmente efetivar a operação e remover
todos os registros mencionados. Ao apertar o botão com o valor de Sim, todos os registros são
removidos da tabela.

7.4 Removendo todos os dados da tabela

Caso o desejo seja de remover todos os dados de uma tabela (para limpá-la e permitir
que o sistema seja reiniciado), pode-se usar um comando alternativo ao DELETE (que quando
não possui parâmetros remove todos os dados).
TRUNCATE pessoa

O comando TRUNCATE remove todos os dados da tabela, só que ele faz isso
apagando a tabela e recriando-a em seguida, o que torna o processo mais rápido (o que é
sensível em tabelas com uma grande quantidade de registros). O comando terá um
37
comportamento especial quando a tabela contiver chaves estrangeiras, necessitando que a
estrutura de remoção em cascata tenha sido usada, garantindo que as tabelas que forneceram
chaves a ela também sejam removidas. Caso isso não seja o real, a operação é cancelada com
erro (o equivalente ao encontrado com o comando DELETE (na prática, o TRUNCATE é um
DELETE mais eficiente e que não suporta restrições na remoção, apagando todos os dados).
8 USO DE ÍNDICES

Todos os tipos de bancos de dados podem ter seu desempenho melhorado pelo uso
de índices. O tipo mais comum de índice é uma lista ordenada dos valores de uma coluna de 38
uma tabela, contendo ponteiros para as linhas associadas a cada valor. Um índice permite que o
conjunto das linhas de uma tabela que satisfazem determinado critério seja localizado
rapidamente.

Os índices são utilizados para encontrar registros com um valor específico de uma
coluna rapidamente. Sem um índice o MySQL tem de iniciar com o primeiro registro e depois ler
através de toda a tabela até que ele encontre os registros relevantes. Quanto maior a tabela,
maior será o custo. Se a tabela possui um índice para as colunas em questão, o MySQL pode
rapidamente obter uma posição para procurar no meio do arquivo de dados sem ter que varrer
todos os registros. Se uma tabela possui 1000 registros, isto é pelo menos 100 vezes mais
rápido do que ler todos os registros seqüencialmente. Note que se você precisar acessar quase
todos os 1000 registros seria mais rápido acessá-los seqüencialmente porque evitaria acessos
ao disco.

As chaves-primárias podem ser entendidas como índices, permitindo buscas rápidas e

eficientes baseadas num valor que nunca se repete. Caso desejado pode-se expandir esse
conceito para colunas que não sejam chaves, aumentando o desempenho de buscas usando
também aquela coluna. Deve-se pesar muito bem o uso ou não de índices, pois quando uma
tabela possui muitos índices e ao mesmo tempo ela sofre muitas modificações (alterações,
remoções, inserções) todos os vários índices também devem ser atualizados para o novo
estado. Para tabelas com uma quantidade muito grande de registros, isso fica ainda mais crítico.

Na parte de estruturas da tabela, existe um item que guia o usuário ao longo do

processo de criação de um índice, além de listar todos os índices que já existam na atual tabela
(caso ela possua uma chave-primária, ela já possuirá um índice).
 39

Clicar no botão executar, leva a seguinte tela:

 Deve-se dar um nome ao índice e indicar quais colunas farão parte dele
(eventualmente, pode-se acrescentar mais de uma coluna ao mesmo índice, o que leva a
considerar todas as informações como parte constante do índice). O final do processo acontece
ao apertar o botão Salvar.

40
ALTER TABLE teste ADD INDEX teste_index (help_category_id)

O comando acima é o gerado a partir das informações inseridas dentro dos campos do
formulário auxiliar, indicando que a tabela teste foi modificada para suportar agora um novo
índice, chamado teste_index, e que deve atuar sobre o campo help_category_id.
9 BUSCANDO DADOS

9.1 Selecionando dados de uma tabela

41

Outra operação muito importante de se realizar num banco de dados é o resgate de

informações armazenadas nele. Isso é feito utilizando a cláusula SELECT, que como o próprio
nome indica, retorna registros de uma tabela. Um exemplo seria:

SELECT

FROM

pessoa

Neste exemplo, todos os registros já inseridos na tabela pessoa são retornados para
uma variável, dependendo do programa ou então exibidos na tela, caso esteja sendo utilizado
algum ambiente de acesso aos dados diretamente.

Esse tipo de consulta é muito simples, pois não limita quais dados serão retornados, o
que pode, para casos em que a tabela possua muitos registros, retornar uma quantidade de
dados impossível de ser tratada pelo programa que executou a consulta.

No exemplo acima, seriam retornadas todos os valores de todas as colunas da tabela,

sendo esse comportamento representado pelo caractere asterisco (em outros pontos da
computação, esse mesmo símbolo é utilizado para representar esse comportamento: “tudo” ou
“qualquer coisa”). Porém, em algumas situações deseja-se definir de forma mais específica qual
campo retornar na busca, pois não seriam necessárias todas as informações:

SELECT 42

nome,

idade

FROM

pessoa

No comando acima, apenas as informações das colunas nome e idade da tabela

pessoa (imaginando que a tabela tenha sido definida desta forma) seriam mostradas no
resultado final da consulta. O número de linhas (registros) retornado continuaria sendo o mesmo,
mas as informações mostradas seriam outras, melhor dizendo, um subconjunto da tabela.
Pensando em memória, o tamanho da memória necessário para retornar e manter esses dados
seria bem menor, uma vez que não seria a tabela toda a ser retornada.

9.2 A sintaxe nomeTabela.nomeCampo

Uma forma alternativa de se realizar consultas a determinados campos de uma tabela

é através do seu nome, o operador ponto. e o nome do atributo. Então, a consulta anterior ficaria
sendo:
SELECT

pessoa.*

FROM

pessoa;

43

Ou ainda:

SELECT

pessoa.cpf,

pessoa.nome,

pessoa.nascimento,

pessoa.altura,

pessoa.filhos

FROM

pessoa;

O segundo exemplo permite que os atributos sejam arranjados da melhor maneira

possível para uma eventual exibição na tela. Nesse momento pode não ser muito interessante
essa estrutura, pois acaba sendo necessário digitar muito mais códigos para ter o mesmo
resultado de se listar apenas as colunas, mas vale lembrar que um próximo passo será
relacionar duas ou mais tabelas dentro de um mesmo SELECT, e como essas tabelas
envolvidas podem ter nomes de colunas repetidas, a maneira que existe para executar essa
operação é prefixar com o nome da tabela cada campo, deixando explícito de onde a informação
deve ser extraída.

Existe outra forma ainda, que seria:

SELECT 44

p.cpf,

p.nome,

p.nascimento,

p.altura,

p.filhos

FROM

pessoa p;

Ao invés de se usar o nome completo da tabela, usou-se um label, ou apelido, para

aquela consulta naquele comando. Assim, toda referência a colunas da tabela pessoa podem ser
feitos através do nome temporário “p”, facilitando a escrita do comando.

Devido a otimizações e cachês que o sistema gerenciador de banco de dados faz nas
consultas, deve-se padronizar qual padrão de escrita utilizar, pois dois comandos que produzam
o mesmo resultado podem ser entendidos como diferentes e ocuparem mais região de memória
que o necessário. Dessa forma, os sistemas devem adotar um padrão de escrita (prefixando com
o nome da tabela ou um mesmo apelido) para garantir que eles fiquem armazenados como um
único e igual comando.
9.3 A cláusula WHERE

Em conjunto com o operador SELECT, pode ser utilizada a palavra WHERE, que
permite fazer uma restrição dos registros a serem retornados pela consulta. Após o WHERE, 45
podem ser colocadas várias condições que serão operadas sobre os registros, só retornando os
dados que realmente satisfarão essas condições. Por exemplo, retornar todas as pessoas com
altura maior que 1,60m:

SELECT

FROM

pessoa

WHERE

altura > 1.60

Se nenhum registro obedecer a esta restrição, será retornado um resultado vazio,

indicando que nada foi encontrado. Outro exemplo seria retornar apenas os nomes das pessoas
que tenham três filhos:

SELECT

pessoa.nome

FROM

pessoa
WHERE

pessoa.filhos = 3

Sendo que o resultado conterá apenas o nome das pessoas que obedeçam ao critério
de igualdade desejado. O comando acima pode ser reescrito da seguinte forma, adotando a 46
nomenclatura de apelidos:

SELECT

p.nome

FROM

pessoa p

WHERE

p.filhos = 3

Nesse comando, e somente nele, a tabela pessoa vai utilizar o nome temporário “p”
para referenciar a tabela em questão para retornar suas respectivas colunas, seja para indicar
dados de quais colunas retornar, seja para utilizar nas restrições da parte WHERE, simplificando
um pouco a escrita do comando (o que pode ser útil em comandos complexos).

9.4 Busca de padrão de caracteres

 Usa-se o operador LIKE em conjunto com o símbolo % para tentar encontrar termos de
palavras dentro dos valores textuais de uma coluna, ao invés de uma busca exata como seria
com o operador igual.

SELECT
47
nome,

idade

FROM

pessoa

WHERE

nome LIKE '%TES%'

O primeiro ponto é que sempre que for feita uma busca de cadeias de caracteres em
alguma coluna do banco, o termo buscado deve vir entre aspas simples. O segundo ponto é que
ao utilizar o operador LIKE, busca-se algum termo dentre os valores da coluna nome da tabela
pessoa que tenham a cadeia TES, em qualquer ponto da busca. Ela pode ser modificada para
algo como:

SELECT

nome,

idade

FROM

pessoa

WHERE
nome LIKE 'TES%'

No exemplo acima, apenas o termos que começarem por TES é que serão retornados
corretamente pela consulta. Dessa forma, o caractere especial % pode ser utilizado na tentativa
de se casar qualquer conjunto de caracteres, em diversas posições, dentro de uma coluna.
48
Vale lembrar que tudo que foi mostrado relacionado à cláusula WHERE para o
SELECT vale também para os comandos já vistos de atualização (UPDATE) e remoção
(DELETE), fazendo com que os comandos não atuem em todos os registros da tabela, mas
somente naqueles em que a condição é satisfeita, limitando o conjunto de dados impactados.

9.5 Operadores lógicos: AND, OR, NOT

Junto com a cláusula WHERE podem vir um número qualquer de condições para se
satisfazer a consulta dos registros, sendo que essas condições devem vir separadas por
operadores lógicos. Assim, para retornar algum registro, ambos os lados da expressão (expr1
AND expr2) devem ser satisfeitos, ao passo que apenas um dos lados da expressão (expr1 OR
expr2) precisa. Juntando os exemplos acima, teríamos algo como:

SELECT

FROM

pessoa

WHERE
(altura > 1.60)

AND (filhos = 3)

Essa consulta só retornará algum resultado se ambas as condições forem verdadeiras,

caso contrário, nada será retornado. De forma resumida, temos: 49

AND: E lógico. Avalia as condições e devolve um valor verdadeiro caso ambos sejam
corretos, sendo muito utilizado em conjuntos de condições de uma cláusula WHERE.

SELECT

nome,

idade

FROM

pessoa

WHERE

idade >10

AND idade < 20

No exemplo, apenas registros que tenham o valor da coluna idade entre 10 e 20 serão
retornados.

OR: OU lógico. Avalia as condições e devolve um valor verdadeiro se algum for

correto, sendo muito utilizado em conjuntos de condições de uma cláusula WHERE.

SELECT
nome,

idade

FROM

pessoa

WHERE 50

idade = 10

OR idade = 20

No exemplo, todos os registros que tenham o valor da coluna idade igual a 10 ou 20

serão retornados.

NOT: Negação lógica. Para valores que retornariam verdade, retorna falso e para
aqueles que seriam falsos, retornaria verdade.

9.6 Operadores Relacionais

Esses operadores estabelecem algum tipo de relação de grandeza entre duas partes,
normalmente uma coluna e um valor passado como parâmetro ou em algumas situações entre
duas colunas do banco de dados. Segue um resumo dos principais:
 Operador Descrição
< Menor que

> Maior que

<> Diferente
>= Maior ou igual
<= Menor ou igual
= Igual
51

O operador BETWEEN pode ser utilizado para especificar um intervalo de valores,

senso especialmente utilizado para definir um intervalo de dados numa busca com início e fim
bem definidos.
10 JUNTANDO DADOS DE DUAS OU MAIS TABELAS

Em determinadas situações, precisamos juntar os dados de duas tabelas diferentes

que de alguma forma se relacionam, pois o modelo relacional foi concebido desta forma, então 52
um dos seus pontos fortes está em não duplicar os dados a partir do momento que se usa
relacionamentos baseados em chaves para separar os dados em locais diferentes.

Porém, é preciso fazer o caminho inverso, ou seja, dadas duas tabelas, de alguma
forma pegar seus dados e montar um relacionamento que faça sentido naquele contexto. Como
exemplo, podemos tomar a tabela de pessoas e de telefones mencionadas acima. Caso
queiramos pegar todos os telefones de uma determinada pessoa como deveríamos proceder?

Simplesmente fazendo uma consulta à tabela de telefone não seria muito útil, pois ao
invés de termos os nomes das pessoas, teríamos apenas seus números de CPF, que de modo
geral são ruins para os seres humanos identificarem-se uns aos outros. O ideal seria colocar o
nome da pessoa ao lado do respectivo número de telefone, mas o problema reside no fato dos
nomes estarem em outra tabela.

O jeito mais simples de fazer isso é utilizar o chamado “produto cartesiano”, que
consiste em pegar cada um dos registros de uma tabela e relacionar com cada uma das linhas
da outra tabela. Vale destacar ainda que o resultado de uma junção seja a união de todos os
atributos das tabelas em questão. A sintaxe é muito simples e seria:

SELECT

FROM

pessoa JOIN telefones

 Ou de uma forma mais simples:

SELECT

FROM 53

pessoa,

telefones

Em ambos os casos o resultado produzido será o mesmo, porém não muito útil nem
com um sentido muito claro. Pois, se numa tabela tivermos quatro registros e na outra oito, o
resultado produzido será de 32 registros (uma multiplicação simples), mas alguns telefones
estarão associados a pessoas erradas. Nesse ponto que entra a utilização do conceito de
chaves. Um exemplo modificado seria:

SELECT

FROM

pessoa,

telefones

WHERE

pessoa.cpf = telefones.cpf

No exemplo acima, só serão retornados os registros onde as chaves forem iguais, ou

seja, o CPF de uma pessoa deve aparecer na tabela de telefones para que a linha seja incluída
no resultado final. A união de todos os atributos continua ocorrendo da mesma forma, porém os
dados passam a fazer sentido.

É necessário discriminar de onde vem cada parâmetro da condição WHERE, porque

eles possuem o mesmo nome, o que geraria um erro na execução da consulta. Esse tipo de
operação pode conter quantas tabelas forem necessárias, mas é uma boa prática sempre
colocar os relacionamentos das chaves para limitar o número de dados retornados. E por fim, 54
dizer que como essa operação manuseia uma imensa quantidade de registros e comparações,
ela tende a ser mais lenta que as demais, então minimizar a sua utilizar é aconselhável.

É nesse momento que a importância das chaves (sejam elas primárias ou

estrangeiras) fica mais evidente, pois é através delas que apenas registros que façam sentido
para a operação serão retornados, descartando aqueles em que não exista correspondência de
chaves (ao fazer o produto cartesiano, todos os registros possíveis estão ali dentro, ficando a
cargo das comparações de chaves removerem aqueles que não façam sentido para a consulta).

Não é obrigatório fazer as comparações utilizando apenas as chaves das tabelas, mas
é onde o processo ganha mais força e fica evidente o modelo relacional. Existem operações em
que se pode relacionar tabelas em que existam chaves válidas em apenas umas das tabelas,
retornando os dados da outra tabela como valores vazios ou simplesmente substituindo por
outras informações de maior interesse. Um cuidado que se deve ter, de qualquer forma, é o de
garantir a consistência das chaves, que pode ser comprometida quando algum registro é inserido
sem que todos os pontos necessários o sejam, ou quando alguma remoção ou alteração mexeu
em apenas alguns pontos e não em todos os necessários.
11 USANDO A INTERFACE GRÁFICA PARA RODAR COMANDOS SELECT

Através da interface do phpMyAdmin é possível também executar quaisquer comandos

de seleção nas tabelas da instância de banco atualmente selecionada. Vale lembrar que 55
independente de qual coluna está sendo exibida no momento é possível envolver mais de uma
no comando ao mesmo tempo.

Como já visto anteriormente, ao clicar na aba SQL depois de escolher qualquer tabela,
é possível executar o comando desejado no campo mostrado (seja ele um SELECT ou qualquer
outro comando SQL válido). Na parte mais à direita, existe um assistente que serve como
indicador de quais colunas existem na tabela, e podem ser incluídos na busca. Ao clicar em
Executar, o resultado da operação é mostrado na próxima página, da mesma forma que foi
exibida na parte referente à exibição dos dados existentes na tabela.
 56

Algumas informações complementares são trazidas, como o número de registros

sendo mostrados e o total geral da consulta (ao utilizar uma cláusula WHERE, o objetivo básico
é reduzir o universo de dados trazidos, diminuindo o tamanho do resultado), o comando SELECT
executado, devidamente avaliado se está correto ou não, algumas opções de navegação dos
dados retornados e, por fim, uma tabela com todas as colunas buscadas e retornadas pela
consulta.

Pode-se inclusive, com esses dados, realizar outras operações sobre a tabela, como a
remoção de algum registro, a alteração e remoção de um registro (caso não envolva outras
tabelas) e a ordenação dos dados segundo qualquer coluna, bastando para isso clicar no título
da coluna desejada (o comando SELECT vai ser atualizado para contemplar o novo modificador,
que será um ORDER BY), que será visto em seguida e serve para ordenar os dados retornados
de uma consulta.

Essa é a interface básica para busca de dados, mas caso seja necessário, pode-se
utilizar uma tela ainda mais avançada e detalhada para incluir informações de busca numa
tabela específica, acessando o item Procurar através da aba que fica na parte superior da tela.
Ao clicar nesse item, chega-se à seguinte configuração de tela, que possui o mesmo padrão
visto anteriormente:

57

Nessa tela, são fornecidas as possibilidades de escolha de quais campos devem

aparecer na consulta (parte inicial do comando SELECT), forma de ordenação, número de
registros que serão mostrados na tela e quais as condições que deverão ser levadas em
consideração, para cada campo, para que a linha em questão seja retornada. Repare que dentro
da escolha das opções de operadores, aqueles que são definidos como cadeias de caracteres,
já trazem habilitado o operador LIKE. Manter um dos campos em branco significa que ele não
será levado em consideração na busca, abrindo um pouco mais o leque de possibilidades da
consulta.

Essa interface oferece um mecanismo muito bom no momento de depurar consultas

(ou comandos em geral) que foram escritos para uma aplicação em particular e está gerando
algum tipo de erro. A maneira mais rápida de fazer essa verificação é depois de obter o comando
que gera o erro dentro dessa interface gráfica (ou diretamente no banco de dados) e ver a razão
do comando estar retornando um erro, facilitando a depuração e correção do comando.

58
12 ORDENANDO O RESULTADO DE UMA CONSULTA

Usa-se o operador ORDER BY para ordenar os registros selecionados com uma ordem
específica. Devem ser informadas as colunas que serão utilizadas na ordenação. Podem ser 59
informadas diversas colunas, sendo que caso ocorra empate entre os valores da próxima coluna,
a próxima será utilizada para desempatar.

SELECT

nome,

idade

FROM

pessoa

ORDER BY

nome

Nesse primeiro exemplo, todos os dados retornados serão ordenados em ordem

crescente pela coluna nome (nomes começados por “A” aparecem no topo do resultado). Um
cuidado que se deve ter na ordenação é usar somente colunas que apareçam na parte do
SELECT (colunas a serem retornadas).

Pode-se, opcionalmente, incluir o termo DESC ao lado de alguma coluna, para que o
resultado seja invertido (de ordem crescente, passa-se para ordem decrescente).

SELECT
nome,

idade

FROM

pessoa

ORDER BY 60

nome,

idade DESC

No exemplo acima, serão retornados todos os registros da tabela pessoa, ordenados

primeiro por nome e caso existam dois nomes iguais, será ordenado por idade, mas nesse caso,
na ordem inversa (maiores apareciam antes na tabela). Uma operação de ORDER BY pode
tornar a consulta consideravelmente mais lenta, visto que ordenar dados não é uma operação
muito eficiente.

12.1 Agrupando dados de uma consulta

Pode-se utilizar o operador GROUP BY para separar os registros selecionados em

grupos específicos. Deve ser informada qual coluna deve ser utilizada para juntar diversos
registros dentro da mesma condição. Vale ressaltar que esse tipo de estrutura é muito utilizado
junto com funções de agregação, como a função COUNT (), que irá contar qual o número de
registro que satisfaz esse agrupamento.
SELECT

COUNT(1),

idade

FROM

pessoa 61

GROUP BY

idade

No exemplo, serão contados quantos registros existem na tabela pessoa, só que o

resultado será agrupado pela coluna idade, quer dizer, primeiro os registros com a mesma idade
serão separados em conjuntos e os elementos desse conjunto serão contados e retornados no
resultado, deixando explícito quantas pessoas de cada idade existem na tabela.

12.2 Trocando o nome de uma coluna no resultado

Pegando o exemplo anterior de se contabilizar o número de idades iguais na tabela

pessoa, pode-se observar que a coluna representada pela função COUNT (1) não possui um
nome, adotando-se o próprio nome da função como título da coluna. Opcionalmente, pode-se
alterar o nome exibido para qualquer coluna, facilitando tanto a exibição dos dados como a
maneira de se recuperar os dados através de funções de alguma linguagem de programação.

SELECT
COUNT(1) AS quantidade,

idade AS idade_pessoas

FROM

pessoa

GROUP BY 62

idade

Nesse exemplo, a primeira coluna, que representa a contagem dos dados, será
chamada no resultado exibido por quantidade e a coluna idade foi trocada para exibir o título de
idade_pessoas, tudo isso ao utilizar o operador AS.

12.3 Mostrando dados sem repetição

Utiliza-se o operador DISTINCT para selecionar dados sem repetição. Ao aplicar esse
modificar a coluna, os valores retornados para ela deverão aparecer uma única vez, descartando
eventuais repetições, mas caso o modificador seja aplicado a um conjunto de valores, apenas a
junção de todos os valores sendo iguais é que tornarão a linha não exibível para a busca.

12.4 Funções de Agregação

 As funções de agregação são usadas dentro de uma cláusula SELECT, em grupos de
registros para devolver um único valor que se aplica a este grupo, trazendo algum significado
para o conjunto.

SELECT
63
AVG (nota)

FROM

aluno

WHERE

codigo = 10

A função AVG, acima, é utilizada para calcular a média dos valores de uma
determinada coluna. No exemplo acima, todas as notas do aluno cujo código seja 10 serão
somadas e divididas pelo número e notas retornadas na busca.

SELECT

COUNT(1)

FROM

aluno

WHERE

código = 10
 A função COUNT () retorna o número de registros encontrados dentro de um SELECT.
No exemplo acima, serão contadas o número de notas existentes para o aluno de código 10 e
mostradas na tela.

SELECT
64
SUM(nota)

FROM

aluno

WHERE

código = 10

Acima, é usada a função SUM () para devolver a soma de todos os valores de um

campo determinado, que no caso, é a somatória das notas do aluno de código 10. As duas
funções anteriores SUM () e COUNT (), quando usadas juntas, teriam o resultado equivalente da
AVG ().

SELECT

MAX(nota)

FROM

aluno

A função MAX () retorna o maior valor de uma determinada coluna. Acima, o valor da
maior nota será retornado.
SELECT

MIN(nota)

FROM

aluno

65

A função MIN () retorna o menor valor de uma determinada coluna. Acima, o valor da
menor nota será retornado.
13 TÓPICOS SELECIONADOS, VIEWS E TRIGGERS

13.1 O que é uma view e sua utilidade

66

VIEWS (ou visões em uma tradução livre) pode ser entendida como uma tabela virtual,
composta pelo resultado de uma consulta a outras tabelas ou mesmo outras VIEWS. Ao
contrário das tabelas normais, uma visão não faz parte fisicamente do banco, existindo apenas
dinamicamente a partir das demais tabelas. Alterações dos dados nas tabelas refletem as
alterações também na visão.

Dentre as vantagens em relação às tabelas, destaca-se que elas podem representar

um subconjunto dos dados de uma tabela, elas podem juntar dados de várias tabelas,
simplificando o manuseio das informações, elas podem esconder parte da complexidade dos
dados de uma tabela, pouco espaço é necessário para armazenar uma visão, uma vez que
apenas a estrutura que a define é guardada e não uma cópia dos dados em si.

Ao verificar a estrutura no sistema gerenciador de banco de dados, uma visão é

identificada como uma estrutura qualquer, bem como qualquer SELECT pode ser executado
normalmente, como se essa fosse uma tabela regular, realizando inclusive novas junções com
outras tabelas.

13.1.1 Como definir uma view

 Segue abaixo um exemplo de criação de uma visão. Repare que a criação faz uso de
estruturas parecidas de criação de tabelas e de comandos SELECTs, que quando reunidos
indicam a criação e qual a origem de dados deve ser utilizada para alimentar a visão com dados:

CREATE VIEW
67
pessoa_maioridade AS

SELECT

nome

FROM

pessoa

WHERE

idade > 18

A estrutura de criação é bem próxima da encontrada na criação de tabelas ou outras

estruturas. Usa-se a palavra CREATE seguida da VIEW identificando a estrutura, o nome da
visão e qual será o SELECT que irá representar os dados existentes nela. No exemplo, os dados
serão trazidos da tabela pessoa, mas apenas a coluna nome (poderiam existir muitos outros) e
apenas aquelas pessoas que tenham idade superior a 18 anos, daí o nome de maioridade na
VIEW.

A remoção de visões segue a mesma regra das remoções de outras estruturas.

DROP VIEW nome_visao

 O comando acima irá remover a visão correspondente, mas não irá atuar nos dados,
até porque os dados estão nas tabelas originais e não na estrutura criada dinamicamente (a
visão). Dessa forma, a remoção atua somente no comando utilizado para definir a VIEW.

68
13.1.2 Como utilizar um view

A utilização de uma view segue o mesmo padrão que a busca de dados em tabelas
físicas já existentes:

SELECT

FROM

pessoa_maioridade

O SELECT acima retornaria todos os registros da visão, mas somente aqueles que
fizessem sentido com a consulta que trouxe os dados originais da tabela pessoa. Lembrando
que essa visão poderia ser utilizada como parte integrante de uma nova consulta mais complexa.

Uma restrição no que toca a construção de visões é que a elas não se pode associar
qualquer tipo de trigger, uma vez que as triggers só podem atuar sobre operações em tabelas
que existam fisicamente, e não estruturas dinâmicas.
13.2 O que é e para que serve um trigger

Suporte a triggers foi incluído com a versão MySQL 5.0.2. Uma trigger é um objeto de
base que é associado com uma tabela e é ativado quando um evento especial acontece numa 69
tabela. Por exemplo, sempre que um INSERT for realizado numa determinada base, pode-se
desejar criar outro registro numa outra tabela.

Triggers são ativadas por comandos SQL. Elas não são ativadas por mudanças em
tabelas feitas por APIs que não transmitem comandos SQL ao servidor de banco, como
chamadas diretas a partir de métodos escritos em JAVA.

13.2.1 Definindo um trigger

A criação de uma trigger segue o seguinte padrão:

CREATE TRIGGER altera_valor BEFORE INSERT ON pessoa

FOR EACH ROW SET @id = @id + NEW.valor;

O comando acima cria uma nova trigger, ficando amarrada à tabela pessoa, devendo
fazer referência a uma tabela permanente (que não é removida ao final de uma operação ou
mesmo uma VIEW). Deve-se dar um nome à estrutura criada, bem como o momento em que a
ação é executada (no exemplo, sempre antes que um novo registro for inserido na tabela
pessoa). Sempre que essa condição for satisfeita, para cada linha existente na tabela pessoa, a
coluna id da tabela será alterada para o seu valor original e mais o valor novo do registro sendo
inserido.

Uma aplicação clássica para o uso de triggers é a criação e uso de logs sempre que
alguma operação crítica for realizada, pois garante que toda e qualquer modificação seja
efetuada. Um cuidado que se deve ter é não onerar demais a tabela com muitas triggers,
especialmente em tabelas cuja quantidade de dados seja muito grande, pois o tempo para 70
realizar todas as operações pode tornar o processo como um todo muito lento, deixando o banco
de dados lento, e conseqüentemente a aplicação que a olha, tornando a aplicação mais lenta.

Detalhando um pouco mais a criação das triggers, a parte inicial é sempre a mesma:
CREATE TRIGGER nome_trigger. O próximo ponto é indicar em que momento o código será
realizado, se antes ou depois que uma determinada ação na tabela será realizada, sendo que as
opções possíveis são BEFORE ou AFTER, quer dizer, o código associado será executado antes
ou depois que a operação de teste for realizada. As ações que disparam a trigger podem ser:
INSERT, UPDATE ou DELETE.

O próximo ponto é identificar qual o código amarrado à trigger que será executando
quando a condição correspondente for satisfeita, sendo que para cada linha já existente na
tabela, o código associado será executado e é por conta disso que para tabelas muito grandes,
essa operação pode ser demorada. Em algumas triggers, não se deseja executar uma operação
para cada registro, mas tão somente inserir uma nova linha em outra tabela (o exemplo de logar
informações, novamente).

Para diferenciar a nova linha sendo inserida e as linhas antigas de cada iteração,
usam-se os identificadores especiais NEW (para a nova linha) e OLD para cada linha já existente
na tabela numa dada iteração. Por representarem uma tupla, pode-se usar o operador ponto
para em seguida acessar qualquer coluna da tabela.

Para remover uma trigger, pode-se usar o comando DROP, da mesma forma que se
remove outras estruturas do banco:

DROP TRIGGER nome_trigger;

 Ao remover a trigger, operações que poderiam disparar a ação deixam de ter efeito.

13.3 Exportando sua base

71

Uma das operações mais importantes e críticas de qualquer sistema é a garantia de

backup que os dados da aplicação devem ter, para evitar que uma queda do sistema ou
qualquer outro problema possa vir a trazer ao sistema, como perda de dados ou instabilidades
futuras. O MySQL possui ferramentas nativas que permitem que essa tarefa seja feita de forma
sistemática e muitas vezes de forma agendada (todas as madrugadas, para garantir que os
dados de um dia para outro não seja perdidos), mas no momento o foco será em fazer esse
procedimento através das interfaces do phpMyAdmin, que tornam o processo manual muito mais
fácil.

Antes, apenas para reforçar, o processo de backup de uma instância de banco de

dados consiste em gravar todas as estruturas e dados da instância em algum arquivo e salvá-lo
numa mídia de backup (fitas dat, CDs ou atualmente, DVDs), mas o importante é que os dados
devem estar seguros e deve haver garantia de que eles foram corretamente salvos durante o
processo. Futuramente, de posse desse arquivo com os dados, o passo de recuperar os dados
fica muito facilitado.
 72

Ao entrar na parte de administração da instância desejada, no topo da página, existe

uma aba representando a Exportação dos dados, com o nome “Exportar”. Ao clicar nesse link,
chega-se à seguinte tela:
 Nas opções da exportação, pode-se montar todas as características dessa exportação.
Na caixa da esquerda, escolhe-se quais tabelas deverão fazer parte do processo, sendo que
para uma cópia completa, todas devem ser selecionadas e mais abaixo mostra-se em que
formato os dados devem ser exportados, sendo que para uma futura recuperação, deve-se
deixar marcada a opção SQL.

Já na caixa da direita, de Opções SQL, deve-se escolher configurações 73

complementares para a exportação. Um ponto que é bom estar marcado para garantir que a
futura importação seja feita corretamente é o item chamado “Inserções Completas”, pois garante
que os novos INSERTs tenham uma maior compatibilidade com outros bancos de dados ou
mesmo versões (imaginando que o SQL gerado será padrão com outras distribuições de bancos
de dados).

Na parte de baixo, pode-se escolher gerar o código da exportação diretamente na tela

ou exportar direto para um arquivo, que para fins de backup é o mais recomendado, pois salva-
se o arquivo e não é necessário salvar num outro arquivo de forma temporária. Seguem os dois
formatos:

Acima, os dados sendo exibidos diretamente na tela. Além dos comentários (colocados
depois dos dois traços), segue-se a definição da tabela com eventuais modificações de valores
padrão e os comandos de inserção com os valores que já existiam ali anteriormente e que
poderão ser recuperados ao recriar o banco como um todo. Ao escolher a opção de inserção
completa, todas as colunas são colocadas explicitamente no comando.

74

Ao escolher essa opção, o mesmo conteúdo mostrado anteriormente é redirecionado

diretamente para ser salvo num arquivo localmente. Repare na extensão do arquivo, que é sql,
padrão de nomenclatura para arquivos de exportação de dados (comumente chamados de
arquivos de “dump”). Esses arquivos terão tamanho diretamente proporcional ao número de
registros de cada tabela e o número de campos delas. O tamanho necessário para armazenar as
estruturas é relativamente pequeno se comparado com o tamanho necessário para se guardar
os dados.

13.3.1 Importando os dados de uma base

 O passo complementar de uma exportação é a importação dos dados de backup a
partir de um arquivo de dump (que normalmente possui a extensão. sql). Seguindo um
procedimento próximo ao da exportação, existe um menu de importação no topo da tela:

75

Ao escolher aquela opção, chega-se à seguinte tela:

 76

Nessa tela deve-se informar qual o arquivo de backup deve ser utilizado para recuperar
as configurações de uma base. Um item que merece destaque é o que permite oferecer
compatibilidade de uma importação com outros bancos de dados, quer dizer, pode-se importar
bases cujo dump fora feito originalmente em outro tipo de bancos de dados e agora trazido para
um banco do tipo MySQL.

De forma alternativa, pode-se, ao invés de importar todas as estruturas de uma vez só,
utilizar as interfaces anteriores para executar apenas trechos de código para criar tabelas e
inserir registros nelas. Vale lembrar que se pode executar vários comandos de uma vez só,
desde que eles sejam separados por ponto-e-vírgula, como no exemplo abaixo:
 77

Neste exemplo, apenas trechos de uma criação de tabela e de suas respectivas

inserções foram colocadas diretamente na aba de SQL para serem executados e recriarem uma
tabela com seus dados.

13.3.2 Permissões de acesso

Uma forma complementar de garantir que as estruturas do banco de dados estarão

seguras e tenha acesso limitado a certos grupos de usuário, é configurar quem pode e quem não
pode acessar determinadas estruturas e realizar determinadas operações sobre o banco ou
tabelas.

78

A aba privilégios leva a todos os usuários configurados para acessar essa instância de
banco de dados.
 79

A página de privilégios mostra todos os usuários configurados para acessar aquele

banco de dados, bem como seus privilégios. Por padrão, todo banco de dados possui o usuário
root (ou administrador) que tem super privilégios, ou seja, pode fazer qualquer coisa com a
instância, suas estruturas (tabelas, visões, índices, triggers) e dados (remover, alterar,
consultar). Em geral, esse usuário é utilizado apenas para administração do banco, como
alteração de estruturas ou dados, não sendo utilizado para as aplicações propriamente ditas.

Por conta disso, devem ser criados outros usuários com acesso mais restrito e
específico para acessar a base, para fazer apenas operações bem definidas, como consultar ou
inserir dados. O cadastro de um novo usuário é feito ao se clicar no item “Abrir nova janela do
phpMyAdmin”, o que leva à seguinte janela:
 80

Na parte de cima são listadas as configurações do usuário, como seu nome de usuário,
servidor em que ele pode se conectar e senha de acesso. Mais abaixo (na próxima figura é
mostrado em detalhes) deve-se indicar todas as permissões que este usuário possua:
 81

Existem quatro grupos principais:

 Dados: Quais operações o usuário pode fazer nos dados, sendo as principais
relacionadas aos comandos vistos anteriormente (INSERT, UPDATE, DELETE e
SELECT);

 Estrutura: Indica quais operações nas estruturas podem ser realizadas, como alterações,
criações e remoções;

 Administração: Quais operações de administração podem ser feitas, como conceder

privilégios, criar usuários e fazer dumps das bases;
  Recursos: Indica quanto dos recursos do banco podem ser utilizados por hora pelo
usuário. Imaginando que tudo está relacionado ao consumo de memória, esse item
indica quanto do banco pode ser alocado para que operações nos dados possam ser
feitas.

O usuário administrador possui acesso completo a esses quatro grupos e em geral 82

novos usuários possuem acessos mais limitados.
 REFERÊNCIAS

83
http://www.conceptia.com.br

Material fortemente baseado nos textos utilizados durante os treinamentos da empresa

Conceptia Consulting.

http://www.imaster.com.br

Site com diversas colunas nas mais variadas tecnologias de informação. Destaque especial para
a coluna sobre PHP, pois mostra diversos exemplos de aplicação e casos reais de programação
em PHP, além de falar de diversas nuances da linguagem, explicando como tirar o máximo
proveito do recurso.

http://www.apache.org

Local onde grandes projetos de software livre estão hospedados e podem ser obtidos por
download sem nenhum tipo de custo. Apenas para citar alguns dos projetos existentes: o
Servidor Web Apache, o Servidor de Aplicação Java Tomcat e o Ambiente de Desenvolvimento
de JSP, Struts.

http://www.mysql.com/

Um dos bancos de dados livres mais famosos e utilizados no mundo, sendo normalmente
utilizado em conjunto com o PHP para o desenvolvimento de soluções completas para pequenos
e médios sistemas. Está atualmente em sua versão 5.0 e pode ser obtido gratuitamente do site.
A maior diferença em relação ao PostGreSQL está no tamanho das bases de dados que cada
um suporta, sendo o PostGreSQL ainda mais robusto para sistemas críticos e de maior tamanho.

http://www.phpmyadmin.net/home_page/index.php

Site do projeto phpmyadmin, onde se pode obter maiores informações do projeto, bem como
fazer o download de versões mais recentes do projeto.
84

http://www.w3schools.com/sql/default.asp

Tutorial em inglês simples, completo e didático sobre a linguagem de acesso ao banco de dados
SQL. Traz muitos exemplos e casos de estudo com exemplos de tabelas e consultas.

http://www.criarweb.com/sql/

Tutorial em português sobre SQL, sendo bem completo e separado por artigos, o que permite
uma leitura não linear, mas focada em itens de maior interesse por parte dos interessados.

http://www.conceptia.com.br

Material fortemente baseado nos textos utilizados durante os treinamentos da empresa

Conceptia Consulting.

http://pt.wikipedia.org/wiki/Banco_de_dados

Site introdutório que traz várias informações teóricas e de base para interessados em começar a
trabalhar com os fundamentos da tecnologia.

http://www.easyphp.org/
Um dos mais famosos instaladores para o pacote de desenvolvimento web usando PHP, MySQL
e Apache. Permite com poucos passos instalar e colocar para executar um ambiente de
desenvolvimento. Não recomendado para ambientes de produção.

http://www.apachefriends.org/en/xampp.html

Outro dos mais famosos instaladores para o pacote de desenvolvimento web usando PHP,
85
MySQL e Apache. Permite com poucos passos instalar e colocar para executar um ambiente de
desenvolvimento. Este pacote vem com uma série de projetos livres e componentes que podem
facilitar em muito o trabalho de se desenvolver uma aplicação. Não recomendado para
ambientes de produção.

http://www.imaster.com.br

Site com diversas colunas nas mais variadas tecnologias de informação. Destaque especial para
a coluna sobre bancos de dados, pois mostra diversos exemplos de aplicação e casos reais de
programação e integração com aplicações que utilizando bancos de dados, além de falar de
diversas nuances da linguagem, explica como tirar o máximo proveito do recurso.

http://www.mysql.com/

Banco de dados objeto deste trabalho e o qual foi baseado todos os pontos específicos do
material. Muito utilizado em diversos tipos de projetos, sendo o preferido na maioria dos projetos
livres. Muito fácil de instalar e manter e a cada nova versão possui um incremento em suas
funcionalidades. Nasceu como software livre, mas cresceu e foi adquirido pela Sun, que
atualmente o mantém.

http://www.oracle.com/global/br/index.html
O banco de dados mais famoso do momento. Recomendado para aplicações médias e grandes,
onde o suporte e manutenção, bem como a necessidade de escalabilidade, são fundamentais
para o processo. Possui custos altos de licença, mas permite a instalação para estudo.

http://www.postgresql.org/

Banco de dados livre, usado cada vez mais em aplicações críticas e onde o desempenho ou o
86
tamanho da aplicação pode aumentar, mas onde existam limitações de custo (para a
implantação de uma solução Oracle, por exemplo), ao mesmo tempo em que possui uma
infinidade de recursos avançados e de administração. Recentemente lançou uma versão nativa
para uso no ambiente Microsoft Windows.

http://www.conceptia.com.br

Material fortemente baseado nos textos utilizados durante os treinamentos da empresa

Conceptia Consulting

http://pt.wikipedia.org/wiki/Banco_de_dados

Site introdutório que traz várias informações teóricas e de base para interessados em começar a
trabalhar com os fundamentos da tecnologia.

http://www.imaster.com.br

Site com diversas colunas nas mais variadas tecnologias de informação. Destaque especial para
a coluna sobre bancos de dados, pois mostra diversos exemplos de aplicação e casos reais de
programação e integração com aplicações que utilizando bancos de dados, além de falar de
diversas nuances da linguagem, explicando como tirar o máximo proveito do recurso.

http://www.mysql.com/

Banco de dados objeto deste trabalho e o qual foi baseado todos os pontos específicos do
material. Muito utilizado em diversos tipos de projetos, sendo o preferido na maioria dos projetos
livres. Muito fácil de instalar e manter e a cada nova versão possui um incremento em suas
funcionalidades. Nasceu como software livre, mas cresceu e foi adquirido pela Sun, que
atualmente o mantém.

http://pt.wikipedia.org/wiki/Banco_de_dados##. C3. 8Dndices

Destaque para o uso de índices, a razão de usá-los e como criá-los usando o banco de dados
87
MySQL.

http://www.conceptia.com.br

Material fortemente baseado nos textos utilizados durante os treinamentos da empresa

Conceptia Consulting.

http://www.php.net

Referência para programação em PHP. Possui bibliotecas de todas as funções disponíveis em

PHP. Parte de download de documentação de manuais e de ferramentas para programação em
PHP. Muitos exemplos, principalmente de usuários. Muito bom também como referência para as
bibliotecas de funções a bancos de dados.

http://www.imaster.com.br

Site com diversas colunas nas mais variadas tecnologias de informação. Destaque especial para
a coluna sobre PHP, pois mostra diversos exemplos de aplicação e casos reais de programação
em PHP, além de falar de diversas nuances da linguagem, explicando como tirar o máximo
proveito do recurso.

http://www.apache.org
Local onde grandes projetos de software livre estão hospedados e podem ser obtidos por
download sem nenhum tipo de custo. Apenas para citar alguns dos projetos existentes: o
Servidor Web Apache, o Servidor de Aplicação Java Tomcat e o Ambiente de Desenvolvimento
de JSP, Struts.

http://www.postgresql.org/

88
Um dos bancos de dados livres mais famosos e utilizados no mundo. Possui como característica
marcante ser objeto-relacional, quer dizer, pode tanto trabalhar na perspectiva dos bancos de
dados relacionais (com tabelas na sua estrutura básica), bem como com objetos, trazendo uma
série de benefícios da orientação a objetos. Está atualmente em sua versão 8.3 e pode ser
obtido gratuitamente do site.

http://www.mysql.com/

Um dos bancos de dados livres mais famosos e utilizados no mundo, sendo normalmente
utilizado em conjunto com o PHP para o desenvolvimento de soluções completas para pequenos
e médios sistemas. Está atualmente em sua versão 5.0 e pode ser obtido gratuitamente do site.
A maior diferença em relação ao PostGreSQL está no tamanho das bases de dados que cada
um suporta, sendo o PostGreSQL ainda mais robusto para sistemas críticos e de maior tamanho.