Revisando sintaxes SQL e criando programa de pesquisa.
Prof. Vitor H. Migoto de Gouvêa
Colégio IDESA – 2011
Edição 5 – SELECT * FROM Minha_memoria – Revisando Sintaxes SQL e Criando programa de Pesquisa
Ano: 04/2011
Nesta Edição
Introdução ......................................................................................................................................................................... 1
As sentenças SQL .............................................................................................................................................................. 1
Sentença de Inserção de Dados .................................................................................................................................... 1
Sentença de Alteração de Dados .................................................................................................................................. 1
Sentença de Deleção de Dados..................................................................................................................................... 2
Sentença de Pesquisa de Dados.................................................................................................................................... 2
Parâmetro WHERE .................................................................................................................................................... 2
Parâmetro LIKE.......................................................................................................................................................... 3
Parâmetro Order By .................................................................................................................................................. 3
Criando o programa .......................................................................................................................................................... 4
Codificando nosso projeto ................................................................................................................................................ 6
Programação do Form .................................................................................................................................................. 6
Programação do Button “Pesquisar” ............................................................................................................................ 7
Arquivos Anexos................................................................................................................................................................ 8
Veja nas próximas edições ................................................................................................................................................ 9
Introdução
Para trabalharmos com banco de dados SQL é necessário que saibamos trabalhar com suas
sintaxes e aqui nesta edição vamos revisar as sentenças SQL uma a uma, para podermos
evoluir nossos trabalhos e nossos programas a fim de obtermos o máximo desta ferramenta
tão grandiosa de Banco de Dados.
As sentenças SQL
Vamos falar agora das sentenças básicas que devemos saber para trabalhar com o banco de
dados MySQL. Vamos dividir em 4 partes , Inserção , Alteração, Deleção e Pesquisa. Abaixo
vamos seguir cada uma delas.
Sentença de Inserção de Dados
A sentença SQL de inserção de dados segue a seguinte sintaxe abaixo:
INSERT INTO nome_da_tabela (campos,campos,...) VALUES (valores,valores,...);
Na sintaxe acima onde se lê nome_da_tabela , seria o nome da tabela onde serão
acrescentados os valores desejados. Onde se lê campos seriam os nomes dos campos,
separados por vírgula, que receberão os dados, que devem ser digitados idênticos como foram
definidos na tabela. Os valores a serem adicionados seguem respectivamente a posição
definida anteriormente na digitação do campo em que irá ser incluído.
Os valores serão colocados entre aspas quando necessários, dependendo do tipo de dado que
o campo possui na tabela.
Sentença de Alteração de Dados
A sentença de alteração de dados é a seguinte:
UPDATE nome_da_tabela SET campo='valor alterado' WHERE campo=valor;
Na sentença de alteração definimos o nome_da_tabela e logo depois a sintaxe SET
colocamos os campos que queremos alterar seguido do valor alterado e por ultimo colocamos
uma condição para a alteração acontecer, por exemplo, definimos que a alteração será feita
para um código especifico, evitando assim que todos os dados do banco de dados sejam
alterados. Vejamos um exemplo:
UPDATE alunos SET nome='Mateu' WHERE codigo=5;
No exemplo acima vemos que na tabela alunos o dado do campo nome receberá uma
alteração para Mateu sendo que a condição é que o dado que será alterado é o dado que
possui o código de valor 5, assim somente o dado que tem o código 5 será alterado no campo
nome para Mateu.
1
Sentença de Deleção de Dados
A sentença de deleção ou exclusão é a seguinte:
DELETE FROM nome_da_tabela WHERE campo1=’x’
Quando vamos excluir um registro especificado de um campo precisamos identificar
que campo queremos remover, para isso usamos novamente a condição com a sentença
where que significa quando. Vejamos um exemplo.
DELETE FROM alunos WHERE codigo=5;
Na sentença acima podemos dizer que ele irá apagar da tabela alunos todos os registros
quando o campo codigo for igual ao valor 5, dessa maneira somente o aluno de código 5 será
excluído. Sem a sentença where definindo uma condição, acabaremos por deletar todos os
dados da tabela.
Sentença de Pesquisa de Dados
A sintaxe da sentença de pesquisa é a seguinte:
SELECT campo1,campo2,... FROM nome_das_tabelas OPÇÕES
A sintaxe do SELECT define em primeiro lugar os campos da tabela que serão mostrados no
resultado (se precisar exibir todos os campos é só utilizar o * no lugar do nome dos campos),
logo depois, após a sentença FROM define-se as tabelas que serão utilizadas na pesquisa.
Depois da tabela vêm as opções de pesquisa, ou seja, definiremos a condição que será
respeitada para a pesquisa ser executada. Podemos usar aqui o WHERE para identificar um
determinado valor especifico de um campo, ou então podemos usar o parâmetro LIKE que irá
pesquisar por valores que começam, terminam ou possuem o valor definido no meio do dado,
se quisermos também podemos ordenar nossa pesquisa usando a propriedade ORDER BY e
definindo a partir de qual campo será ordenado o resultado da pesquisa. Vamos ver um
exemplo de cada caso.
Parâmetro WHERE
O parâmetro where define uma condição única, ou seja, o valor especificado deverá ser
idêntico ao dado que se quer conseguir. Vejamos um exemplo:
SELECT * FROM alunos WHERE nome='Carlos';
Neste exemplo serão pesquisados na tabela alunos os dados do aluno que possui o nome
idêntico a Carlos, nesta pesquisa se existir algum aluno com o nome Carlos Alessandro não
será retornado como resultado, pois a pesquisa é especifica somente ao nome Carlos.
Este parâmetro é útil quando se deseja fazer a pesquisa de um valor cujo dado é único, como
um código ou RG ou CPF, por exemplo, em que os resultados têm de ser um único valor exato.
2
Parâmetro LIKE
O parâmetro like ,que é uma variação do parâmetro where, define uma condição onde o valor
pesquisado pode estar no começo, no fim ou no meio de qualquer palavra do campo, ou seja,
o valor pesquisado não necessariamente poderá ser idêntico ao dado que se quer conseguir.
Vejamos um exemplo:
SELECT * FROM alunos WHERE nome LIKE "Ca%";
Neste exemplo serão pesquisados na tabela alunos os dados dos alunos que os nomes
começam com as letras Ca e podem ter qualquer terminação, nesta pesquisa se existir algum
aluno com o nome Carlos Alessandro será retornado como resultado, pois a pesquisa restringe
que o dado comece com as letras Ca podendo ter qualquer terminação posteriormente.
O parâmetro like pode ser usado de 3 maneiras com o operador %, vejamos estas maneiras:



%texto – Desta maneira os dados pesquisados deverão terminar com o texto definido
texto% – Desta maneira os dados pesquisados deverão começar com o texto definido
%texto% – Desta maneira os dados pesquisados podem conter o texto definido no
meio, no inicio ou no final deles.
Este parâmetro é útil quando se deseja fazer pesquisas de informações aproximadas, onde se
possui parte da informação apenas.
Parâmetro Order By
Já fora das pesquisas, temos o parâmetro Order by que serve como ordenador dos resultados.
Ele ordena de maneira ascendente ou decrescente os resultados pelo campo definido pelo
usuário. Vejamos um exemplo:
SELECT * FROM alunos ORDER BY codigo ASC;
Esta pesquisa irá retornar todos os dados da tabela ordenados pelo código de maneira
ascendente, ou seja, do menor código para o maior código.
Para ordenar de maneira ascendente utiliza-se o parâmetro ASC logo após o campo que se
deseja ordenar, e para ordenar de maneira decrescente utiliza-se o parâmetro DESC logo após
o campo que se deseja ordenar. Pode-se também ordenar em função de mais de um campo
apenas separando as opções de ordenação com vírgula.
SELECT * FROM alunos ORDER BY codigo ASC, nome DESC;
3
Criando o programa
Agora que já temos relembrado o uso das sentenças SQL podemos criar um programa em que
iremos fazer uma pesquisa das informações que possuímos no nosso banco de dados. O
objetivo deste nosso programa é pesquisar nomes de alunos no nosso banco de dados e para
isso precisaremos então preparar nosso Form. Siga a imagem abaixo para ver a disposição dos
objetos no Form e logo depois veja as propriedades que deverão ser alteradas seguindo a
numeração disposta em cada objeto. Ao criar o seu projeto lembre-se de salvá-lo seguindo os
procedimentos ensinados anteriormente nas outras edições.
9
1
2
3
8
4
5
6
7
4
Agora altere as propriedades referentes a cada objeto, para tudo seguir corretamente, altere
primeiro as propriedades Name de cada objeto e depois siga alterando as outras
propriedades:
1. Label
a. Caption  Pesquisa:
2. Edit
a. Text  deixar em branco
b. Name  pesq
3. Button
a. Caption  Pesquisar
4. SQL Connection
a. Name  con
b. DatabaseName  escola
c. HostName  127.0.0.1
d. UserName  root
e. Password  A senha que você definiu na instalação do Appserv
f. Connected  True
5. SQL Query
a. Name  query
b. Database  con
c. Transaction  trans
6. SQL Transaction
a. Name  trans
b. Database  con
7. Data Source
a. Name  source
b. Dataset  query
8. DBGrid ( Palheta Data Control)
a. Name  grid
b. DataSource source
9. Form
a. Caption  Pesquisa de Alunos
5
Codificando nosso projeto
Para que o sistema funcione então precisamos agora incluir alguns comandos de programação
no nosso projeto. Primeiro vamos inserir uma pequena linha de programação no evento
FormCreate que irá fazer a ligação do nosso DB Grid com o banco de dados para que possamos
visualizar todos os dados que estão cadastrados.
Programação do Form
Para isso clique duas vezes no formulário para ir para a tela de edição de código diretamente
no evento FormCreate. Veja os comandos digitados e digite-os em seu projeto.
ATENÇÃO: PARA EVITAR PROBLEMAS EM NOSSO PROJETO, DIGITE O CÓDIGO QUE VOCÊ
VERÁ EM NOSSO MATERIAL, POIS CASO OS COMANDOS SEJAM COPIADOS E COLADOS NO
LAZARUS, ELES PODEM CONTER FORMATAÇÕES QUE SERÃO VISTAS COMO ERRO NO
PROGRAMA NA HORA DA DEPURAÇÃO.
Nesta programação estamos dizendo ao programa que no instante em que for criado o Form
(Evento FormCreate) o programa irá incluir na nossa query uma sintaxe SQL “SELECT * FROM
alunos ORDER BY codigo” que faz uma pesquisa no banco de dados por todos os dados da
tabela alunos e ordena o resultado pelo código. Na segunda linha ele faz executar o script
anterior através da função Open da query.
Este código fará com que os dados que tivermos no nosso banco sejam mostrados no DB Grid
do nosso form , tudo isso devido a ligação entre o Data Source a Query e o DB Grid.
6
Programação do Button “Pesquisar”
Para fazer a parte da pesquisa vamos precisar codificar o botão de Pesquisar, para isso volte ao
form e dê dois cliques no botão Pesquisar para irmos à janela de edição de código no evento
Click do nosso Button. Após isso digite o código que verá na imagem abaixo:
No código do botão a primeira coisa que fazemos é criar uma variável do tipo STRING que irá
armazenar o texto a ser pesquisado. ( a criação da variável você observa na linha em que
adicionamos entre a Procedure e o Begin um comando Var e logo abaixo colocamos
sql:string;)
Depois do Begin o que se vê é que pegamos o valor da propriedade text do edit pesq, que
possuirá o valor digitado pelo usuário, e armazenamos dentro da variável SQL. Após isso
finalizamos a conexão anterior do Query através do comando query.close; e então na linha
abaixo iniciamos a sintaxe de pesquisa.
A sintaxe de pesquisa adicionada na propriedade SQL.text do objeto query fará a pesquisa do
nome dos alunos que possuem o texto digitado pelo usuário em qualquer parte do nome.
Dentro da sintaxe SQL precisamos incluir o texto digitado pelo usuário, por ser texto deve ser
apresentado entre aspas então para isso digitamos primeiro as aspas duplas, pois se usarmos
as aspas simples significa que estamos encerrando a instrução do text da query. Porem
precisamos adicionar o conteúdo que será digitado dentro da caixa de texto e para fazer isso
não podemos estar entre as aspas simples, então fechamos as aspas simples depois do
parâmetro % do comando LIKE, dizendo ao programa que iremos encerrar o texto da
propriedade text da query, mas adicionamos logo depois o + que irá fazer com que algo seja
juntado/concatenado ao conteúdo. Então adicionamos depois do sinal de + a variável que
possui o valor da caixa de texto. Para encerrar o script SQL usamos então outro + e depois
abrimos as aspas simples de novo e continuamos como se estivéssemos no mesmo texto de
antes, assim encerrando o parâmetro % e depois a instrução SQL.
Dessa forma quando o computador executar ele verá como se tudo fosse um texto só
substituindo o conteúdo da caixa entre os sinais de + que nós inserimos.
Veja um exemplo de como o computador iria ler esta linha de código se fosse digitado o nome
Jo dentro da caixa de texto:
Na programação  ‘SELECT * FROM alunos WHERE nome LIKE "%’ +sql+'% ");’
7
Quando Executado  SELECT * FROM alunos WHERE nome LIKE "%Jo%");
Observe que quando executado é como se o programa retirasse as aspas simples e substituísse
o conteúdo da caixa de texto no meio das aspas duplas com os parâmetros %.
Continuando a explicação das outras linhas, logo em seguida do script SQL temos a função
Open sendo usada na query, que irá executar a pesquisa.
Dessa forma depois de digitado esta programação você pode executar seu projeto e ver que já
temos um programa de pesquisa no banco de dados.
Nas próximas edições vamos ver outras ações que podemos fazer com os dados, como
exclusão e edição.
Arquivos Anexos
Os arquivos exemplos deste projeto podem ser obtidos pelo link a seguir:
http://www.idesa.com.br/vitor/vitor_2010_2semestre/arquivos/edicoes/projetos/ped5.rar
O arquivo está compactado no formato RAR, é preciso um descompactador deste tipo de
arquivo para extrair os arquivos. Em caso de não conseguir baixar o arquivo RAR no endereço
acima, me contate pelo email: [email protected] .
8
Veja nas próximas edições

Trabalhando com Edição e Exclusão de Dados no Lazarus – Me altere ou me exclua.
9