Consultas SQL. Consultas no Access m_unit – livro de referência; unidades de medida

Descrição do projeto educativo “Loja”

Diagrama de link de tabela

Descrição das tabelas

m_category - categorias de produtos

m_income - entrada de mercadorias

m_outcome - consumo de bens

m_product - diretório, descrições de produtos

m_fornecedor - diretório; informações do fornecedor

m_unit – diretório; unidades de medida

Para testar de forma prática os exemplos dados neste material de treinamento, você deve ter o seguinte software:

Microsoft Access 2003 ou posterior.

Consulta SQL no MS Access. Começar

Para ver o conteúdo da tabela, clique duas vezes no nome da tabela no painel esquerdo:

Para alternar para o modo de edição de campos de tabela, selecione Modo de design no painel superior:

Para exibir o resultado de uma consulta SQL, clique duas vezes no nome da consulta no painel esquerdo:

Para mudar para o modo de edição de consulta SQL, selecione o modo SQL no painel superior:

Consulta SQL. Exemplos em MS Access. SELECIONE: 1-10

Em uma consulta SQL, a instrução SELECT é usada para selecionar tabelas de banco de dados.

Consulta SQL Q001. Exemplo de consulta SQL para obter apenas os campos obrigatórios na sequência desejada:

SELECIONE dt, product_id, valor

DE m_renda;

Consulta SQL Q002. Neste exemplo de consulta SQL, o caractere asterisco (*) é utilizado para listar todas as colunas da tabela m_produto, ou seja, para obter todos os campos da relação m_produto:

SELECIONE *
DE m_produto;

SolicitarSQLQ003. A instrução DISTINCT é usada para eliminar entradas duplicadas e obter múltiplas entradas exclusivas:

SELECIONE ID_do_produto DISTINTO

DE m_renda;

Consulta SQL Q004. A instrução ORDER BY é usada para classificar (ordenar) registros pelos valores de um campo específico. O nome do campo é especificado após a instrução ORDER BY:

SELECIONE *
DE m_renda

Preço ORDER BY;

Consulta SQL Q005. A instrução ASC é usada como complemento da instrução ORDER BY e serve para especificar a classificação crescente. A instrução DESC é usada além da instrução ORDER BY e é usada para especificar a classificação decrescente. No caso em que nem ASC nem DESC são especificados, assume-se a presença de ASC (padrão):

SELECIONE *
DE m_renda

PEDIR POR dt DESC , preço;

Consulta SQL Q006. Para selecionar os registros necessários da tabela, são utilizadas várias expressões lógicas que expressam a condição de seleção. A expressão booleana aparece após a instrução WHERE. Um exemplo de obtenção de todos os registros da tabela m_income para os quais o valor do valor é maior que 200:

SELECIONE *
DE m_renda

ONDE valor>200;

Consulta SQL Q007. Para expressar condições complexas, são utilizados os operadores lógicos AND (conjunção), OR (disjunção) e NOT (negação lógica). Um exemplo de como obter da tabela m_outcome todos os registros cujo valor do valor é 20 e o valor do preço é maior ou igual a 10:

Preço

DE m_resultado
ONDE valor=20 E preço>=10;

Consulta SQL Q008. Para unir dados de duas ou mais tabelas, use as instruções INNER JOIN, LEFT JOIN, RIGHT JOIN. O exemplo a seguir recupera os campos dt, product_id, amount, price da tabela m_income e o campo title da tabela m_product. O registro da tabela m_income é unido ao registro da tabela m_product quando o valor de m_income.product_id é igual ao valor de m_product.id:

ON m_income.product_id=m_product.id;

Consulta SQL Q009. Há duas coisas a serem observadas nesta consulta SQL: 1) o texto de pesquisa está entre aspas simples ("); 2) a data está no formato #Mês/Dia/Ano#, o que é verdadeiro para o MS Access. Em outros sistemas, o formato de escrita da data pode ser diferente. Um exemplo de exibição de informações sobre o recebimento de leite em 12 de junho de 2011. Observe o formato da data #6/12/2011#:

SELECT dt, product_id, título, valor, preço

FROM m_income INNER JOIN m_produto

ONDE title="Leite" And dt=#6/12/2011#; !}

Consulta SQL Q010. A instrução BETWEEN é usada para testar se um valor pertence a um determinado intervalo. Um exemplo de consulta SQL que exibe informações sobre produtos recebidos entre 1º e 30 de junho de 2011:

SELECIONE *
FROM m_income INNER JOIN m_produto

EM m_income.product_id=m_product.id
ONDE dt ENTRE #01/06/2011# E #30/06/2011#;

Consulta SQL. Exemplos em MS Access. SELECIONE: 11-20

Uma consulta SQL pode ser aninhada em outra. Uma subconsulta nada mais é do que uma consulta dentro de uma consulta. Normalmente, uma subconsulta é usada na cláusula WHERE. Mas existem outras maneiras de usar subconsultas.

Consulta Q011. São exibidas informações sobre os produtos da tabela m_product, cujos códigos também estão na tabela m_income:

SELECIONE *
DE m_produto

WHERE id IN (SELECT product_id FROM m_income);

Consulta Q012.É exibida uma lista de produtos da tabela m_product, cujos códigos não estão na tabela m_outcome:

SELECIONE *
DE m_produto

WHERE id NOT IN (SELECT product_id FROM m_outcome);

Solicitação Q013. Esta consulta SQL exibe uma lista exclusiva de códigos e nomes de produtos que estão na tabela m_income, mas não na tabela m_outcome:

SELECIONE DISTINCT product_id, título

FROM m_income INNER JOIN m_produto
EM m_income.product_id=m_product.id
WHERE product_id NOT IN (SELECT product_id FROM m_outcome);

Consulta Q014. Uma lista exclusiva de categorias cujos nomes começam com a letra M é exibida na tabela m_category:

SELECIONE título DISTINTO

DE m_produto
ONDE título LIKE "M*";

Consulta Q015. Um exemplo de execução de operações aritméticas em campos de uma consulta e renomeação de campos em uma consulta (alias). Este exemplo calcula despesa = quantidade*preço e lucro para cada entrada de despesas de item, assumindo que o lucro é de 7% das vendas:

valor*preço/100*7 lucro AS
DE m_resultado;

Consulta Q016. Ao analisar e simplificar as operações aritméticas, você pode aumentar a velocidade de execução da consulta:

SELECT dt, product_id, valor, preço, valor*preço AS resultado_soma,

resultado_soma*0,07 lucro AS
DE m_resultado;

Solicitação Q017. Você pode usar a instrução INNER JOIN para unir dados de várias tabelas. No exemplo a seguir, dependendo do valor ctgry_id, cada entrada na tabela m_income corresponde ao nome da categoria da tabela m_category à qual o produto pertence:

SELECIONE c.título, b.título, dt, valor, preço, valor*preço AS soma_da_renda

FROM (m_renda AS a INNER JOIN m_produto AS b ON a.product_id=b.id)
INNER JOIN m_category AS c ON b.ctgry_id=c.id
ORDENAR POR c.título, b.título;

Solicitação Q018. Funções como SUM - soma, COUNT - quantidade, AVG - média aritmética, MAX - valor máximo, MIN - valor mínimo são chamadas de funções agregadas. Eles aceitam muitos valores e após processá-los retornam um único valor. Um exemplo de cálculo da soma do produto dos campos valor e preço usando a função agregada SUM:

SELECIONE SOMA(valor*preço) AS Total_Sum

DE m_renda;

Consulta Q019. Um exemplo de uso de várias funções agregadas:

SELECIONE Soma(valor) AS Valor_Soma, AVG(valor) AS Valor_AVG,

MAX(valor) AS Valor_Max, Min(valor) AS Valor_Min,
Contagem(*) AS Número_Total
DE m_renda;

Solicite Q020. Neste exemplo, é calculado o total de todas as mercadorias com código 1, capitalizadas em junho de 2011:

SELECIONE Soma(valor*preço) AS soma_renda

DE m_renda
ONDE product_id=1 E dt ENTRE #01/06/2011# E #30/06/2011#;.

Consulta Q021. A consulta SQL a seguir calcula a quantidade de vendas de itens com código 4 ou 6:

SELECIONE Soma(valor*preço) como soma_resultado

DE m_resultado
ONDE product_id=4 OU product_id=6;

Consulta Q022. Calcula-se quantas mercadorias com código 4 ou 6 foram vendidas em 12 de junho de 2011:

SELECIONE Soma(valor*preço) AS soma_resultado

DE m_resultado
ONDE (id_produto=4 OU id_produto=6) AND dt=#6/12/2011#;

Consulta Q023. A tarefa é esta. Calcule a quantidade total de mercadorias na categoria “Produtos de Panificação”.

Para resolver esse problema, é necessário operar com três tabelas: m_renda, m_produto e m_categoria, pois:

- a quantidade e o preço dos bens capitalizados são armazenados na tabela m_income;
- o código da categoria de cada produto é armazenado na tabela m_product;
- o nome da categoria do título é armazenado na tabela m_category.

Para resolver este problema usaremos o seguinte algoritmo:

- determinar o código da categoria "Produtos de panificação" da tabela m_category usando uma subconsulta;
- conectar as tabelas m_income e m_product para determinar a categoria de cada produto adquirido;
- cálculo do valor do recebimento (= quantidade*preço) para mercadorias cujo código de categoria é igual ao código definido pela subconsulta acima.
SELECIONAR
FROM m_product AS a INNER JOIN m_income AS b ON a.id=b.product_id
WHERE ctgry_id = (SELECT id FROM m_category WHERE title="Produtos de panificação"); !}

Consulta Q024. Resolveremos o problema de cálculo do valor total de bens capitalizados na categoria “Produtos de Panificação” utilizando o seguinte algoritmo:
- para cada entrada na tabela m_income, dependendo do valor do seu product_id, da tabela m_category, corresponda ao nome da categoria;
- selecionar registros cuja categoria seja “Produtos de Panificação”;
- calcular o valor do recebimento = quantidade * preço.

FROM (m_produto AS a INNER JOIN m_income AS b ON a.id=b.produto_id)

ONDE c.title="Produtos de panificação"; !}

Consulta Q025. Este exemplo calcula quantos itens de mercadorias foram consumidos:

SELECIONE CONTAGEM(id_produto) AS produto_cnt

FROM (SELECT DISTINCT product_id FROM m_outcome) AS t;

Consulta Q026. A instrução GROUP BY é usada para agrupar registros. Normalmente, os registros são agrupados pelo valor de um ou mais campos e alguma operação agregada é aplicada a cada grupo. Por exemplo, a consulta a seguir gera um relatório sobre a venda de mercadorias. Ou seja, é gerada uma tabela contendo os nomes das mercadorias e o valor pelo qual foram vendidas:

SELECIONE título, SOMA(valor*preço) AS soma_resultado

FROM m_product AS a INNER JOIN m_outcome AS b
EM a.id=b.product_id
GRUPO POR título;

Consulta Q027. Relatório de vendas por categoria. Ou seja, é gerada uma tabela que conterá os nomes das categorias de produtos, o valor total pelo qual foram vendidos os produtos dessas categorias e o valor médio das vendas. A função ROUND é usada para arredondar o valor médio para o centésimo mais próximo (o segundo dígito após o separador decimal):

SELECIONE c.título, SOMA(valor*preço) AS soma_resultado,

ROUND(AVG(valor*preço),2) AS resultado_soma_média
FROM (m_produto AS a INNER JOIN m_outcome AS b ON a.id=b.product_id)
INNER JOIN m_category AS c ON a.ctgry_id=c.id
GRUPO POR c.título;

Consulta Q028. O número total e médio de seus recebimentos é calculado para cada produto e exibe informações sobre produtos cujo total de recebimentos é de pelo menos 500:

SELECIONE id_do_produto, SUM(quantia) AS quantidade_soma,

Arredondamento(Média(quantia),2) AS quantidade_média
DE m_renda
GRUPO POR product_id
TENDO Soma(quantia)>=500;

Consulta Q029. Esta consulta calcula para cada produto o valor e a média dos seus recebimentos realizados no segundo trimestre de 2011. Se o valor total do recebimento do produto não for inferior a 1.000, serão exibidas informações sobre este produto:

SELECIONE título, SOMA(valor*preço) AS soma_renda

FROM m_income a INNER JOIN m_product b ON a.product_id=b.id
ONDE dt ENTRE #01/04/2011# E #30/06/2011#
GRUPO POR título
TENDO SOMA(valor*preço)>=1000;

Consulta Q030. Em alguns casos, é necessário combinar cada registro de alguma tabela com cada registro de outra tabela; que é chamado de produto cartesiano. A tabela resultante de tal conexão é chamada de tabela de Descartes. Por exemplo, se alguma tabela A tiver 100 registros e a tabela B tiver 15 registros, então a tabela Descartes consistirá em 100*15=150 registros. A consulta a seguir une cada registro da tabela m_income com cada registro da tabela m_outcome:
DE m_renda, m_resultado;

Consulta Q031. Um exemplo de agrupamento de registros por dois campos. A seguinte consulta SQL calcula para cada fornecedor a quantidade e a quantidade de mercadorias recebidas dele:

SOMA(valor*preço) AS soma_renda

Consulta Q032. Um exemplo de agrupamento de registros por dois campos. A consulta a seguir calcula para cada fornecedor a quantidade e quantidade de seus produtos vendidos por nós:

SELECIONE id_fornecedor, id_produto, SUM(quantia) AS quantidade_soma,

GROUP BY fornecedor_id, produto_id;

Consulta Q033. Neste exemplo, as duas consultas acima (q031 e q032) são usadas como subconsultas. Os resultados dessas consultas usando o método LEFT JOIN são combinados em um relatório. A consulta a seguir exibe um relatório sobre a quantidade e quantidade de produtos recebidos e vendidos para cada fornecedor. Observe que se algum produto já foi recebido, mas ainda não foi vendido, a célula result_sum para esta entrada estará vazia. que esta consulta é apenas um exemplo do uso de consultas relativamente complexas como uma subconsulta. O desempenho desta consulta SQL com uma grande quantidade de dados é questionável:

SELECIONE *
DE

SOMA(valor*preço) AS soma_renda

ON a.product_id=b.id GRUPO POR fornecedor_id, product_id) COMO um
PARTIR À ESQUERDA
(SELECIONE id_fornecedor, id_produto, SUM(quantia) AS quantidade_soma,
SOMA(valor*preço) AS soma_resultado
FROM m_resultado AS a INNER JOIN m_produto AS b
ON a.product_id=b.id GRUPO POR fornecedor_id, product_id) AS b
ON (a.product_id=b.product_id) E (a.supplier_id=b.supplier_id);

Consulta Q034. Neste exemplo, as duas consultas acima (q031 e q032) são usadas como subconsultas. Os resultados dessas consultas usando o método RIGTH JOIN são combinados em um relatório. A consulta a seguir exibe um relatório sobre o valor dos pagamentos de cada cliente de acordo com os sistemas de pagamento que utilizou e o valor dos investimentos que realizou. A consulta a seguir exibe um relatório sobre a quantidade e quantidade de produtos recebidos e vendidos para cada fornecedor. Observe que se algum produto já foi vendido, mas ainda não chegou, a célula income_sum desta entrada estará vazia. A presença de tais células vazias é um indicador de erro na contabilidade de vendas, pois antes de uma venda é necessário primeiro que chegue o produto correspondente:

SELECIONE *
DE

(SELECIONE id_fornecedor, id_produto, SUM(quantia) AS quantidade_soma,
SOMA(valor*preço) AS soma_renda
FROM m_income AS a INNER JOIN m_product AS b ON a.product_id=b.id
GROUP BY fornecedor_id, produto_id) COMO um
JUNTE-SE À DIREITA
(SELECIONE id_fornecedor, id_produto, SUM(quantia) AS quantidade_soma,
SOMA(valor*preço) AS soma_resultado
FROM m_outcome AS a INNER JOIN m_product AS b ON a.product_id=b.id
GROUP BY fornecedor_id, produto_id) AS b
ON (a.supplier_id=b.supplier_id) AND (a.product_id=b.product_id);

Consulta Q035.É exibido um relatório mostrando o valor das receitas e despesas por produto. Para isso, é criada uma lista de produtos de acordo com as tabelas m_income e m_outcome, então para cada produto desta lista é calculada a soma de suas receitas de acordo com a tabela m_income e o valor de suas despesas de acordo com a tabela m_outcome:

SELECT product_id, SUM(in_amount) AS income_amount,

SOMA(valor_saída) AS valor_resultado
DE
(SELECIONE product_id, valor AS in_amount, 0 AS out_amount
DE m_renda
UNIÃO TODOS
SELECT product_id, 0 AS in_amount, quantidade AS out_amount
DE m_resultado) AS t
GRUPO POR id_produto;

Consulta Q036. A função EXISTS retorna TRUE se o conjunto passado para ela contiver elementos. A função EXISTS retorna FALSE se o conjunto passado para ela estiver vazio, ou seja, não contém elementos. A consulta a seguir exibe os códigos de produto contidos nas tabelas m_income e m_outcome:

SELECIONE ID_do_produto DISTINTO

DE m_renda COMO a
WHERE EXISTS(SELECT product_id FROM m_outcome AS b

Consulta Q037. Os códigos de produto contidos nas tabelas m_income e m_outcome são exibidos:

SELECIONE ID_do_produto DISTINTO

DE m_renda COMO a
ONDE product_id IN (SELECIONE product_id FROM m_outcome)

Consulta Q038. São exibidos códigos de produto que estão contidos na tabela m_income, mas não estão contidos na tabela m_outcome:

SELECIONE ID_do_produto DISTINTO

DE m_renda COMO a
ONDE NÃO EXISTE(SELECIONE product_id FROM m_outcome AS b
ONDE b.product_id=a.product_id);

Consulta Q039. Uma lista de produtos com valor máximo de vendas é exibida. O algoritmo é o seguinte. Para cada produto é calculado o valor de suas vendas. Em seguida, é determinado o máximo desses valores. Em seguida, para cada produto, o valor de suas vendas é calculado novamente, e são exibidos o código e o valor de vendas dos produtos cujo valor de vendas é igual ao máximo:

SELECIONE id_do_produto, SUM(valor*preço) AS valor_soma

DE m_resultado
GRUPO POR product_id
TENDO SOMA(quantia*preço) = (SELECT MAX(s_quantia)
FROM (SELECT SUM(quantia*preço) AS s_amount FROM m_outcome GROUP BY product_id));

Consulta Q040. A palavra reservada IIF (operador condicional) é usada para avaliar uma expressão lógica e executar uma ação dependendo do resultado (VERDADEIRO ou FALSO). No exemplo a seguir, a entrega de um item é considerada “pequena” se a quantidade for inferior a 500. Caso contrário, ou seja, a quantidade recebida for maior ou igual a 500, a entrega é considerada “grande”:

SELECIONE dt, product_id, valor,

IIF(valor DE m_renda;

Consulta SQL Q041. No caso em que o operador IIF é utilizado diversas vezes, é mais conveniente substituí-lo pelo operador SWITCH. O operador SWITCH (operador de seleção múltipla) é usado para avaliar uma expressão lógica e executar uma ação dependendo do resultado. No exemplo a seguir, o lote entregue é considerado “pequeno” se a quantidade de mercadorias no lote for inferior a 500. Caso contrário, ou seja, se a quantidade de mercadorias for maior ou igual a 500, o lote é considerado “grande ":

SELECIONE dt, product_id, valor,

SWITCH(quantidade =500,"grande") marca AS
DE m_renda;

Consulta Q042. Na próxima solicitação, se a quantidade de mercadoria do lote recebido for inferior a 300, o lote será considerado “pequeno”. Caso contrário, isto é, se a condição amount SELECT dt, product_id, amount,
IIF(valor IIF(valor FROM m_renda;

Consulta SQL Q043. Na próxima solicitação, se a quantidade de mercadoria do lote recebido for inferior a 300, o lote será considerado “pequeno”. Caso contrário, isto é, se a condição amount SELECT dt, product_id, amount,
SWITCH(valor valor>=1000,"grande") marca AS
DE m_renda;

Consulta SQL Q044. Na consulta a seguir, as vendas são divididas em três grupos: pequeno (até 150), médio (de 150 a 300), grande (300 ou mais). A seguir, é calculado o valor total para cada grupo:

SELECIONE Categoria, SUM(outcome_sum) AS Ctgry_Total

FROM (SELECIONE valor*preço AS resultado_soma,
IIf(valor*preço IIf(valor*preço FROM m_resultado) AS t
Agrupar por categoria;

Consulta SQL Q045. A função DateAdd é usada para adicionar dias, meses ou anos a uma determinada data e obter uma nova data. Próxima solicitação:
1) adiciona 30 dias à data do campo dt e exibe a nova data no campo dt_plus_30d;
2) adiciona 1 mês à data do campo dt e exibe a nova data no campo dt_plus_1m:

SELECIONE dt, dateadd("d",30,dt) AS dt_plus_30d, dateadd("m",1,dt) AS dt_plus_1m

DE m_renda;

Consulta SQL Q046. A função DateDiff foi projetada para calcular a diferença entre duas datas em unidades diferentes (dias, meses ou anos). A consulta a seguir calcula a diferença entre a data no campo dt e a data atual em dias, meses e anos:

SELECT dt, DateDiff("d",dt,Data()) AS último_dia,

DateDiff("m",dt,Data()) AS últimos_meses,
DateDiff("aaaa",dt,Data()) AS últimos_anos
DE m_renda;

Consulta SQL Q047. O número de dias desde a data de recebimento da mercadoria (tabela m_income) até a data atual é calculado usando a função DateDiff e a data de vencimento é comparada (tabela m_product):

DateDiff("d",dt,Data()) AS last_days
FROM m_renda AS a INNER JOIN m_produto AS b
EM a.product_id=b.id;

Consulta SQL Q048.É calculado o número de dias desde a data de recebimento da mercadoria até a data atual, em seguida é verificado se esta quantidade ultrapassa o prazo de validade:

SELECIONE a.id, product_id, dt, lifedays,

DateDiff("d",dt,Date()) AS last_days, IIf(last_days>lifedays,"Sim","Não") AS date_expire
FROM m_renda a INNER JOIN m_produto b
EM a.product_id=b.id;

Consulta SQL Q049.É calculado o número de meses desde a data de recebimento da mercadoria até a data atual. A coluna mês_último1 calcula o número absoluto de meses, a coluna mês_último2 calcula o número de meses completos:

SELECT dt, DateDiff("m",dt,Data()) AS mês_último1,

DateDiff("m",dt,Data())-iif(dia(dt)>dia(data()),1,0) AS mês_último2
DE m_renda;

Consulta SQL Q050. Um relatório trimestral é exibido sobre a quantidade e quantidade de bens adquiridos em 2011:

SELECIONE valor, SOMA(soma_resultado) AS Total

FROM (SELECIONE valor*preço AS soma_resultado, mês(dt) AS m,
SWITCH(m =10,4) AS kvartal
FROM m_renda ONDE ano(dt)=2011) AS t
GRUPO POR trimestre;

Consulta Q051. A consulta a seguir ajuda a saber se os usuários conseguiram inserir no sistema informações sobre o consumo de mercadorias em valor superior à quantidade de mercadorias recebidas:

SELECT product_id, SUM(in_sum) AS income_sum, SUM(out_sum) AS result_sum

FROM (SELECIONE id_produto, valor*preço como soma_entrada, 0 como soma_saída
de m_renda
UNIÃO TODOS
SELECIONE product_id, 0 como in_sum, quantidade*preço como out_sum
de m_resultado) AS t
GRUPO POR product_id
TENDO SOMA(em_soma)
Consulta Q052. A numeração das linhas retornadas por uma consulta é implementada de diferentes maneiras. Por exemplo, você pode renumerar as linhas de um relatório preparado no MS Access usando o próprio MS Access. Você também pode renumerar usando linguagens de programação, por exemplo, VBA ou PHP. No entanto, às vezes isso precisa ser feito na própria consulta SQL. Portanto, a consulta a seguir numerará as linhas da tabela m_income de acordo com a ordem crescente dos valores do campo ID:

SELECIONE COUNT(*) como N, b.id, b.product_id, b.amount, b.price

FROM m_income a INNER JOIN m_income b ON a.id GROUP BY b.id, b.product_id, b.amount, b.price;

Consulta Q053. Os cinco principais produtos entre os produtos por valor de vendas são exibidos. Os primeiros cinco registros são impressos usando a instrução TOP:

SELECIONE TOP 5, product_id, soma(valor*preço) AS soma

DE m_resultado
GRUPO POR product_id
ORDER BY soma(quantidade*preço) DESC;

Consulta Q054. Os cinco principais produtos entre os produtos por valor de vendas são exibidos e as linhas são numeradas como resultado:

SELECIONE CONTAGEM(*) COMO N, b.product_id, b.summa

DE


DE m_outcome GROUP BY product_id) COMO um
JUNÇÃO INTERNA
(SELECIONE id_produto, soma(valor*preço) AS soma,
summa*10000000+product_id AS id
DE m_outcome GRUPO POR product_id) AS b
EM a.id>=b.id
GRUPO POR b.product_id, b.summa
TENDO CONTAGEM(*)ORDEM POR CONTAGEM(*);

Consulta Q055. A consulta SQL a seguir mostra o uso das funções matemáticas COS, SIN, TAN, SQRT, ^ e ABS no MS Access SQL:

SELECT (selecione contagem(*) de m_income) como N, 3,1415926 como pi, k,

2*pi*(k-1)/N como x, COS(x) como COS_, SIN(x) como SIN_, TAN(x) como TAN_,
SQR(x) como SQRT_, x^3 como "x^3", ABS(x) como ABS_
FROM (SELECIONE CONTAGEM(*) AS k
FROM m_income AS a INNER JOIN m_income AS b ON a.idGROUP BY b.id) t;

Consulta SQL. Exemplos em MS Access. ATUALIZAÇÃO: 1-10

Solicitar U001. A seguinte consulta de alteração SQL aumenta os preços dos produtos com código 3 na tabela m_income em 10%:

ATUALIZAÇÃO m_income SET preço = preço*1,1

ONDE id_produto=3;

Solicitar U002. A seguinte consulta de atualização SQL aumenta a quantidade de todos os produtos na tabela m_income em 22 unidades cujos nomes começam com a palavra “Petróleo”:

ATUALIZAR m_renda SET valor = valor+22

WHERE product_id IN (SELECT id FROM m_product WHERE title LIKE "Óleo*");

Solicitar U003. A seguinte consulta SQL para uma alteração na tabela m_outcome reduz os preços de todos os produtos fabricados pela Sladkoe LLC em 2 por cento:

ATUALIZAR m_outcome SET preço = preço*0,98

ONDE product_id ESTÁ
(SELECIONE a.id FROM m_product a INNER JOIN m_supplier b
EM a.supplier_id=b.id ONDE b.title="LLC"Сладкое"");. !}

SQL é uma das linguagens de programação mais comuns para criar e gerenciar um banco de dados, bem como para realizar diversas ações com os próprios dados.

Como mostra a prática, é bastante fácil de aprender e aproveita ao máximo o vocabulário padrão do inglês. Como qualquer outra linguagem de programação, SQL possui lógica e sintaxe próprias, um conjunto de comandos básicos e regras para seu uso.

Classificação de comandos SQL

Todos os padrões podem ser considerados com base em sua finalidade. Os seguintes conjuntos podem ser tomados como base para a classificação informal:

Comandos para construção de consultas.

Comandos de procedimentos e funções integrados.

Comandos para gatilhos e tabelas de sistema.

Conjuntos de combinações para trabalhar com variáveis ​​de data e string.

Comandos para trabalhar com dados e tabelas.

Essa classificação pode continuar indefinidamente, mas os principais conjuntos de comandos SQL serão construídos precisamente com base nesses tipos.

Ao considerar a classificação da linguagem, não se pode deixar de mencionar que ela é universal, como evidencia a abrangência de seu uso. Esta linguagem de programação e suas variantes são utilizadas não apenas no ambiente padrão, mas também em outros programas que, de uma forma ou de outra, você utilizou.

O escopo do uso do SQL pode ser visto do ponto de vista do software de escritório, ou seja, o MicrosoftAccess. Esta linguagem, ou mais precisamente, sua versão - MySQL, permite administrar bancos de dados na Internet. Até mesmo o ambiente de desenvolvimento Oracle usa comandos SQL no centro de suas consultas.

Usando SQL no Microsoft Access

Um dos exemplos mais simples de uso de uma linguagem para programação de banco de dados é o pacote de software Microsoft Office. O estudo deste produto de software está incluído no curso escolar de informática e, no décimo primeiro ano, é discutido o sistema de gerenciamento de banco de dados MicrosoftAccess.

É aprendendo esta aplicação que os alunos se familiarizam com a linguagem de desenvolvimento de banco de dados e adquirem uma compreensão básica de tudo o que está envolvido. Os comandos SQL do Access são bastante primitivos, é claro, se você os considerar em um nível profissional. A execução desses comandos é muito simples e são criados em um editor de código customizado.

Vejamos um exemplo específico:

SELECIONE Pe_SobreNome

ONDE Pe_Nome = "Maria";

Com base na sintaxe do comando, você pode entender que ele retornará ao usuário o sobrenome de uma pessoa, no caso uma mulher chamada Mary, que está armazenada na tabela do banco de dados de Contatos.

Embora o uso de SQL no Access seja limitado, às vezes essas consultas simples podem simplificar bastante a tarefa em questão.

Usando comandos SQL no Oracle

A Oracle é provavelmente o único concorrente sério do Microsoft SQL Server. É este ambiente de desenvolvimento e gestão que conduz constantemente à melhoria das funções do produto de software da Microsoft, uma vez que a competição é o motor do progresso. Apesar da competição constante, as equipes de SQL da Oracle replicam o SQL. Vale ressaltar que embora o Oracle seja considerado uma cópia quase completa do SQL, a lógica desse sistema e da linguagem como um todo é considerada mais simples.

O sistema Oracle, ao utilizar um determinado conjunto de comandos, não possui uma estrutura tão complexa. Considerando as capacidades desses ambientes de desenvolvimento de banco de dados, a Oracle não possui uma estrutura de consulta aninhada complexa.

Essa diferença permite agilizar muitas vezes o trabalho com os dados, mas, ao contrário, leva ao uso irracional da memória, em alguns casos individuais. A estrutura do Oracle é construída principalmente em tabelas temporárias e seu uso. Por exemplo: os comandos SQL neste sistema são construídos por analogia com os padrões da própria linguagem SQL, embora sejam ligeiramente diferentes dela.

SELECTCONCAT(CONCAT(CONCAT('Funcionário', nome), CONCAT(SUBSTR(fnome, 0, 1), SUBSTR(otch, 0, 1)), CONCAT('aceito', dataaceita)) FROM funcionários WHERE dataaceita > até_data ( '01.01.80′,'dd.mm.aaaa');

Esta consulta retornará dados sobre funcionários que foram contratados em um determinado período de tempo. Embora a estrutura da consulta seja diferente, a execução dos comandos SQL nesses sistemas é semelhante, exceto por pequenos detalhes.

Usando SQL na Internet

Com o advento da World Wide Web, ou seja, da Internet, o escopo de utilização da linguagem SQL está se ampliando. Como você sabe, muitas informações são armazenadas na rede, mas não são localizadas aleatoriamente, mas sim colocadas em sites e servidores de acordo com determinados critérios.

Os bancos de dados são os responsáveis ​​diretos pelo armazenamento de informações na Internet, como em outros locais, e os sites são sistemas de gerenciamento. Via de regra, os sites e seus códigos de programas são organizados em diferentes linguagens de programação, mas os bancos de dados são baseados em uma das variedades de SQL, ou seja, a linguagem de criação de banco de dados, orientada para interfaces web MySQL.

A sintaxe e o conjunto básico de comandos desta linguagem copiam completamente o SQL familiar, mas com alguns acréscimos próprios, que o diferenciam do Microsoft tSQL Server.

Os comandos SQL são completamente semelhantes não apenas na sintaxe, mas também no conjunto padrão de palavras funcionais. A única diferença está na chamada e estruturação da solicitação. Por exemplo, você pode considerar uma solicitação para criar uma nova tabela; esta é a primeira coisa que as crianças aprendem nas escolas de ciência da computação:

$link = mysqli_connect("localhost", "root", "", "testador");

if (!$link) die("Erro");

$query = "criar tabela users(

entrar VARCHAR(20),

senha VARCHAR(20)

if (mysqli_query($link, $query)) echo "A tabela foi criada.";

elseecho "Tabela não criada: ".mysqli_error();

mysqli_close($link);

Como resultado da execução de tal consulta, você poderá obter uma nova tabela “Usuários”, que terá dois campos: login e senha.

A sintaxe foi modificada para a Web, mas é baseada em comandos MicrosoftSQLServer.

Construindo consultas MicrosoftSQLServer

Selecionar tabelas de um conjunto de dados específico é uma das principais tarefas do SQL. O comando select em SQL é fornecido para tais operações. Isto é o que será discutido abaixo.

As regras para construir um comando são muito simples, e o próprio comando select em SQL é construído da seguinte maneira. Por exemplo, existe uma tabela que contém dados sobre um funcionário, que, por exemplo, tem o nome Pessoa. Vamos definir a tarefa de que da tabela você precisa selecionar dados sobre funcionários cuja data de nascimento esteja no intervalo de primeiro de janeiro a primeiro de março do ano corrente, inclusive. Para tal seleção, é necessário executar um comando SQL, que conterá não apenas a construção padrão, mas também a condição de seleção:

Selecione * da pessoa

Onde P_BerthDay >= ‘01/01/2016’ e P_BerthDay<= ‘03/01/2016’

A execução de tal comando retornará todos os dados sobre os funcionários cujo aniversário ocorre no período que você especificou. Às vezes, a tarefa pode ser exibir apenas o sobrenome, nome e patronímico de um funcionário. Para fazer isso, você precisa construir a solicitação de uma forma um pouco diferente, por exemplo, desta forma:

SelecioneP_Nome - nome

P_SurName - sobrenome

P_Patronímico - patronímico

Onde P_BerthDay >= ‘01/01/2016’ e P_BerthDay<= ‘03/01/2016’

No entanto, esta é apenas uma escolha de algo. Em essência, não afeta nada, apenas fornece informações. Mas se você decidir levar a sério a linguagem SQL, terá que aprender como fazer alterações nos bancos de dados, pois construí-los sem isso é simplesmente impossível. Como isso é feito será discutido abaixo.

Comandos SQL básicos para alteração de dados

A sintaxe da linguagem é construída não apenas para executar consultas, mas também para manipular dados. A principal tarefa de um programador de banco de dados é escrever scripts para seleções e relatórios, mas às vezes é necessário fazer alterações nas tabelas. A lista de comandos SQL para tais ações é pequena e consiste em três comandos principais:

Inserir (trad. Inserir).

Atualização (trad. Atualização).

Excluir (trad. Excluir).

A finalidade desses comandos é fácil de determinar; tudo o que você precisa fazer é traduzir seus nomes. Esses comandos são fáceis de usar e possuem uma estrutura simples, mas vale ressaltar que alguns deles, se utilizados incorretamente, podem causar danos irreparáveis ​​ao banco de dados.

Via de regra, antes de usar esses comandos MSSQL, você precisa pensar bem e levar em consideração todas as possíveis consequências de sua execução.

Tendo aprendido esses comandos, você pode começar a trabalhar totalmente com tabelas de banco de dados, modificando-as e introduzindo algumas novas variáveis ​​​​ou excluindo as antigas.

Inserir comando

Para inserir dados em uma tabela, o comando mais seguro é Inserir. Dados inseridos incorretamente sempre podem ser excluídos e inseridos novamente no banco de dados.

O comando Inserir destina-se a inserir novos dados em uma tabela e permite adicionar um conjunto completo e seletivo.

Por exemplo, considere o comando insert na tabela Person descrita anteriormente. Para inserir dados em uma tabela, você precisa executar um comando SQL que permitirá inserir todos os dados na tabela ou preenchê-la seletivamente.

Inserir na pessoa

Selecione 'Grigoriev','Vitaly','Petrovich','01/01/1988'

Comandos deste tipo preenchem automaticamente todas as células da tabela com os dados especificados. Há situações em que um funcionário não tem nome do meio, digamos, ele veio trabalhar da Alemanha como estudante de intercâmbio. Neste caso, é necessário executar um comando de inserção de dados, que inserirá na tabela apenas o que for necessário. A sintaxe de tal comando será a seguinte:

Inseririntopessoa(P_Nome, P_SurNome,P_BerthDay)

Valores ('David', 'Gancho', '11/02/1986')

Tal comando preencherá apenas as células especificadas e todas as outras terão o valor nulo.

Comando para alterar dados

Para alterar os dados de toda a linha e de algumas células, use o comando Atualizar SQL. Você precisa executar tal comando apenas com uma determinada condição, ou seja, indicar exatamente em qual linha por número você precisa fazer alterações.

O comando Atualizar SQL possui uma sintaxe simples. Para uma utilização correta, deve-se indicar quais dados devem ser alterados, em qual coluna e em qual registro. Em seguida, crie um script e execute-o. Vejamos um exemplo. Precisamos alterar a data de nascimento de David Hooke, que está listado como número 5 na tabela de funcionários.

Defina P_BerthDay = '02/10/1986' onde P_ID = 5

A condição (neste script) não permitirá alterar a data de nascimento em todos os registros da tabela, mas atualizará apenas os necessários.

É este comando que os programadores utilizam com mais frequência, pois permite alterar os dados da tabela sem causar danos significativos a todas as informações.

Comandos para usar procedimentos e funções integrados

Usando a linguagem SQL, você pode não apenas construir consultas, mas também criar mecanismos integrados para trabalhar com dados. Como regra, há momentos em que você precisa usar uma seleção que foi escrita anteriormente no corpo de uma solicitação.

Se você julgar logicamente, precisará copiar o texto da seleção e colá-lo no lugar certo, mas pode fazer com uma solução mais simples. Consideremos um exemplo quando um botão para imprimir um relatório, digamos no Excel, é exibido na interface de trabalho. Esta operação será realizada conforme necessário. Procedimentos armazenados integrados são usados ​​para tais fins. Os comandos neste caso são incluídos em um procedimento e chamados usando o comando SQLExec.

Vamos supor que foi criado um procedimento para exibir a data de nascimento dos funcionários da tabela Pessoa descrita anteriormente. Nesse caso, não há necessidade de redigir a solicitação inteira. Para obter as informações necessárias, basta executar o comando Exec [nome do procedimento] e passar os parâmetros necessários para a amostragem. Como exemplo, podemos considerar o mecanismo de criação de um procedimento desta natureza:

CREATEPROCEDUREPrintPerson

@DBsmalldatetime

@DE smalldatetime

SELECIONE * de Pessoa

DE HumanResources.vEmployeeDepartmentHistory

ONDE P_BerthDay >= @DB e P_BerthDay<= @DE

ANDEndDateISNULL;

Este procedimento retornará todas as informações dos funcionários cujo aniversário será em determinado período de tempo.

Organização da integridade dos dados. Gatilhos

Alguns comandos do MS SQL, pode-se até dizer construções, permitem não apenas organizar manipulações com dados, mas também garantir sua integridade. Para tais fins, a linguagem contém construções de sistema que são criadas pelo próprio programador. Esses são os chamados gatilhos que podem fornecer controle de dados.

Neste caso, comandos de consulta SQL padrão são usados ​​para organizar a verificação de condições. Nos gatilhos, você pode criar diversas condições e restrições para trabalhar com dados, o que ajudará a controlar não apenas o acesso às informações, mas também a proibir a exclusão, alteração ou inserção de dados.

Não há restrições quanto aos tipos de comandos SQL que podem ser usados ​​em um gatilho. Vejamos um exemplo.

Se descrevermos o mecanismo para criar um gatilho, os tipos de comandos SQL aqui são os mesmos da criação de um procedimento. O algoritmo em si será descrito abaixo.

Primeiro de tudo, precisamos descrever o comando de serviço para criação de gatilhos:

Indicamos para qual operação de dados (no nosso caso é uma operação de alteração de dados).

A próxima etapa é especificar as tabelas e variáveis:

declare @ID int. @Date smalldatetime @nID int. @nDatesmalldatetime

DEclare o cursor C1 para selecionar P_ID, P_BerthDay de Inserido

DEclare o cursor C2 para selecionar P_ID, P_BerthDay de excluído

Definimos as etapas de seleção de dados. Depois, no corpo dos cursores escrevemos a condição e a reação a ela:

se @ID = @nID e @nData = "01/01/2016"

sMasseges "A operação não pode ser realizada. A data não é adequada"

Vale ressaltar que um gatilho pode não apenas ser criado, mas também desabilitado temporariamente. Esta manipulação só pode ser realizada por um programador executando os comandos SQL SERVER:

altertablePERSONdisabletriggerall - para desabilitar todos os gatilhos criados para esta tabela e, consequentemente, altertablePERSONenabletriggerall - para habilitá-los.

Esses comandos SQL básicos são os mais comumente usados, mas suas combinações podem ser variadas. SQL é uma linguagem de programação muito flexível e oferece ao desenvolvedor o máximo de possibilidades.

Conclusão

Do exposto, podemos tirar a única conclusão: o conhecimento da linguagem SQL é simplesmente necessário para quem vai se dedicar seriamente à programação. É a base de todas as operações realizadas na Internet e em bancos de dados domésticos. É por isso que um futuro programador deve conhecer muitos comandos desta linguagem, pois só com a ajuda deles é possível, por assim dizer, comunicar-se com um computador.

É claro que existem desvantagens, como tudo neste mundo, mas são tão insignificantes que simplesmente empalidecem em comparação com as vantagens. Entre todas as linguagens de programação, o SQL é praticamente o único do gênero, porque é universal, e o conhecimento de escrita de scripts e códigos está na base de quase todos os sites.

A principal vantagem do SQL pode, sem dúvida, ser considerada a sua simplicidade, pois, afinal, está inserido no currículo escolar. Mesmo um programador iniciante que não entende de linguagens pode lidar com isso.

A linguagem SQL não possui as funções de uma linguagem de desenvolvimento completa, mas é focada no acesso a dados, por isso está incluída nas ferramentas de desenvolvimento de programas. Neste caso é chamado SQL incorporado. O padrão de linguagem SQL é suportado por implementações modernas das seguintes linguagens de programação: PL/1, Ada, C, COBOL, Fortran, MUMPS e Pascal.

Nos sistemas especializados de desenvolvimento de aplicações do tipo cliente-servidor, o ambiente de programação é, além disso, normalmente complementado com ferramentas de comunicação (estabelecimento e desconexão de conexões com servidores de banco de dados, detecção e processamento de erros ocorridos na rede, etc.), ferramentas para desenvolvimento interfaces de usuário, ferramentas de design e depuração

Existem dois métodos principais para usar SQL incorporado: estático e dinâmico.

No estático uso da linguagem (SQL estático) O texto do programa contém chamadas para funções da linguagem SQL, que são rigidamente incluídas no módulo executável após a compilação. As alterações nas funções chamadas podem ocorrer no nível de parâmetros de chamada individuais usando variáveis ​​de linguagem de programação.

No dinâmico uso da linguagem (SQL dinâmico) assume-se que as chamadas para funções SQL são construídas dinamicamente e a interpretação dessas chamadas, por exemplo, acessando dados de um banco de dados remoto, durante a execução do programa. O método dinâmico costuma ser utilizado nos casos em que a aplicação não conhece previamente o tipo de chamada SQL e é construído em diálogo com o usuário.

O principal objetivo da linguagem SQL (assim como de outras linguagens para trabalhar com bancos de dados) é preparar e executar consultas. Como resultado da amostragem de dados de uma ou mais tabelas, pode-se obter um conjunto de registros, denominado apresentação.

Desempenhoé essencialmente uma tabela formada como resultado da execução de uma consulta. Podemos dizer que é um tipo de consulta armazenada. Você pode construir múltiplas visualizações usando as mesmas tabelas. A visualização em si é descrita especificando o identificador da visualização e a solicitação que deve ser feita para obtê-la.

Para facilitar o trabalho com visualizações, o conceito de cursor foi introduzido na linguagem SQL. Cursoré um tipo de ponteiro usado para percorrer conjuntos de registros ao processá-los.

A descrição e uso de um cursor em SQL é a seguinte. Na parte descritiva do programa, uma variável do tipo cursor (CURSOR) está associada a uma instrução SQL (geralmente uma instrução SELECT). Na parte de execução do programa, o cursor é aberto (OPEN<имя курсора», перемещение курсора по записям (FETCI-1 <имя курсора>...), seguido do processamento apropriado e finalmente fechando o cursor (CLOSE<имя курсора>).

Nos SGBDs relacionais, para realizar operações sobre relações, são utilizados dois grupos de linguagens, que têm como base matemática as linguagens de consulta teórica propostas por E. Codd:

Álgebra relacional;

Cálculo relacional.

Em álgebra relacional Os operandos e resultados de todas as ações são relações. As linguagens de álgebra relacional são procedimentais porque a relação resultante de uma consulta em um banco de dados relacional é avaliada pela execução de uma sequência de operadores relacionais aplicados às relações. Os operadores consistem em operandos, que são relações, e operações relacionais.

As operações de álgebra relacional Codd podem ser divididas em dois grupos: teoria dos conjuntos básica e relacional especial. O primeiro grupo de operações inclui as operações clássicas da teoria dos conjuntos: união, diferença, interseção e produto. O segundo grupo representa o desenvolvimento de operações ordinárias da teoria dos conjuntos voltadas para problemas reais de manipulação de dados e inclui as operações: projeção, seleção, divisão e conexão;

Linguagens de cálculo são não procedimentais (descritivos ou declarativos) e permitem que as consultas sejam expressas usando um predicado de primeira ordem (instruções de função) que as tuplas ou domínios relacionais devem satisfazer. Uma consulta ao banco de dados executada usando essa linguagem contém apenas informações sobre o resultado desejado. Essas linguagens são caracterizadas pela presença de conjuntos de regras para escrever consultas. Em particular, SQL pertence às linguagens deste grupo.

Recursos do aplicativo Consultas SQL

Uma consulta SQL é uma consulta criada usando uma instrução SQL. Exemplos de consultas SQL são consultas de junção, consultas de servidor, consultas de controle e consultas subordinadas.

Uma consulta de junção é uma consulta que combina campos (colunas) de uma ou mais tabelas ou consultas em um único campo ou coluna no conjunto de resultados de registros. Por exemplo, seis vendedores fornecem à gerência um inventário de seu estoque todos os meses. Ao criar uma consulta de junção, você pode combinar esses inventários em um conjunto de registros de resultados e, em seguida, desenvolver uma consulta de criação de tabela com base na consulta de junção.

Uma solicitação ao servidor transmite comandos SQL via ODBC para um servidor, por exemplo, Microsoft SQL Server. As consultas do servidor permitem que você trabalhe diretamente com tabelas no servidor, em vez de juntá-las. O resultado de uma solicitação ao servidor pode ser o carregamento de registros ou a alteração de dados.

Uma consulta de controle cria ou modifica objetos de banco de dados, como tabelas do Access ou do SQL Server.

Uma subconsulta consiste em uma instrução SQL SELECT dentro de outra consulta de seleção ou alteração. Estas instruções são inseridas na linha “Campo” do formulário de solicitação para definir um novo campo ou na linha “Condição de Seleção” para definir a condição de seleção do campo. Subconsultas são usadas para fazer o seguinte:

Verificar em uma subconsulta a existência de alguns resultados utilizando as palavras reservadas EXISTS ou NO EXISTS;

Pesquisa na consulta principal quaisquer valores que sejam iguais, maiores ou menores que os valores retornados na subconsulta (usando as palavras reservadas ANY, IN ou ALL);

Criação de subconsultas dentro de subconsultas (subconsultas aninhadas).

A linguagem SQL no Access pode ser utilizada para desenvolver formulários de tela, relatórios, bem como para criar macros e programas VBA.

Relação entre as linguagens QBE e SQL

No Access, existe uma estreita relação entre as linguagens QBE e SQL. As tabelas de consulta (formulários) na linguagem QBE, preenchidas pelo usuário, são convertidas em expressões SQL antes da execução imediata. Ou seja, a linguagem SQL é um padrão interno para execução de consultas. Este mecanismo tem a vantagem de permitir ao sistema Access unificar a preparação de consultas para execução em computadores locais e remotos. Neste último caso, a mensagem SQL é realmente transmitida ao computador - o servidor de solicitação.

No Access, uma consulta pode estar em um dos três modos (estados): Design, SQL e Tabela. O modo Design é usado para desenvolver uma nova consulta do zero (sem usar assistentes ou outras ferramentas) ou para alterar o layout de uma consulta existente. O modo SQL é usado para inserir ou visualizar instruções SQL. O modo tabela é usado para trabalhar com resultados de consulta.

SQL em formulários e relatórios

As principais fontes de registros em exibições e relatórios são tabelas e consultas. No segundo caso, a solicitação pode ser uma consulta ao banco de dados pronta ou criada no desenvolvimento de um formulário ou relatório.

SQL em macros

Os comandos de macro fazem parte das macros usadas para automatizar a execução de ações repetidas com frequência no trabalho com um banco de dados. Uma macro é um ou mais comandos de macro com argumentos.

As macros são chamadas a partir da janela do banco de dados ou automaticamente quando ocorrem determinados eventos. O evento que aciona uma macro pode ser, por exemplo, o clique de um botão na área do formulário ou a abertura de uma janela de banco de dados. Além de executar determinadas ações em objetos de banco de dados, as macros podem chamar outras macros, programas do Visual Basic e aplicativos externos.

Dos muitos comandos de macro, dois comandos de macro estão diretamente relacionados ao SQL: Executar Consulta SQL (Executar SQL) e Consulta Aberta (OpenQuery)

Comando macro Executar consulta SQL executa uma consulta de alteração ou controle do Access usando a instrução SQL apropriada. Esta macro possibilita realizar ações em uma macro sem primeiro salvar as consultas. Você também pode executar consultas salvas usando a macro.

Solicitações de mudança são instruções SQL que implementam as seguintes funções: adição (INSERT INTO), exclusão (DELETE), criação de tabela (SELECT...INTO) e atualização (UPDATE)

Solicitações de controle são instruções SQL que executam as seguintes funções: criar uma tabela (CREATE TABLE), modificar uma tabela (ALTER TABLE), eliminar uma tabela (DROP TABLE), criar um índice (CREATE INDEX) e eliminar um índice (DROP INDEX)

O único e obrigatório argumento do comando macro Executando uma consulta SQLé uma instrução SQL. Argumento de macro como texto SQL - as instruções são inseridas manualmente na janela de entrada de macro ou copiadas da janela SQL, o que geralmente é mais conveniente.

Comando macro OpenRequest permite que você abra uma consulta selecionada ou cruzada (nos modos de tabela, design e visualização), execute uma consulta para alterar ou inserir dados.

A macro especifica três argumentos: nome da solicitação, modo e modo de dados. O primeiro argumento especifica o nome da solicitação a ser aberta e é obrigatório. O segundo argumento especifica o modo de abertura da consulta (Tabela, Design e Visualização). O terceiro argumento descreve o modo de entrada de dados na solicitação ("Adicionar", "Alterar" e "Somente leitura")

SQL em programas VBA

O VBA, assim como as macros, foi projetado para automatizar operações repetitivas em objetos de banco de dados Access.

No Access, existem as seguintes maneiras de executar programas VBA:

Incluir um programa no procedimento de processamento de eventos;

Chamando uma função em uma expressão;

Chamar um procedimento Sub em outro procedimento ou em uma janela de depuração;

Executando o comando macro RunCode (RunCode) em uma macro.

As funções são usadas em expressões que definem campos calculados em formulários, relatórios ou consultas. As expressões são usadas para especificar condições em consultas e filtros, bem como em macros, instruções e métodos VBA e instruções SQL. Um procedimento Sub pode incluir sub-rotinas públicas do VBA que são chamadas de outros procedimentos.

Vejamos como executar uma consulta de banco de dados usando instruções SQL em um programa Visual Basic for Applications.

A solicitação seleciona registros do banco de dados que satisfaçam determinadas condições (solicitação de seleção) ou emite instruções para executar ações específicas com registros que satisfaçam determinadas condições (solicitação de alteração).

Existem as seguintes maneiras de executar consultas:

Chamar o método Execute (para executar consultas SQL para alterações);

Criação e execução de um objeto QueryDef especial;

Usando uma instrução SQL como argumento para o método OpenRecordset;

Execute o método OpenRecordset em um objeto QueryDef existente;

Chamando métodos RunSQL e OpenQuery.

Método de execução usado se você precisar fazer uma alteração no banco de dados que não retorne registros. Por exemplo, operações de inserção ou exclusão de registros.

Objeto QueryDef representa uma definição de consulta salva no banco de dados. Pode ser considerado uma instrução SQL compilada.

Método OpenRecordset usado para abrir um objeto do tipo Recordset para executar operações subsequentes nele.

Método RunSQL executa uma macro Executando uma consulta SQL no programa VBA

Método OpenQuery executa o comando macro OpenQuery em um programa VBA. Com ele, você pode abrir uma consulta no modo Folha de Dados, Design ou Visualização. Isso define um dos seguintes modos para trabalhar com dados: adição, alteração ou somente leitura.

A escolha da opção de execução da consulta é determinada pelo programador, levando em consideração as características do problema a ser resolvido.

Criando uma tabela Power Design usando DDL

Todas as etapas de definição do banco de dados que podem ser executadas usando uma ferramenta RAD como o Access também podem ser executadas usando SQL. Nesse caso, em vez de clicar nos itens do menu, você insere comandos usando o teclado. Aqueles que preferem manipular objetos gráficos consideram as ferramentas RAD fáceis e naturais de entender e aprender. Outros, que preferem colocar palavras em frases que tenham uma certa lógica, acreditam que os comandos SQL são mais fáceis e naturais. Como algumas coisas são fáceis de representar usando o paradigma de objetos e outras são fáceis de manipular usando SQL, é útil ter um bom conhecimento de ambos os métodos.

As seções a seguir usarão SQL para executar as mesmas ações de criação, modificação e eliminação de tabelas que a seção anterior usou a ferramenta RAD para executar.

Usando SQL com Microsoft Access

O Access foi projetado como uma ferramenta de desenvolvimento rápido de aplicativos (RAD) que não requer programação. Embora você possa escrever e executar comandos SQL diretamente no Access, você também pode fazer isso pela porta dos fundos. Para abrir o editor principal, que é usado para inserir o código SQL, siga estas etapas:

1. Abra o banco de dados e selecione Consultas na lista Objetos.
2. No painel de tarefas, localizado no lado direito da janela, selecione a opção Criar uma consulta no modo design. A caixa de diálogo Adicionar tabela é exibida.
3. Selecione qualquer uma das tabelas, clique nos botões Adicionar e Fechar. Ignore o cursor que pisca na janela de consulta recém-criada.
4. No menu principal do Access, selecione Exibir modo SQL. Uma janela do editor aparece com a instrução SQL SELECT inicial.
5. Remova a instrução SELECT e insira a instrução SQL necessária.
6. Ao terminar, clique no ícone Salvar. O Access solicita que você insira um nome para a consulta que acabou de criar.
7. Insira um nome para a solicitação e clique em OK.

O comando que você acabou de criar será salvo e executado posteriormente como uma consulta. Infelizmente, o Access não executa toda a gama de comandos SQL. Por exemplo, ele não executa o comando CREATE TABLE. No entanto, depois de criar uma tabela, você poderá realizar quase todas as transformações necessárias nos dados contidos nela.

Criando uma tabela

Ao trabalhar com um SGBD completo, como Microsoft SQL Server, Oracle 9i ou IBM DB2, você deve inserir as mesmas informações ao criar uma tabela usando SQL como faria ao criar uma tabela usando uma ferramenta RAD. A diferença aqui é que a ferramenta RAD ajuda você a fazer isso, fornecendo uma caixa de diálogo de criação de tabela (ou alguma estrutura semelhante) e evitando que você insira nomes, tipos ou tamanhos de campos incorretos. SQL não lhe dará muita atenção. Ao trabalhar com SQL, você deve saber exatamente o que fazer desde o início. Uma instrução CREATE TABLE inteira deve ser inserida antes que o SQL perceba, e muito menos informe se há algum erro na instrução.

O comando a seguir cria uma tabela idêntica à criada anteriormente:

CRIAR TABELA PowerSQL
Número da proposta	INT PEQUENO
Primeiro nome	CARACTER (15),
Sobrenome	CARACTER(20),
Endereço	CARACTER(30),
Cidade	CARACTER(25),
EstadoProvíncia	CARACTER(2),
Código Postal	CARACTER(10),
País	CARACTER(30),
Telefone	CARACTER (14),
Como saber	CARACTER(30),
Proposta	CARACTER(50),
Negócios ou caridade	CARÁTER(1);

Como você pode ver, as informações são essencialmente as mesmas da criação de uma tabela usando ferramentas RAD (conforme descrito anteriormente neste capítulo). Você pode dar preferência a qualquer método de criação de tabelas. Porém, o que há de bom na linguagem SQL é sua versatilidade. A mesma sintaxe padrão funcionará em qualquer sistema de gerenciamento de banco de dados.

Lembrar:
Qualquer esforço investido no aprendizado de SQL será recompensado com o tempo, porque essa linguagem não irá desaparecer rapidamente. E o esforço que você faz para se tornar um especialista em seu ambiente de desenvolvimento provavelmente renderá menos retorno. E não importa quão excelente seja a ferramenta RAD mais recente, tenha certeza de que ela será substituída por uma tecnologia melhor dentro de dois a três anos. Seria ótimo se durante esse período você pudesse recuperar o esforço que fez para aprender este instrumento! Se você puder, use-o. E se não puder, seria mais sensato seguir o remédio antigo, testado e comprovado. O conhecimento de SQL renderá dividendos por muito mais tempo.

O aplicativo MS Access DBMS é um assistente completo para criar e manter bancos de dados incluídos em tabelas e arrays. Se o banco de dados for muito grande, será muito difícil encontrar rapidamente os valores necessários.

É por isso que o Access possui um recurso chamado consultas. Vejamos o que é, como funciona e quais recursos possui.

Criando consultas no Microsoft Access

Para entender como criar consultas no Access, você precisa conhecer os fundamentos de como trabalhar com um SGBD.

Existem duas maneiras de realizar este procedimento:

• Construtor de consultas.
• Assistente de consulta.

O primeiro método permite criar manualmente qualquer uma de todas as consultas disponíveis, mas com a pequena ressalva de que o usuário tem experiência em trabalhar com um aplicativo do Access. Ele também deve compreender pelo menos suas tarefas básicas. Quanto ao segundo método, ele precisa ser considerado com mais detalhes.

Maneira fácil para iniciantes

Uma pessoa experiente, com apenas alguns cliques do mouse, seleciona os componentes que o usuário precisará para concluir a solicitação e, em seguida, cria rapidamente um registro de acordo com os valores-chave coletados. Se este for o primeiro contato com o SGBD e o usuário não tiver ideia de como criar consultas no Access, o programa Wizard será selecionado.

Nesta modalidade você poderá se familiarizar e compreender os seguintes tipos de solicitações:

• Simples.
• Cruzar.
• Registros sem subordinados.
• Entradas duplicadas.

Esta escolha é feita já na primeira fase de trabalho com o Mestre. E no futuro, seguindo instruções claras, até mesmo um usuário novato poderá criar uma solicitação facilmente. Vamos conhecer suas variedades.

Pedido simples

Esta ferramenta de planilha coleta os dados necessários dos campos especificados pelo usuário. O nome por si só já mostra que esse é o tipo de solicitação mais popular para iniciantes. Sua comodidade reside no fato de este procedimento abrir em uma nova aba. Portanto, a resposta à questão de como criar uma consulta no Access 2010 torna-se óbvia após abrir o primeiro menu do Assistente.

Solicitação cruzada

Este tipo de amostragem é mais complexo. Para descobrir como criar uma consulta cruzada no Access usando o “Assistente” neste modo, você precisa clicar nesta função na primeira janela.

Na tela aparecerá uma tabela na qual você poderá selecionar até três colunas localizadas no original.

Um dos campos não selecionados restantes pode ser usado como cabeçalho da tabela de consulta. Na terceira etapa do procedimento (interseção), outro valor é selecionado com uma função de variabilidade (valor médio, soma, primeiro, último).

A foto mostra que a solicitação cruzada foi criada e que as ações necessárias foram tomadas de acordo com os parâmetros especificados.

Entradas duplicadas

Como o nome indica, o objetivo principal desta consulta é selecionar todas as linhas idênticas na tabela de acordo com os parâmetros especificados. Parece assim:

Além disso, você pode selecionar campos adicionais para corresponder a várias linhas de uma só vez.

Para selecionar entradas duplicadas, você precisa expandir a lista de solicitações e criar uma nova pasta lá. A seguir, na janela “Nova Consulta”, selecione a linha “Pesquisar registros duplicados”. Em seguida, você precisa seguir as instruções do Mestre.

Registros sem subordinados

Este é o último tipo de consulta disponível na modalidade Master – Registros sem Escravos.

Neste caso, são selecionados apenas os valores que não estão envolvidos em nenhum campo de tabelas e consultas, mas que já foram criados.

Este tipo é relevante apenas nos casos em que existem vários bancos de dados.

Todos esses quatro tipos de consulta fornecem um ponto de partida básico para trabalhar com elementos complexos, mas facilitam a compreensão de como criar uma consulta em um banco de dados Access.

Funções de consulta no MS Access

Vamos descobrir por que você precisa executar as etapas descritas acima. O objetivo de todas as consultas simples e complexas no Access DBMS é o seguinte:

• Coletar os dados necessários em tabelas e depois visualizar, editar e adicionar novos valores.
• Excelente material de origem para preparar todos os tipos de formulários de relatórios.
• Realização de procedimentos de contagem matemática e estatística em matrizes inteiras de dados com os resultados exibidos na tela (valor médio, soma, desvio, totais).

Solicitação de amostra

Este tipo de trabalho de banco de dados é complexo porque requer a participação de múltiplas tabelas.

É necessário que todas as tabelas tenham campos-chave comuns. Caso contrário, a operação não será possível.

Vamos revisar como criar uma consulta de seleção no Access. Primeiro você precisa criar uma consulta simples com a seleção dos campos obrigatórios. Aqui você pode editar os dados para colocá-los no formato desejado. Aliás, as alterações feitas serão transferidas para as tabelas de origem, portanto este ponto deve ser levado em consideração.

Na janela do designer que se abre, a janela “Adicionar tabelas” é preenchida. Aqui você precisa adicionar as tabelas ou consultas das quais deseja extrair os valores originais.

Após adicionar, você pode começar a preencher as condições da solicitação. Para isso precisamos da string "Campo". Nele você precisa selecionar os valores das tabelas que serão exibidos durante a solicitação.

Para concluir a operação, você precisa clicar no botão “Executar”.

Solicitação com parâmetros

Este é outro tipo de procedimento complexo que exigirá que o usuário tenha certas habilidades em banco de dados. Uma das principais áreas desta ação é a preparação para a criação de relatórios com dados em grande escala, bem como a obtenção de resultados sumários. Como criar consultas no Access 2007 usando o designer será discutido a seguir.

Você precisa iniciar este procedimento de amostragem de dados criando uma consulta simples para selecionar os campos obrigatórios. A seguir, através do modo Designer, deverá preencher o campo “Condição de Seleção” e, com base no valor inserido, será realizada a seleção.

Assim, à questão de como criar uma consulta com um parâmetro no Access, a resposta é simples - insira os parâmetros iniciais para a seleção. Para trabalhar com o Designer, você deve usar o Assistente de Consulta. Lá são criados dados primários para filtragem, que servem de base para trabalhos futuros.

Consulta cruzada avançada

Continuamos a complicar a situação. Ainda mais difícil de entender são as informações sobre como criar consultas no Access se houver várias tabelas de dados. A solicitação cruzada já foi discutida acima como uma das opções para trabalhar com o Master. No entanto, você pode criar uma solicitação semelhante no modo Design.

Para fazer isso, clique em “Query Builder” - “Cruz”.

Um menu para adicionar tabelas de origem é aberto, bem como a capacidade de preencher os campos selecionados. As únicas coisas que você deve prestar atenção são os itens “operação de grupo” e “tabulação cruzada”. Devem ser preenchidos corretamente, caso contrário o procedimento não será concluído corretamente.

As consultas cruzadas são a maneira mais fácil de pesquisar e recuperar informações de diversas fontes de dados, além da capacidade de gerar tabelas e gráficos.

Além disso, ao utilizar este procedimento, a busca é realizada de forma mais rápida, mesmo com diversas opções de desenvolvimento.

Claro, também existem armadilhas que podem interferir no seu trabalho. Por exemplo, ao criar uma consulta para ordenar um banco de dados por valores de colunas, o sistema gera um erro. Ou seja, está disponível apenas a classificação por itens padrão - “crescente e decrescente”.

Resumindo, é preciso dizer que o usuário deve decidir como criar consultas no Access - utilizando o Wizard ou o Designer. Embora, para a maioria das pessoas que usam o SGBD MS Access, a primeira opção seja mais adequada. Afinal, o Wizard fará todo o trabalho sozinho, deixando apenas alguns cliques do mouse para o usuário selecionar as condições da solicitação.

Para usar configurações avançadas, é claramente necessária experiência em banco de dados de nível profissional. Se grandes bancos de dados estiverem envolvidos no trabalho, é melhor entrar em contato com especialistas para evitar interrupções no SGBD e possível perda de dados.

Há um ponto que está disponível apenas para programadores. Como a linguagem principal do SGBD é SQL, a consulta desejada pode ser escrita na forma de código de programa. Para trabalhar neste modo, basta clicar na linha da consulta já criada e selecionar “Modo SQL” no menu de contexto que se abre.

No caso mais simples, a consulta implementa a seleção de campos obrigatórios em uma tabela, registros que atendem às condições de seleção especificadas e a visualização dos resultados da consulta.

Construindo consultas de seleção com condições de seleção

Vejamos as consultas de seleção no Access usando o exemplo de recuperação de informações da tabela PRODUCT do banco de dados Fornecimento de Bens.

Problema 1. Suponha que você precise selecionar uma série de características de um produto pelo nome.

1. Para criar uma consulta na janela do banco de dados, selecione a guia da faixa de opções - Criação(Criar) e no grupo Solicitações(Consultas) clique no botão Construtor de consultas(Desenho de Consulta). Uma janela vazia de solicitação de seleção será aberta no modo de design - SolicitaçãoN(QueryN) e caixa de diálogo Adicionando uma tabela(Mostrar tabela) (Fig. 4.2).
2. Na janela Adicionando uma tabela(Mostrar Tabela) selecione a tabela PRODUCT e clique no botão Adicionar(Adicionar). A tabela selecionada será exibida na área do esquema de dados da consulta. Fechar a janela Adicionando uma tabela(Mostrar Tabela) pressionando o botão Fechar(Fechar).

Como resultado das ações realizadas na janela do designer de consultas (Fig. 4.1), aparecerá no painel superior um esquema de dados de consulta, que inclui as tabelas selecionadas para esta consulta. Neste caso, uma tabela PRODUCT. A tabela é representada por uma lista de campos. A primeira linha da lista de campos da tabela, marcada com um asterisco (*), indica todo o conjunto de campos da tabela. O painel inferior é um formulário de solicitação que deve ser preenchido.

Além disso, uma nova aba (Ferramentas de Consulta | Design) aparece na faixa de opções e é automaticamente ativada (a Figura 4.3 mostra parte desta aba), na qual é destacado o tipo de consulta criada - Amostra(Selecionar). Portanto, por padrão, uma consulta selecionada é sempre criada. Os comandos nesta aba fornecem ferramentas para executar as ações necessárias ao criar uma solicitação. Essa guia é aberta quando você cria uma nova consulta ou edita uma consulta existente no modo Design.

1. Para remover qualquer tabela do esquema de dados da consulta, coloque o cursor do mouse sobre ela e pressione uma tecla. Para adicionar - clique no botão Mostrar tabela(Mostrar tabela) em grupo Configuração de consulta Guia (Configuração da consulta) Trabalhando com solicitações | Construtor(Ferramentas de Consulta | Design) ou execute o comando Adicionar tabela(Mostrar Tabela) no menu de contexto chamado no diagrama de dados da solicitação.
2. Na janela do designer (Fig. 4.4), arraste sequencialmente os campos NAME_IT, PRICE, AVAILABILITY_IT da lista de campos da tabela PRODUCT para as colunas do formulário de solicitação na linha Campo(Campo).
3. Para incluir os campos desejados da tabela nas colunas de consulta correspondentes, você pode usar as seguintes técnicas:
   • na primeira linha do formulário de solicitação Campo(Campo) clique com o mouse para fazer aparecer o botão da lista e selecione o campo desejado na lista. A lista contém os campos das tabelas representadas no esquema de dados da consulta;
   • clique duas vezes no nome do campo da tabela no esquema de dados da consulta;
   • Para incluir todos os campos da tabela, você pode arrastar ou clicar duas vezes no símbolo * (asterisco) na lista de campos da tabela no esquema de dados da consulta.
4. Se você acidentalmente arrastou um campo desnecessário para o formulário de solicitação, exclua-o. Para fazer isso, mova o cursor para a área do rótulo da coluna na parte superior, onde aparecerá como uma seta preta apontando para baixo, e clique com o botão do mouse. A coluna será destacada. Pressione uma tecla ou execute um comando Remover colunas(Excluir colunas) no grupo Configuração de consulta(Configuração da consulta).
5. Em linha Saída para tela(Mostrar) verifique os campos, caso contrário eles não serão incluídos na tabela de consulta.
6. Escreva na linha Condições de seleção(Critérios) nome do produto, conforme formulário de solicitação da Fig. 4.4. Como a expressão na condição de seleção não contém um operador, o operador = é usado por padrão. O valor do texto usado na expressão é inserido entre aspas duplas, que são adicionadas automaticamente.
7. Execute a consulta clicando no botão Executar ou no botão Exibir no grupo Resultados. Uma janela de consulta aparecerá na tela em modo tabela com uma entrada da tabela PRODUCT que atenda às condições de seleção especificadas.

COMENTÁRIO
A janela de consulta na visualização de tabela é semelhante à janela de visualização de tabela do banco de dados. Através de algumas tabelas de consulta, podem ser feitas alterações nos dados da tabela base subjacente à consulta. Uma consulta visualizada no modo Folha de Dados, diferentemente de uma tabela de banco de dados do Access 2010, não possui uma coluna Clique para adicionar(Clique para Adicionar), projetado para alterar a estrutura da tabela. Neste modo, na guia da faixa de opções Lar(Home) os mesmos botões estão disponíveis ao abrir uma tabela de banco de dados.

1. Se você cometeu uma imprecisão ao inserir um nome de produto complexo, o produto não será encontrado na tabela. Usando os operadores curinga - asterisco (*) e ponto de interrogação (?) (padrão ANSI-89, usado por padrão para consultas) ou sinal de porcentagem (%) e sublinhado (_) (ANSI-92, recomendado como padrão para SQL Server ), simplifica a busca pelas strings necessárias e evita muitos erros. Insira Corpus* ou Corpus% em vez do nome completo do produto. Conclua a solicitação. Se no campo nome do produto um valor começar com a palavra “Caso”, o resultado da solicitação será o mesmo do caso anterior. Após executar a consulta, a expressão inserida será complementada com o operador Like “Body*”. Este operador permite que caracteres curinga sejam usados ​​ao pesquisar em campos de texto.
2. Se você precisar encontrar vários produtos, use o operador In. Ele permite verificar a igualdade com qualquer valor da lista, especificada entre parênteses. Escreva In na linha de condições de seleção (“Caso MiniTower”; “HDD Maxtor 20GB”; “FDD 3.5″). A tabela de consulta exibirá três linhas. A instrução In não permite caracteres curinga.
3. Salve sua solicitação clicando na aba Arquivo(Arquivo) e executando o comando Salvar(Salvar). Na janela Salvando(Salvar como) insira o nome da solicitação Exemplo1. Observe que o nome da consulta não deve coincidir não apenas com os nomes das consultas existentes, mas também com os nomes das tabelas no banco de dados.
4. Feche a solicitação atual usando o comando do menu de contexto Fechar(Fechar) ou clicando no botão da janela de consulta Fechar(Fechar).
5. Execute uma consulta salva destacando a consulta no painel de navegação e selecionando o comando no menu de contexto Abrir(Abrir).
6. Para editar uma solicitação, selecione-a na área de navegação e execute o comando no menu de contexto Construtor(Visualização de projeto).

Tarefa 2. Suponha que você precise selecionar produtos cujo preço não seja superior a 1.000 rublos e que o IVA não seja superior a 10%, e também selecionar produtos cujo preço seja superior a 2.500 rublos. O resultado deve conter o nome do produto (NAIM_TOV), seu preço (PRICE) e IVA (RATE_VAT).

1. Crie uma nova consulta no modo de design, adicione a tabela PRODUCT. Na janela do designer (Fig. 4.5), arraste sequencialmente os campos NAME_IT, PRICE, RATE_VAT da lista de campos da tabela PRODUCT para o formulário de solicitação.
2. Escreva Condições de seleção(Critérios), conforme mostrado no formulário de solicitação na Fig. 4.5. Uma operação lógica AND é executada entre condições escritas na mesma linha. Uma operação lógica OR é executada entre condições escritas em linhas diferentes.
3. Conclua a solicitação, clique no botão Executar(Correr) no grupo Resultados(Resultados). Uma janela de consulta aparecerá na tela em modo tabela com registros da tabela PRODUCT que atendam às condições de seleção especificadas.
4. Salve a solicitação executando o comando apropriado no menu de contexto da solicitação, que é chamado quando o cursor é colocado no cabeçalho da solicitação. Dê um nome Exemplo2.

Problema 3. Suponha que precisemos selecionar todas as faturas de um determinado período. O resultado deverá conter o número da fatura (NOM_NAK), código do armazém (CODE_SC), data de envio (DATE_SHIP) e o custo total da mercadoria expedida (SUMMA_INKL).

1. Crie uma nova consulta no modo Design e adicione a tabela INVOICE. Na janela do designer, arraste sequencialmente todos os campos necessários da lista de campos da tabela INVOICE para o formulário de solicitação.
2. Para o campo DATE_OTGR na linha Condições de seleção(Critérios) escreva Entre #01/11/2008# E #03/31/2008#. O operador Between especifica um intervalo de datas (ANSI-92 usa aspas simples ' em vez do sinal #). Além disso, este operador permite especificar um intervalo para um valor numérico.

Para reforçar isso, assista ao vídeo tutorial:

Você pode criar bancos de dados, tabelas, formulários e outros relatórios no MS Access. Este artigo ajudará o usuário a executar consultas SQL no MS Access. Você pode executar as mesmas consultas usadas no SQL para recuperar dados de um banco de dados. Este artigo é destinado a usuários que acabaram de começar a aprender o MS Access e desejam executar consultas SQL no MS Access. A única condição necessária antes de começar é que você tenha acesso ao banco de dados usado na organização.

Passos

O que você vai precisar

• O usuário deve ter acesso ao banco de dados da organização
• O usuário pode entrar em contato com o suporte tecnológico antes de realizar consultas via MS Access

Informações do artigo

Esta página foi visualizada 4443 vezes.

Este artigo foi útil?