Introdução ao SQL

Introdução

Muitos já tentaram colocar aplicações Delphi em rede, usando Paradox ou qualquer outro banco de dados. E essas pessoas devem ter notado que a velocidade da rede diminuiu muito após o início do acesso dos usuários ao banco de dados. Por que isso acontece? É óbvio: quando você manipula tabelas via rede, a tabela inteira é transferida para a estação, para que o mesmo possa processar os dados e exibir somente o desejado ao usuário. Freqüentemente a maioria desses dados é desperdiçada.

Além disso, não existia uma maneira fácil de se relacionar duas ou mais tabelas sem utilizar muitas linhas de programação, e nem uma forma simples de exibir esses dados em um componente Data Aware (de dados, como o DBEdit).

Isso acabou. Para facilitar a vida dos desenvolvedores de computação Cliente/Servidor é que foi criada a linguagem SQL. Ele resolve diversos problemas decorrentes de uma programação "comum":

· Tráfego na rede. Transferir uma tabela de 100K pela rede não é muita coisa, mas um banco de dados com 50 tabelas num total de 450 MB de dados é coisa demais para ser transferida em uma rede, por menos utilizada que seja para outros fins. Usando SQL, a estação simplesmente envia o comando para o servidor, que retorna somente os dados relevantes;
· Processamento. A maioria computadores utilizados como clientes em uma rede é formada por 386 e 486 (na melhor das hipóteses são Pentium 133 MHz recém-instalados). Esses computadores não são poderosos o suficiente para processar dados de um banco de dados muito grande. Bancos de dados SQL fazem o trabalho pesado diretamente no servidor (é mais viável (inclusive economicamente) colocar um ou poucos servidores de última geração no comando desse tipo de processamento ao invés de muitos computadores não tão poderosos nas máquinas clientes;
· Relacionamento de dados. É praticamente impossível você colocar mais de uma tabela em um DBGrid utilizando o componente TTable. E para ler / gravar dados em tabelas relacionadas, era necessário o uso de longas linhas de código para realizar uma transação, sem a garantia de que os dados sejam gravados em todos os locais necessários. Utilizando SQL e bancos de dados relacionais adequados (como o Interbase, Sybase, Oracle, etc.), é possível obter segurança nas transações, além de ser possível relacionar várias tabelas em um único DBGrid.

Você deve estar pensando: onde posso usar SQL em meus programas? Fácil: você pode usar SQL em seus relatórios (naqueles casos onde você quer listar os dados de apenas um usuário), filtros de dados (é melhor que o filter), stored procedures (você precisa de SQL para criá-las e depois usá-las no sistema), redes com tráfego alto na rede (que impeça uma tabela grande de ser transferida na íntegra), etc

Vejamos os comandos básicos do SQL:

Pesquisa:

Sintaxe:

Select from [where ] [order by ]

Select é o comando de pesquisa;

são os campos a serem incluídos na pesquisa, separados por vírgula (,). Caso você queira selecionar todos os campos de todas as tabelas, simplesmente coloque um asterisco (*) no lugar;

é o nome das tabelas que entrarão na pesquisa, também separados por vírgula (,).

Nota: não é o nome dos componentes TTable que serão digitados, mas sim os nomes das tabelas que foram digitadas no Database Desktop (ou no seu Gerenciador de Banco de Dados).

where e order by são opcionais. Utilize a cláusula where se você quiser fazer restrições na pesquisa (por exemplo, caso queira somente os clientes do Espírito Santo). A cláusula order by será utilizada caso você queira que a tabela seja ordenada por algum campo (por cliente, por exemplo).

Notas:
1. Caso você queira usar parâmetros ao invés de valores em qualquer lugar do comando onde isso seja possível (como , , etc.), é só criar uma variável iniciando com o sinal dois-pontos (:) antes do nome da variável (ex: Select * from Tabela where Campo = :Valor);
2. Pode haver mais de uma condição em qualquer lugar que utilize where (como Select, Delete, update, etc). Você só precisa incluir uma expressão booleana (AND - E booleano, OR - OU booleano);
3. Para exibir dados de uma tabela que NÃO esteja em outra, inclua NOT IN . Os valores de que estiverem em não serão exibidos.

Um exemplo para facilitar as coisas: Você quer listar todas as notas fiscais com os dados dos clientes. Há uma tabela chamada Clientes que possui os campos CodCliente (que é o código do cliente), Nome e Telefone. Todas as vendas estão listadas na tabela Vendas, que possui os campos CodCliente (cujos valores são os mesmos da tabela de clientes, para saber qual o cliente que efetuou a compra), Data e Valor. E essas lista será exibida por ordem alfabética de cliente. O comando SQL que faria essa tarefa é a seguinte:

Select * from Clientes, Vendas where (Vendas.CodCliente = Clientes.CodCliente)
order by Nome

Na condição where, não é necessário que o número do registro nas duas tabelas tenham o mesmo valor. Na verdade, não é necessário que haja um registro equivalente em cada uma das tabelas. Para cada código de cliente na tabela de clientes, pode haver zero, um ou mais registros equivalentes na tabela de vendas. O registro será repetido para cada vez que aparecer na outra tabela (e vice-versa).

Outras funções de pesquisa SQL são:Sum (), para somar o valor total da soma desse campo de todos os registros na tabela;

· Avg (), para extrair a média aritmética desse campo de todos os registros na tabela;

· Extract (Day / Month / Year from Campo), para descobrir o dia/mês/ano de uma data qualquer.

· Min / Max (), que exibe qual é o menor (ou maior) valor desse campo em todos os registros, respectivamente.

Nota: Os comandos em negrito não devem ser alterados. é um nome de campo qualquer (numérico nos dois primeiros casos e data no terceiro caso. Day / Month / Year significa que você deve escolher uma das opções

Inserção:

Sintaxe:

Insert into (, , ..., ) values
(, , ..., )

Insert into é o comando de inserção de dados;

(, , ..., ) são os campos que terão seus dados informados (pode haver qualquer quantidade de campos). É opcional, e nesse caso você deve especificar todos os campos na ordem em que foram gravados no banco de dados.

Os valores após values devem obrigatoriamente ser do mesmo tipo do seu campo respectivo e estar entre aspas (a não ser que esteja usando parâmetros).

Notas:
1. A quantidade de itens em values deve ser igual ao de campos e estar em suas respectivas posições (um campo para um valor).
2. Ao fazer uma inclusão, exclusão ou edição de dados, utilize o comando commit para confirmar a operação ou rollback para cancelar (se estiver usando Delphi, não será necessário usar esses comandos, a não ser que seja explicitamente definido no BDE (e normalmente não é) ou esteja usando CachedUpdates em uma Query (no último caso use o método ApplyUpdates do Dataset (ex: Table e Query).

Ex.: Para incluir um registro em uma tabela chamada Clientes, com os campos Nome, Idade, Endereço e Telefone, utilizamos os seguintes comandos SQL:

Insert into Clientes (Nome, Idade, Telefone, Endereço) values (‘João’, ‘35’, ‘234-5678’, ‘Beco dos Afogados, n°. 13’)

E logo após, caso necessário, use:

Commit

Edição:

Sintaxe:

update set , ..., [where ]

Update é o comando de edição; é o valor ou expressão que você vai passar para determinado campo;

Nota: Sempre use a cláusula where, a não ser que queira alterar TODOS os registros da tabela. E não se esqueça de definir um campo chave que tenha um valor único para cada campo.

Ex.: Alterando a tabela do exemplo anterior, vamos alterar somente o telefone e endereço do João:

Update Clientes set Telefone = ‘000-0000’, Endereço = ‘Mansão dos Ricaços’
where Nome = ‘João’

Não se esqueça do commit!
Note que o campo na condição não precisa ser alterado (apesar de ser possível).

Exclusão:

Sintaxe:

Delete from [where ]

Nota: Sempre use a cláusula where, a não ser que queira excluir TODOS os registros da tabela. E não se esqueça de definir um campo chave que tenha um valor único para cada campo.

Ex.: Vamos excluir o João da lista de clientes:

Delete from Clientes where Nome = ‘João’

O comando acima irá excluir todos os registros que tenham o valor “João” no campo “Nome”.

E terminamos por aqui esta introdução ao SQL. Neste artigo foram mencionados apenas os comandos básicos de SQL, porém num próximo artigo serão cobertos outros comandos SQL, como os de manipulação de tabelas e índices.