Fórum Dúvida na utilização de comandos SQL em Interbase #36437

neste formato a data deve ser mm/dd/aa

delete from ligacoes where data <= ´11/01/02´

Valeu pela dica..vou tentar na segunda feira lá no serviço..Mas o engraçado que eu fiz como falei e consegui deletar as ligações do ano de 2001 e as de datas menores que novembro de 2002 eu não consigo..
Mas valeu..tentarei...se não conseguir, chamarei por ti..

Obrigada...

[]s

Dá pra tirar montão de dúvida de SQL


SQL em Delphi

NOTAS DO AUTOR

Bem vindo a um ´pequeno curso de SQL para Delphi´, espero que este texto que eu estou escrevendo seja útil a você. Não irei entrar muito em detalhes, mas este texto, (o qual ainda não está acabado, está é apenas uma pequena parte sobre o que vou escrever aqui), poderá lhe ajudar bastante nesta questão, que é o SQL. Aconselho também a Comprar o Livro Delphi Com Oracle, pois lá temos muitas informações sobre SQL, que são utilizadas também (e principalmente) no Delphi, não apenas no Oracle. E vale lembrar, que o que está sendo dito aqui, não faz parte deste livro citado.

INTRODUÇÃO À SQL

Cada relatório será composto de duas partes: a primeira é atela de seleçãode dados: é uma tela parecida com a de entrada de dados, na qual o usuário pode escolher quais as informações que deseja no relatório: se preencher os dados, eles servem como limites. Caso não os preencha, não há limite para este dado. A segunda parte é o relatório em si, usando componente do QuickReport, conjunto de componentes especialmente criado para a geração de relatório é incorporado ao executável, não necessitando de outros programas ou módulos externos e que o desenho dos relatórios é muito semelhante ao desenho de uma Form. Para a seleção das informações usaremos a TQuery, um componente de acesso a banco de dados que utiliza a linguagem SQL. A linguagem SQL permite a seleção de informações, sendo bastante flexível. É a maneira mais comum do acesso a bancos de dados Cliente/Servidor, devemos ser conhec

Muitas vezes, a consulta não é editável, como em uma Table. Para que uma consulta seja editável, a Query deve ter sua propriedade RequestLive configurada para True. além disso, ela deve satisfazer uma série de requisitos, como não conter união de tabelas, não conter agrupamento de dados ou não conter uma ordenação explícita. Como só estaremos utilizando as Queries nos relatórios, não precisamos nos preocupar com Queries editável, utiliza-se o componente TUpdateSQL, da guia Data Access da paleta de componentes. Este componente liga-se uma Query e lá podem ser especificadas três sentenças SQL: uma para inclusão de dados, uma para alteração e outra para execlusão. Assim, quando se faz alguma modificação nos dados de Query, o Delphi usa as sentenças so TUpdateSQL.

HISTÓRICO

A linguagem SQL nasceu nos laboratórios da IBM nos anos 70, conjuntamente com seus estudos de bancos de dados relacionais. Nos anos 80, outros fabricantes criaram seus bancos de dados relacionais e passaram a incorporar a linguagem SQL, que teve ampla aceitação no mercado. Á media que novos fabricantes foram aparecendo, cada um foi incorporando novos recursos (e incompatibilidade) à linguagem. Isto evoluiu para uma tentativa de padronização da linguagem, de maneira que todos aderissem. Em 1986 foi lançado o primeiro padrão, o SQL-86, que foi posteriormente revisado em 1989 e em 1992. O padrão atual é o SQL-92, ainda não completamente implemetado por muitos fabricantes. A maioria suporta subconjunto dessa padronização. e ainda há dialetos, como o Transact-SQL, suportado nos bancos de dados Sybase e MS-SQL-Server. A linguagem SQL é bastante ampla, suportando comandos para criação e manipulação de banco de dados, de tabelas, bem como de recuperação de dados. Além dos recursos descritos, a linguagem ainda oferece recursos de segurança, permitindo criar usuários do banco de dados e restringir seu acesso a eles.

INSERINDO COMANDOS SQL

Quando se deseja interargir diretamente com o banco de dados, sem o uso de uma linguagem de programação como a Delphi, deve-se escolher uma ferramenta para editar e executar os comandos SQL. Sigitam-se os comandos SQL no editor da ferramenta, que tem algumas maneira de executar o comando . no Interbase, que vem com o Delphi Profissional (versão Local Interbase) e com o Enterprise (versão para cinco usuários), há uma ferramenta chamada WISQL. ela tem duas janelas: na superior, digita-se a sentença SQL, e na inferior, verifica-se os resultados:

Em geral, todos os bancos de dados têm uma ferramenta semelhante a essa. Além da ferramenta padrão do banco de dado, pode-se também usar o Database (ou SQL) Explorer. Ao selecionar o alias que se deseja trabalhar, abre-se uma guia com o nome de Enter SQL, do lado direito da tela. Lá pode-se digitar uma sentença e visualizar os resultados numa grid, como mostrado a seguir: Qualquer ferramenta que permita entrar com as sentenças SQL e visualizatr os resultadospode ser usada. Você deve escolher aquelas com a qual se sente mais à vontade. Para a entrada dos comandos e aprendizado do SQL, usaremos o SQL Explorer. Os comandos SQL podem ser digitados em letras maiúsculas ou minúsculas. Um comando pode ter diversas linhas, não importando onde são quebradas. A única exceção é a quebra no meio de uma cadeia de caracteres, que não deve ser feita. Você deve quebrar uma sentença SQL de maneira a facilitar seu entendimento. Os comandos mostrados aqui usarão a sintaxe do Local SQL, própria para o uso com tabelas Paradox ou DBase. Para outros bancos de dados a sintaxe pode se alterar um pouco.

CRIANDO E ALTERANDO TABELAS

A criação de tabelas é feita com o comando CREATE TABLE, que tem a seguinte sintaxe:

CREATE TABLE <TABELA> (
Campo1 Tipo,
Campo2 Tipo,
...
)

- <TABELA> é o nome da tabela a ser criada;
- Campo1, Campo2, ... são os nomes dos campos da tabela. Estes nomes vêm seguidos pelos seus respectivos tipos;
- Ao final da lista de campos, podem-se definir as chaves primárias usando a cláusula PRIMARY KEY;
- A lista de campos deve ser envolvidas por parênteses. Por exemplo, para criar a tabela de produtos do sistema, pode-se usar o seguinte comando:

CREATE TABLE PRODUTOS (
Codigo AutoInc,
Descricao Char(40),
CodBarras Char(13),
Preco Money,
Custo Money,
Fornecedor Integer,
DataCadastro Date,
PRIMARY KEY (Codigo)
)

Para alterar a estrutura de uma tabela, deve-se usar o comando ALTER TABLE.

Quando se deseja adicionar uma coluna, usa-se a cláusula ADD, seguida do nome e tipo do campo. Para remover um campo da tabela, deve-se usar uma cláusula DROP, seguida de um ADD com o campo de mesmo nome. Neste caso, os dados do campo serão pedidos. Por exemplo, para incluir um novo campo na tabela chamado CATEGORIA, do enteiro, e remover o campo CUSTO, pode-se fazer:

ALTER TABLE PRODUTOS ADD Categoria Integer, DROP CUSTO

Para excluir uma tabela, usa-se comando DROP TABLE <TABELA>. Deve-se tomar cuidado, pois a tabela e seus dados serão excluídos, sem possibilidade de recuperação.

CRIANDO E EXCLUINDO ÍNDICES

Além do índice primário, pode-se criar índices secundários, usando o comando CREATE INDEX. Sua sintaxe é a seguinte:

CREATE INDEX <NOMEIND> ON <TABELA> (Campo1, Campo2,...)
-<NOMEIND> é o nome do índice a ser criado;
-<TABELA> é o nome da tabela onde será criado o índice;
- Campo1, Campo2,...são os campos que compõem o índice.

Para criar os índices secundários da tabela de produtoa, deve-se dar os seguintes comandos:

CREATE INDEX Descri ON PRODUTOS (Descricao)
CREATE INDEX Barras ON PRODUTOS (CodBarras)

Para apagar um indice secundário da tabela de produtos, deve-se usar o comando DROP INDEX <TABELA>.<INDICE>. Especifica-se o nome da tabela e o nome de seu índice. Caso seja necessário excluir o índice pela palavra PRIMARY.

INSERINDO VALORES NA TABELA

Antes de falar sobre a inserção de valores numa tabela, vale falar um pouco sobre os valores de dados:

- Os valores do tipo caractere são iseridos entre aspas simples (o Local SQL permite aspas duplas, mais isso não é um padrão SQL;
- Os valores do tipo numérico de ponto flutuante são inseridos com o ponto decimal, e sem separadores de milhares;
- Os valores do tipo data são inseridos como valores caractere, no formato ´mm/dd/aa´ou ´mm/dd/aaaa´ , isto é, no formato americano;
- Os valores do tipo hora são inseridos no formato ´hh:mm:ss am´ ou ´hh:mm:ss´, podendo-se usar um relógio de 24 horas (segundo formato)ou de 12 horas (primeiro formato);
- Uma confusão muito comum existe entre oss dados com valor NULL e os campos preenchiodos com espaços.

Um campo com valor NULL é os campos preenchidos com espaços. Um Campo que foi preenchido com espaços está preenchido e é diferente de uma campo que contém NULL. Esta diferença é patente quando se deseja recuperar informações com a cláusula IS NULL. Ela pode recuperar informações apenas quando o campo não foi preenchido com espaços, a informação não é recuperada. Da mesma maneira, o valor NULL não é equivalente ao numéro 0. Tanto espaços quanto o número 0 são valores definidos. NULL é um valor não definido ou não preenchido.
Para inserir valores numa tabela, usa-se o comando INSERT. Caso se queira inserir valores para todos os campos da tabela, basta usar um comando como o seguinte:

INSERT INTO TABELAVALUES (Valor1, Valor2, ...)

Os valores Valor1, Valor2, ... devem corresponder em tipo e devem estar na mesma ordem da definição de campos da tabela. Caso não se queira inserir valores para todos os campos, usa-se esta forma:

INSERT INTO TABELA (Campo1, Campo2)
VALUES(Valor1, Valor2, ...)

Esta segunda forma é a preferida, pois permite visualizar onde os valores estão sendo inseridos e não é afetada por mudanças na estrutura da tabela. Os campos não mencionados na lista são preenchidos com o valor NULL. Esta é a única maneira para se inserir dadosem tabelas Paradox com campos AutoIncremento. Assim, para incluir três registros na tabelade produtos, poderiámos usar os seguintes comandos:

INSERT INTO PRODUTOS (Descriçao, Preco, Custo, Fornecedor, DataCadastro)
VALUES ( ´Calça de brim 42-46´, 27.99,20,1, ´05/12/1999´)
INSERT INTO PRODUTOS (Descricao, Preco, Custo, Fornecedor, DataCadastro)
VALUES (´Camisa de algodão P/M/G´, 13,8.50,1, ´05/12/1999´)
INSERT INTO PRODUTOS (Descricao, Preco, Custo, Fornecedor, DataCadastro)
VALUES (´Camiseta pólo P/M/G´, 9.50,7,1, ´05/12/1999´)

Cada registro deve ser inserido com um comando. A única maneira de se inserir diversas linhas de uma vez é importando os dados de outra tabela. Neste caso, omite-se a cláusula VALUES, colocando um comando SELECT, como em:

INSERT INTO PRODUTOS (Descricao, Preco, DataCadastro)
SELECT Nome, Valor, Cadastramento from CADPRODUTOS

Este comando importa os dados de descrição, preço e data de cadastramento da tabela CADPRODUTOS, jogando-os nos campos correspondentes da tabela PRODUTOS.

ALTERANDO VALORES DE UMA TABELA

Para alterar valores de uma tabela, usa-se o comando UPDATE. sua sintaxe é a seguinte:

UPDATE <TABELA> SET Campo1 = valor1[, Campo2 = Valor2, ...]
[WHERE ...]

Com este comando, pode-se alterar o valor de diversos campos da tabela, para os registros que obedeçam ao especificado na cláusula WHERE. Por exemplo, para aumentar os preços dos produtos do fornecedor 1 em 10¬, poderíamos usar o seguinte comando:

UPDATE PRODUTOS SET Preco = 1.1 * Preco WHERE Fornecedor = 1

Caso a cláusula WHERE não seja incluída no comando, todos os registros da tabela serão alterados.

A CLÁUSULA WHERE

A cláusula WHERE é utilizada para limitar a alteração, exclusão e seleção de dados. Nela podem ser especificadas diversas condições de seleção de dados lógicas, ligadas pelas palavras-chave AND e OR. Podem ser usados parênteses para agrupar as diversas condições, como em:

SELECT * FROM PRODUTO WHERE (Fornecedor = 1) OR
(Fornecedor = 2)

Neste caso serão selecionados os registros da tabela de produtos cujo fornecedor seja igual a 1 ou 2. Quando se quer limitar a seleção entre dois estremos, pode-se usar a palavra-chave BETWEEN. Ela substitui uma consulta como:

SELECT * FROM PRODUTO WHERE (Fornecedor >= 1 AND
(Fornecedor <= 10

Onde são selecionados o registros que têm fornecedores com código entre 1 e 10 por:

SELECT * FROM PRODUTO WHERE Fornecedor BETWEEN 1 AND 10

O BETWEEN pode ser usado com números, caracteres e datas, sempre incluido os extremos. Quando a faixa de seleção não é contínua, pode-se usar a palavra-chave IN. Ela substitui algo como:

SELECT * FROM PRODUTO WHERE (Fornecedor = 1) OR
(Fornecedor = 2)

por:

SELECT * FROM PRODUTO WHERE Fornecedor IN (1,2)

Basta colocar os valores de seleção entre parênteses. O IN tem ainda outra utilização: ele pode ser usado para selecionar dados a partir de outra consulta, como em:

SELECT * FROM PRODUTO WHERE Fornecedor IN (1,2)
(SELECT CODIGO FROM FORNECEDORES
WHERE NOME = ´CAMISAS ABC´)

Esta consulta selecionará apenas os produtos do fornecedor que têm nome igual a CAMISAS ABC. Quando se deseja fazer uma pesquisa parcial em caracteres, pode-se usar a palavra-chave LIKE. Ela permite selecionar partes do caractere, usando os ´coringas:¬, que substituem qualquer cadeia de caraceteres, independentemente do tamanho e_, que substituem apenas um caractere. Assim:

SELECT *FROM PRODUTOS WHERE Descrição LIKE (´_al_a¬´)

Retornará os registros cuja descrição tenha as telras al na segunda e terceira posições, a letra a na quinta posição e terminam com qualquer cadeia de caracteres, como Calça, Calma, Calçado ou Calça de Brim.

Para selecionar apenas os registros que tenham determinado campo igual a NULL, pode-se usar a condição IS NULL, ou IS NOT NULL, para selecionar os registros com campo com valor diferente de NULL. Um exemplo de consulta que mostra os produtos cujo fornecedor não está preenchido é:

SELECT *FROM PRODUTOS WHERE Fornecedor IS NULL

Uma última condição de seleção é feita com a palavra-chave EXISTS. Ela testa uma determinada consulta. Se houver ao menos um registro que satisfaça à consulta, o registro é selecionado. Pode-se inverter esta condição com a palavra-chave NOT EXISTS. Por exemplo, para selecionar todos os registros de vendas que não tenham nenhum correspondente na tabela de itens, pode-se fazer:

SELECT *FROM VENDAS WHERE
NOT EXISTS (SELECT * FROM ITENS WHERE
VENDAS .PEDIDO = ITENS.PEDIDO)

Se houver algum item que tenha o mesmo número de pedido que aquele da tabela de vendas, este registro não é selecionado, sendo mostrados assim apenas os registros da tabela de vendas, sem correspondentes na tabela de itens.

EXCLUINDO DADOS DE UMA TABELA

Para excluir dados de uma tabela, usa-se o comando DELETE. Sua sintaxe é a seguinte:

DELETE FROM <TABELA> [WHERE...]

Se a cláusula WHERE não for especificada neste comando, todos os registros da tabela serão excluídos. Caso se queira limitar o escopo de exclusão, deve-se usar esta cláusula, especificando quais os registros que devem ser apagados. Deve-se tomar muito cuidado ao usar este comando, pois os regitros são excluídos sem nenhum aviso e posteriormente, não podem ser recuperados.

SELECIONANDO DADOS DE EXIBIÇÃO

A seleção de dados de exibição é feita com o comando SELECT. Este é o comando que será mais usado, tendo várias opções e podendo alcançar um nível de complexidade bastante grande. Na sua forma mais simples ele tem a seguinte sintaxe:

SELECT * FROM <TABELA>

Este comando mostra todos os dados contidos numa determinada tabela, exibindo todos os seus compos e todas as suas linhas.
Normalmente não é isto que se deseja. Muitas vezes, todos os campos de uma tabela não são necessário na rede. Pode-se então selecionar quais os campos ou colunas que se deseja recuperar especificando a lista de colunas da tabela, como em:

SELECT codigo, descrição FROM PRODUTOS

Este comando permite recuperar apenas os códigos e descrições dos produtos, mostrando todas as linhas da tabela. Para limitar a pesquisa, pode-se usar a cláusula WHERE, como em:

SELECT Ccodigo, descricao FROM PRODUTOS
WHERE codigo BETWEEM 1 and 100

Este comando recupera os códigos e descrição da tabela de produtos, mas limitando àqueles que tenha código entre 1 e 100 (estes limites também serão incluídos). Conforme foi visto no tópico sobre a cláusula WHERE, pode-se especificar condições mais complexas usando as palavras-chaves AND E OR. Não é necessário que um dos campos que determina a seleção esteja na lista de colunas. Este comando é perfeitamente válido:

SELECT codigo, descricao FROM PRODUTOS
WHERE preco >100

Embora a coluna Preco não esteja na lista de colunas a ser mostradas, ela é usada como critério de seleção das informações.
A Recuperação das informações é feita numa ordem aleatória especificada pelo banco de dados, onde o usuário não tem poder de interferir. Para que os dados venham ordenados, usa-se a cláusula ORDER BY, como em:

SELECT codigo, descricao FROM PRODUTOS
ORDER BY DESCRICAO

A ordenação neste caso seria pelo campo Descricao, em ordem ascendente. Caso se queria ordenar de maneira decrescente, usa-se a palavra-chave DESC, como em:

SELECT codigo, descricao FROM PRODUTOS
ORDER BY Descricao DESC

Desta maneira, serão recuperados os códigos e descrições da tabela de produtos, em ordem decrescente, pelo campo descricao.
Quando se deseja ordenar por mais de um campo, pode-se separá-los por vírgulas. Os campos de ordenação não necessitam estar na lista de colunas recuperadas, como em:

SELECT Codigo, descricao FROM PRODUTOS
ORDER BY descricao ASC, PRECO DESC

A palavra-chave ASC, inserida no comando acima, indica que se deseja uma ordenação ascendente para o campo Descricao e descendente para o campo Preco. Assim, quando houver dois produtos com a mesma descrição, será mostrado antes aquele com preço maior.
Pode-se ainda obter totais, médias ou contagens de valores, usando-se as funções SUM, AVG ou COUNT. Por exemplo, este comando retorna quantos registros a tabela de produtos contém:

SELECT COUNT (*) FROM PRODUTOS

Já este comando retorna o preço médio dos produtos:

SELECT AVG (Preco) FROM PRODUTOS

Pode-se também limitar a totalização com a cláusula WHERE.

Muitas vezes, não se deseja apenas um total ou uma contagem geral das informações: às vezes é necessário apenas agrupar os dados, como quando se deseja saber o total de vendas em cada dia. Para o agrupamento das informações, usa-se a cláusula GROUP BY.
Este comando agrupa as vendas diárias, mostrando o dia e o total de vendas:

SELECT DATA, (SUM(VALOR) FORM VENDAS
GROUP BY DATA

Aqui há duas colunas: uma é o campo Data e o segundo é a soma dos valores de vendas. Quando o comando SELECT tem colunas agrupadas e não agrupadas, todas as colunas não agrupadas devem aparecer na cláusula GROUP BY. Por exemplo, se quiséssemos mostrar a data e o vendedor, não poderíamos fazer:

SELECT DATA, VENDEDOR, SUM(VALOR) FROM VENDAS
GROUP BY DATA

Isto geraria um erro de SQL. Neste caso, devemos incluir a coluna Vendedor na cláusula GROUP BY, como em:

SELECT DATA, VENDEDOR, SUM(VALOR) FROM VENDAS
GROUP BY DATA, VENDEDOR

Neste caso, as vendas são totalizadas por vendedor: para cada data teríamos as vendas de cada vendedor.
Pode-se limitar a faixa de agrupamento usando-se a cláusula WHERE. O comando a seguir totaliza as vendas por data entre dois 1 e 31 de agosto de 1999. Norte que o formato da data é mês/dia/ano:

SELECT DATA, SUM(VALOR) FROM VENDAS
WHERE DATA BETWEEN ´8/1/99´AND ´8/31/99´
GROUP BY DATA

Quando se esta trabalhando com programas, fica difícil recuperar colunas como SUM(VALOR). Estas colunas são representadas no editor de campos como SUM-OF_VALOR, o que provavelmente não e o que se deseja. Pode-se dar um apelido ao campo, e ele passa a ser representado assim. Para isso, usa-se a palavra-chave AS.

Este comando faz o mesmo que o anterior, mas faz com, que a soma dos valores diários seja representada pelo nome TOTDIA:

SELECT DATA, SUM(VALOR) AS TOTDIA FROM VENDAS
WHERE DATA BETWEEN ´8/31/99´
GROUP BY DATA

JUNÇÃO DE TABELAS

Até agora usamos apenas uma tabela por vez. Uma característica marcante da SQL é a facilidade de juntar uma ou mais tabelas, obtendo um resultado único.

A junção mais simples de tabelas (porém aquelas com menor utilidade) é um SELECT onde se colocam as tabelas separadas por vírgulas, como em:

SELECT * FROM VENDAS, VENDEDORES

Este comando retornará todos os campos das tabelas Vendas e Vendedores, gerando um registro para cada combinação de registro das duas tabelas, isto é se a tabela de vendas tiver 5000 registros e a tabela vendedores 20 registros, serão geradas 100.000 linha, 5000 para cada vendedor. Isto, na maior parte das veses, não tem utilidade, pois o que desejamos. como todas as informações das duas tabelas não são completamente necesasárias, podmeos selecionar as colunas que desejamos:

SELECT * FROM VENDAS, VENDEDORES
WHERE VENDAS.VENDEDORES = VENDEDORES.CODIGO

Neste caso serão mostrados apenas registros onde o campo Vendedores da tabela Vendas seja igual ao campo Codigo da tabela Vendedores. Com isto, obteremos apenas a informação que desejarmos. Como todas as informações das duas tabelas não são completamente necessárias, podemos selecionar as colunas que desejamos:

SELECT VENDAS.*, VENDEDORES.NOME FROM VENDAS, VENDEDORES
WHERE VENDAS.VENDEDORES = VENDEDORES.CODIGO

Neste caso, serão retornadas todas as colunas da tabela Vendas e apenas a coluna Nome da tabela Vendedores, usando o mesmo criterio da associação. Aqui deve ser feita uma observação: verificando a cláusula WHERE, podemos notar que serão retornados apenas os registros que tenha equivalência nas duas tabelas. Quando houver um registro da tabela de vendedores não cadastrados na tabela de vendedores ou um código de vendedores igual a NULL, ele não será mostrado. Este tipo de ligação onde é necessária a correspondência da informação nas duas tabelas é chamado de INNER JOIN. O mesmo comando acima pode ser rescrito como:

SELECT VENDAS.*, VENDEDORES.NOME
FROM VENDAS INNER JOIN VENDEDORES ON
VENDAS.VENDEDORES = VENDEDORES.CODIGO

Neste caso, a cláusula WHERE desaparece e é substituída pela sintaxe do INNER JOIN. Ambas as sentenças são equivalentes e retornam a mesma informação. Quando se deve preservar a informação, mesmo que não haja a correspondência entre colunas, deve-se usar o OUTER JOIN. Ha três tipos de OUTER JOIN: LEFT OUTER JOIN,RIGHT OUTER JOIN e FULL OUTER JOIN. O Left e o Right refere-se à posição da tabela em relação à palavra JOIN. Por exemplo, em:

FROM VENDAS LEFT OUTER JOIN VENDEDORES

A tabela Vendas é a tabela da esquerda (LEFT) e a tabela da esquerda, descartando da tabela de vendedores, é a tabela da direita (RIGHT).
O LEFT OUTER JOIN, preserva todas as linhas da tabela da esquerda, descartando as da direita quando não há correspondência. Por exemplo:

SELECT VENDAS.*, VENDEDORES.NOME FROM VENDAS
LEFT OUTER JOIN VENDEDORES
ON VENDAS.VENDEDORES = VENDEDORES.CODIGO

Mostrará todas as linhas da tabela Vendas. Caso não haja correspondência entre o código do vendedor na tabela de vendedores, o nome do vendedor retornará NULL. No RINGHT OUTER JOIN, a tabela da direita é preservada, descartando-se os registros da tabela esquerda quando não há correspondência entre elas. O FULL OUTER JOIN não descarta registros de nenhuma tabela. Ele mostra não sejam encontrados os dados da tabela à direita, suas informações são mostradas como NULL. O mesmo quando não houver correspodência. Caso não sejam encontrados os dados da tabela à direita, suas informações são mostradas como NULL. O mesmo acontece quando não forem encontrados os dados da tabela à esquerda. Para evitar escrever o nome completo da tabela antes de cada coluna a ser recuperada, pode-se especificar um apelido para a tabela, passando a referenciá-la sempre. Um exemplo disso é o comando seguintes:

SELECT V.*, VD NOME FROM VENDAS V
LEFT OUTER JOIN VENDEDORES VD
ON V.VENDEDORES = VD.CODIGO

No comando acima, foi definido um apelido de V para a tabela de Vendas e VD para a tabela Vendedores. Em todos os locais onde as tabelas são referenciadas é usado o apelido determinado. O último tipo retornado de junção entre tabelas é o UNION. Este comando junta duas ou mais tabelas, retornando tanto os registros da primeira, como da segunda, em seqüência. As tabelas preciam ter a mesma estrutura para permitir uma UNION. Um caso para se usar este tipo de comando é quando se tem uma tabela para as vedas de 1999 e uma tabela para as vendas de 1998, que t6em a mesma estrutura, e se deseja listar as vendas de ambos os anos simultaneamente. Para isso, usa-se o comando:

SELECT * FROM VENDAS99
UNION
SELECT * FROM VENDAS99

Isto ajuda as duas tabelas, retornando os valores armazenado em ambos como se fosse uma única tabela.

DELPHI E SQL

Para se utilizar a SQL no Delphi, deve-se usar o componente TQuery, que está na guia Data Access da paleta de componentes. Seleciona-se o componente e coloca-se na Form ou no DataModule. Seleciona-se a propriedade DataBase e, para preencher a sentença SQL, usa-se a propriedade SQL. Ao clicar no botão copm as reticências, abrem-se o editor de String onde se pode digitar o comando desejado. O comando pode ser colocado em diversas linhas: é até interessante quebrar o comando para facilitar a visualização. Para usar as informações retornadas a partir da consulta, deve-se abrir a Query com o método Open ou configurar a propriedade Active para True. Pode-se usar uma Query da mesma maneira que uma Table, ligado-a a um DataSource e, por sua vez, ligando este a componentes DataAware. As condiçõews de edição de uma Query são mais restritas que uma Table. Para se editar uma Query, ela deve ter sua propriedade RequestLive configurada para True e obdecer às seguintes condições:

- Não conter Joins;
- Nao conter agrupamentos;
- Não conter a cláusula ORDER BY.

Caso essas condições não possam ser satisfeitas, para editar uma Query deve-se colocar um componente TUpdateSQL, preenchendo as sentenças para inserção, atualização e exclusão nas propriedades InsertSQL, ModifySQL e DeleteSQL, ligando os dois componentes usando-se a propriedade UpdateSQL da Query. Quando uma Query não retorna um conjunto de informações, como no caso de uma Query de inserção atualização ou exclusão de dados, não se deve abri-la com o método Open ou configurando a propriedade Active. Neste caso, deve-se executar a Query, com o método ExecSQL. Ele apenas executa a Query, atualizando o banco de dados. Muitas vezes, uma Query pode levar algum tempo para executar devido ao grande volume de informações a ser processado. Quando a Query é aberta, o cursor é mudado para um cursor de espra, retornando ao cursor padrão quando a consulta é finalizada, apresentando os dados. Até aqui foram mostradas apenas consultas fixas. Normalmente, não é o que se deseja. Por exemplo, o usuário não exemplo, o usuário não quer sempre as vendas do mês de agosto de 1999 ou do vendedor de código 5. Ele deseja escolher as informações que quer receber. Para isso, existe o conceito de parâmetros: a SQL é pré-codificada, deixando-se parâmetros, que serão definidos em tempo de execução pelo programa. Para incluir um parâmetro numa sentença SQL, basta colocar um nome de variável, antecedida por:, como em:

SELECT * FROM VENDAS
WHERE DATA BETWEEN :DAT1 AND: DAT2

Este comando mostrará todas as informações da tabela de vendas compreendidas entre duas datas, que serão chamados de Da1 (a data inicial) e Da2 (a data final). Deve-se determinar os tipos desses parâmetros e, se for desejado, o valor padrão que assumirão caso não sejam preenchidos. Para isso, deve-se selecionar a propriedade Params da Quer. Ao clicar no botão com reticências, aparece o editor de parâmetros, com os parâmetros solicitados na Query: Ao selecionar um parâmetro no editot, são mostradas suas propriedades no Object Inspector. Deve-se definir o tipo de parâmetro que será utilizado. Numa Query como a que foi deita, os dois parâmetros são do tipo ftDate, tipo data.
Feito isso, a Query está pronta para ser utilizada. Antes de abrir a Query, deve-se atribuir valores aos parâmetros para que ela possa ser executada corretamente. Para isso, usa-se o métood ParambyName para especificar qual parâmetro se deseja definir e usa-se a propriedade Value, ou ainda os métodos AsString, AsDataTime, AsInterger, conforme o tipo de dado que está atribuindo. Assim:

Query1.ParambyName (´dat1´).Value := Date;

Atribui ao parâmetro dat1 a data atual. Como o tipo do parâmetrofoi definido como data, deve-se atribuir à propriedade um valor do tipo data. Caso se quisesse atribuir um valor do tipo caractere, poderia ser usado o método AsString, como em:

Query1.ParambyName (´dat1´).AsString := MaskEdit.Text;

Este comando atribui ao parâmetro dat1 o valor do tipo do texto contido no conponente MaskEdit1. Como este texto é do tipo string, usa-se o método AsString. Uma maneira alternativa de se usar um parâmetro é usar a propriedade da Query, Params. Esta propriedade é uma matriz quie contém todos os parâmetros. Assim, Params [0] representa dat1 e Params [1] representa dat2. Esta maneira, embora um pouco mais rápida, é menos flexível, pois se mudarmos a SQL, incluindo um novo parâmetro antes dos dois anteriores, a numeração muda. Para se alternar o valor de um parâmetro, a Query deve estar fechada. Se ela estiver aberta, a alternação do valor do parâmetro não altera o conteúdo do que é apresentado.

Quando a Query é dinâmica, contendo parâmetros, é interesante que ela seja preparada com antecendência. Isto faz com que sejam preparadas estruturas necessárias para sua execução, fazendo com que a Query execute mais rapidamente. Isto deve ser feito com o método Prepare. Ele é utilizado apenas uma vez, devendo ser chamado antes de a Query ser aberta. Quando uma Query é aberta, o Delphi verifica se ela ja foi preparada. Se não tiver sido, ele a prepara e executa. Caso o método Prepare. Não tenha sido chamado, toda vez que a Query é aberta, o Delphi prepara-a novamente. Assim, quando se espera que uma Query seja aberta múltiplas vezes, é interessante chamar o método Prepare antes de abri-la pela primeira vez. Quando a Query não for mais utilizada, deve-se chamar o método UnPrepare para que as estruturas que foram alocadas sejam deslocadas.

Uma outra forma de criar SQLs dinâmicas é aproveitando a maneira que o Delphi trabalha com a propriedade SQL: ela á uma lista de strings, onde cada string corresponde a uma linha da sentença SQL. Desta maneira, pode-se limpar completamente a sentença SQL, bem como adicionar ou modificar linhas. Caso tenhamos a seguinte sentença SQL:

SELECT * FROM VENDAS
WHERE DATA BERWEEN :DAT1 AND :DAT2

SQL[0] representa a primeira linha da sentença e SQL[1] representa a segunda linha. Usando o método Add, pode-se adicionar uma nova linha a esta SQL. Por exemplo, se tivésemos alguma maneira com a qual o usuário indicasse a ordenação se recuperação dos resultados durante a execução do programa, poderíamos escrever o seguinte código:

if Ordem = oqProData then
Query1.SQL.Add(´Order by data´)
else
Query1.SQL.Add(´Order by valor desc´);
Query1.Open;

Neste código, estamos adicionando uma nova linha à Query, fazendo com que ela seja ordenada conforme o usuário deseja, por data ou por ordem decrescente de valores. Desta maneira pode-se, inclusive, limpar completamente uma Query, com o método Clear, possibilitando criar uma Query completamente nova. Pode-se ainda alterar uma linha da SQL para, por exemplo, alterar a tabela que se quer acessas. No caso da SQL anterior, caso se queira acessar os registros da tabela VENDAS(*, em vez da tabela VENDAS, pode-se fazer o seguinte:

SQL[0]:= ´SELECT * FROM VENDAS98´

Isto substitui a primeira linha da sentença SQL alterando a tabela que será usada.

ida e dominada por todos desenvolvedores que desejam usar este tipo de bancos de dados (embora o conhecimento de SQL não seja desperdiçado por quem usa banco de dados desktop). O Delphi usa para seus bancos de dados desktop um dubconjunto do SQL, chamado Local SQL. O Local SQL permite que se usem bancos de dados Cliente/Servidor, trazendo mais um ponto por favor da escalabilidade do sistema. Quando se usa uma TQuery, conecta-se a um alias, usando a propriedade DatabaseName. Em seguida, preenche-se a propriedade SQL com a consulta é executada, retornando os dados que satisfazem à consulta.