Na parte 1 verificamos um pouco da estrutura de um Banco de
Dados, tabelas e registros.
Na segunda parte iremos abordar a recuperação dos dados e
conhecer um pouco sobre a linguagem SQL, em específico as clausulas From e
Select.
Com os bancos de dados podemos armazenar e futuramente
recuperar os dados. Para recuperar os dados utilizamos consultas (ou Queries).
Fazendo uma comparação, as consultas são como os botões
pesquisar em sites e aplicativos: Você digita uma palavra-chave (ou frases) com
o intuito de obter uma resposta (ou resultado).
Em bancos de dados não é diferente, você realiza uma
consulta SQL com o intuito de obter um resultado.
Essa comparação pode ser visualizada na figura 1.
Essa comparação pode ser visualizada na figura 1.
Figura 1 – Comparando mecanismo de busca com consulta SQL.
Nosso Blog é voltado para SQL Server, logo a linguagem de
consulta que abordaremos é o SQL.
Para quem está confuso o SQL Server é um produto da
Microsoft que utiliza a linguagem SQL. Assim como o Oracle é um produto que
também utiliza a linguagem SQL
SQL é uma abreviação de Structured Query Language, em uma
tradução aproximada para Linguagem de Consulta Estruturada. Foi criada pela IBM
por volta dos anos 70.
É uma linguagem padrão ANSI e ISO, baseada no modelo
relacional e que tem como objetivo consultas e gerenciamento de dados.
Quando falamos em consultas surgem duas clausulas: Select e
From.
Considero as principais instruções para quem está iniciando.
Entendendo elas terá facilidade em entender as demais.
A sintaxe segundo o Books Online da Microsoft é a seguinte:
Para a clausula From:
[ FROM { <table_source> } [ ,...n ] ]
<table_source> ::=
{
table_or_view_name [ [ AS ]
table_alias ] [ <tablesample_clause> ]
[
WITH ( < table_hint > [ [ , ]...n ] ) ]
| rowset_function [ [ AS ]
table_alias ]
[ (
bulk_column_alias [ ,...n ] ) ]
| user_defined_function [ [
AS ] table_alias ] ]
| OPENXML
<openxml_clause>
| derived_table [ AS ]
table_alias [ ( column_alias [ ,...n ] ) ]
| <joined_table>
|
<pivoted_table>
|
<unpivoted_table>
|
@variable [ [ AS ] table_alias ]
|
@variable.function_call ( expression [ ,...n ] ) [ [ AS ] table_alias ] [
(column_alias [ ,...n ] ) ]
}
<tablesample_clause> ::=
TABLESAMPLE [SYSTEM] (
sample_number [ PERCENT | ROWS ] )
[
REPEATABLE ( repeat_seed ) ]
<joined_table> ::=
{
<table_source> <join_type>
<table_source> ON <search_condition>
| <table_source>
CROSS JOIN <table_source>
|
left_table_source { CROSS | OUTER } APPLY right_table_source
| [ ( ]
<joined_table> [ ) ]
}
<join_type> ::=
[ { INNER | { { LEFT |
RIGHT | FULL } [ OUTER ] } } [ <join_hint> ] ]
JOIN
<pivoted_table> ::=
table_source PIVOT
<pivot_clause> [ AS ] table_alias
<pivot_clause> ::=
(
aggregate_function ( value_column [ [ , ]...n ])
FOR
pivot_column
IN
( <column_list> )
)
<unpivoted_table> ::=
table_source UNPIVOT
<unpivot_clause> [ AS ] table_alias
<unpivot_clause> ::=
(
value_column FOR pivot_column IN ( <column_list> ) )
<column_list> ::=
column_name [ ,...n ]
Para a clausula Select:
<SELECT statement> ::=
[WITH <common_table_expression> [,...n]]
<query_expression>
[ ORDER BY { order_by_expression | column_position [ ASC | DESC ] }
[ ,...n ] ]
[ <FOR Clause>]
[ OPTION ( <query_hint> [ ,...n ] ) ]
<query_expression> ::=
{ <query_specification> | ( <query_expression> ) }
[ { UNION [ ALL ] | EXCEPT | INTERSECT }
<query_specification> | ( <query_expression> ) [...n ] ]
<query_specification> ::=
SELECT [ ALL | DISTINCT ]
[TOP ( expression ) [PERCENT] [ WITH TIES ] ]
< select_list >
[ INTO new_table ]
[ FROM { <table_source> } [ ,...n ] ]
[ WHERE <search_condition> ]
[ <GROUP BY> ]
[ HAVING < search_condition > ]
Muita informação não é mesmo?
Para questões de aprendizado inicial, vamos resumir as duas
clausulas da seguinte forma:
SELECT
<COLUNA(S)>
FROM
<TABELA>
Na clausula From deve-se indicar o nome da tabela que deseja
consultar.
Na clausula Select deve-se indicar o nome das colunas que
deseja consultar.
O escopo dessas instruções vai alem dessa descrição, por
exemplo, a clausula From não abrange apenas tabelas. Pode referenciar Views,
tabelas derivadas e etc. Mas para fins de aprendizados abordaremos apenas as
tabelas.
Na figura 2 temos um exemplo de tabela e logo em seguida a instrução SQL para consultar essa tabela.
Figura 2 – Exemplo de tabela de Clientes
Código SQL para consultar essa tabela:
SELECT
codigo_cliente
,nome_cliente
FROM
Cliente
Consulta 1.
O resultado dessa consulta são os 10 registros apresentados
na Figura 2.
Note que entre o nome dos campos existe uma virgula (,) que
serve para delimitar (ou separar) os campos.
Se por um acaso necessite-se apenas do nome dos clientes a
consulta ficaria dessa forma:
SELECT
nome_cliente
FROM
Cliente
Consulta 2.
O resultado é apresentado na figura 3.
Figura 3 – Resultado da consulta apenas com o nome do
cliente.
Outra opção é a utilização de asterisco (*) no lugar do nome
dos campos no Select. Seria o equivalente a indicar na consulta “Todos os
campos”. Se a tabela tiver 100 campos, todos retornaram no resultado.
SELECT
*
FROM
Cliente
Consulta 3.
Essa consulta é equivalente a consulta 1. Porem vale lembrar
que a utilização de “*” deve ser realizada com cautela. Para tabelas como a do
nosso exemplo, que contem apenas duas colunas, não há muita diferença. Mas
quando se tem tabelas com grande quantidade de campos, talvez não seja a melhor
escolha, pois pode afetar o desempenho da consulta. Dificilmente irá realizar
uma consulta onde precise listar todos os campos de uma tabela que contenha inúmeros
campos.
Esse post é apenas uma introdução, para se aprofundar recomendo as referencias no final.
Obrigado e até a próxima!
Referencias
Livro:
Microsoft SQL Server 2008 – Fundamentos em T-SQL. Itzik Bem-Gan.
Bookman, 2010.
Books Online:
Select:
From:
Nenhum comentário:
Postar um comentário