LINGUAGEM
SQL :
A Linguagem SQL(Structured Query Language ou (Linguagem
Estruturada de Consulta) é uma linguagem de acesso , seleção e manipulação de
dados utilizada em bancos de dados Relacionais tais como: Oracle, My SQL, MS
SQL SERVER, POSTGREE, SYBASE,MARIADB, etc..
Dentro de um Banco de dados relacional, o armazenamento dos
dados só pode ser feito de uma única forma: TABELAS.
Essas TABELAS são
bidimensionais, ou seja, possuem linhas e colunas baseando-se na teoria da
álgebra relacional da matemática.
Na álgebra relacional temos as operações de UNIÃO,INTERSEÇÃO, SUBTRAÇÃO e PRODUTO
CARTESIANO.
Já na Teoria dos Conjuntos, temos as operações:
PROJEÇÃO, SELEÇÃO ,
UNIÃO e DIVISÃO.
Entendendo estes conceitos, entenderemos a linguagem SQL,
pois basicamente se baseia nessas duas teorias.
Na SQL temos alguns conceitos que separam a linguagem de
acordo com sua Finalidade:
São os Comandos:
DML -> DATA MANIPULATION LANGUAGE (LINGUAGEM DE
MANIPULAÇÃO DE DADOS)
DDL -> DATA DEFINITION LANGUAGE(LINGUAGEM DE DEFINIÇÃO DE
DADOS)
DCL -> DATA CONTROL LANGUAGE(LINGUAGEM DE CONTROLE DE
DADOS)
TCL -> TRANSACTION CONTROL LANGUAGE(LINGUAGEM DE CONTROLE
DE TRANSAÇÕES)
COMANDOS DML:
·
SELECT
·
DELETE
·
UPDATE
·
INSERT
·
E MAIS ALGUNS QUE ENTRAM NA CATEGORIA DE SQL
EXPERT ( NÃO VEM AO CASO NO MOMENTO)
Quando manipulamos dados dentro de um banco de dados
relacional, devemos ter em mente que estamos alterando os dados das tabelas e
objetos de banco de dados, por exemplo, suponhamos que temos a seguinte tabela:
TABELA:
FUNCIONARIOS (NOME DA TABELA).
ID
|
NOME
|
SOBRENOME
|
SALARIO
|
TELEFONE
|
1
|
FULANO
|
SILCA
|
2000000
|
56465464546
|
2
|
GERALDO
|
TESTE |
30000
|
54657878787
|
3
|
NINJA
|
FULANO
|
50000
|
54166465461
|
4
|
CHERADO
|
DA SILVA
|
600000
|
156165651561
|
5
|
TROPEÇO
|
LIMA
|
600000
|
65164546541
|
Desta tabela queremos somente selecionar o nome e o
sobrenome dos funcionários, faríamos da seguinte maneira:
SELECT coluna ( aqui vai o nome da
coluna desejada)
FROM tabela; ( aqui vai o nome da tabela a que a coluna
pertence).
Ou seja:
SELECT nome
FROM funcionários;
O resultado dessa consulta seria o seguinte:
NOME
|
FULANO
|
GERALDO
|
NINJA
|
CHERADO
|
TROPEÇO
|
Somente os nomes dos funcionários seria retornado, isso se
denomina no SQL PROJEÇÃO, pois eu
estou PROJETANDO no meu SELECT as colunas que desejo buscar, logo entenda
SELECT como PROJEÇÃO.
Mas e caso o que quiséssemos fosse buscar somente um nome
específico dentro da nossa tabela e não todos os nomes como a consulta acima
faz?
Bom, nesse caso, devemos utilizar a operação da teoria de
álgebra relacional SELEÇÃO (ATENÇÃO! NÃO
CONFUNDA SELEÇÃO COM SELECT, AFINAL SELECT FAZ UMA PROJEÇÃO).
Já que na consulta acima realizamos uma PROJEÇÃO dos campos a serem
recuperados pela consulta, vamos agora realizar uma SELEÇÃO desses dados:
Suponha que queiramos buscar apenas o nome ADMIR como
faríamos?
SELECT nome
FROM funcionários
WHERE id = 1;
Neste comando estamos buscando o nome da tabela onde o
número de identificação seja igual á 1, ou seja, após fazer uma projeção do
campo no select realizamos uma seleção de quais ou qual campo deve ser
retornado.
Observe que no campo ID
os números não se repetem NUNCA! E nem DEVEM, pois eles se tratam de uma
coisa essencial e indispensável em qualquer banco de dados relacional:
CHAVE PRIMÁRIA!!
A chave primária é o CONECTOR de uma tabela que não pode ser
repetido, pois, caso isso aconteça quando eu tentar buscar um determinado campo
que seja único ele nunca irá ser retornado, pois, existem mais de uma chave
para cada campo, resumindo, a função da chave primária(a saber por agora) é a
de garantir unicidade de cada registro
para cada linha do banco de dados evitando completamente as chances de
DUPLICIDADE.
Dito isso entenda a partir de agora que WHERE -> SELEÇÃO.
Resultado da consulta:
NOME
|
ADMIR
|
A operação de UNIÃO
pode ser entendida com a união de duas tabelas,
é um ponto bastante extenso do estudo de banco de dados relacional, por
isso vou colocar a ideia aqui e ao final do capitulo os links do que deve ser
pesquisado.
TABELA 1:
FUNCIONARIOS:
ID
|
NOME
|
SOBRENOME
|
SALARIO
|
TELEFONE
|
1
|
FULANO
|
SILCA
|
2000000
|
56465464546
|
2
|
GERALDO
|
TESTE
|
30000
|
54657878787
|
3
|
NINJA
|
FULANO
|
50000
|
54166465461
|
4
|
CHERADO
|
DA SILVA
|
600000
|
156165651561
|
5
|
TROPEÇO
|
LIMA
|
600000
|
65164546541
|
TABELA DOIS : DEPARTAMENTOS
DEP_ID
|
DEPARTAMENTO
|
CIDADE
|
ESTADO
|
1
|
MIS
|
BAURU
|
SP
|
2
|
MKT
|
SÃO PAULO
|
SP
|
3
|
.....
|
BELO HORIZONTE
|
MG
|
4
|
.....
|
MARINGA
|
PR
|
5
|
.....
|
BRASILIA
|
DF
|
Suponha que você deseja fazer uma consulta que traga o nome
FULANO junto com o Departamento e a cidade em que ele trabalha, como faríamos?
SELECT func.nome,
dep.departamento,dep.cidade
FROM funcionários func
JOIN departamentos dep
ON (func.id = dep.dep_id);
Ou seja:
Estamos Projetando o nome que pertence á tabela
“Funcionarios” ( Por isso o ALIAS “func”, para identificar a tabela) e ao
departamento e cidade que pertence á tabela “DEP”, na cláusula FROM indicamos a tabela
funcionários com o ALIAS (APELIDO) func
e no JOIN (UNIAO) a tabela
departamentos com o ALIAS” dep”.
Na cláusula ON especificamos qual é o ponto em comum desses
campos com a tabela, ou seja, o banco identifica através da CHAVE PRIMARIA (
Por isso a importância dela) qual o número que o id do funcionário ADMIR tem e
qual departamento implica nesse número na tabela DEPARTAMENTOS.
Sendo assim o resultado desta consulta seria:
ID
|
NOME
|
DEPARTAMENTO
|
CIDADE
|
1
|
FULANO
|
T.I
|
BAURU
|
EXECUTANDO UM SIMPLES
COMANDO SELECT:
Uma das cláusulas SQL mais utilizadas é o comando SELECT *
FROM.
Este comando significa que estou projetando todas as linhas
da minha tabela (*)
Tendo em mente a tabela FUNCIONÁRIOS seria a mesma coisa que
:
SELECT nome, sobrenome, salario, telefone
FROM funcionários;
Resultado:
ID
|
NOME
|
SOBRENOME
|
SALARIO
|
TELEFONE
|
1
|
FULANO
|
SILCA
|
2000000
|
56465464546
|
2
|
GERALDO
|
TESTE |
30000
|
54657878787
|
3
|
NINJA
|
FULANO
|
50000
|
54166465461
|
4
|
CHERADO
|
DA SILVA
|
600000
|
156165651561
|
5
|
TROPEÇO
|
LIMA
|
600000
|
65164546541
|
SELECT * FROM funcionários;
Resultado:
ID
|
NOME
|
SOBRENOME
|
SALARIO
|
TELEFONE
|
1
|
FULANO
|
SILCA
|
2000000
|
56465464546
|
2
|
GERALDO
|
TESTE
|
30000
|
54657878787
|
3
|
NINJA
|
FULANO
|
50000
|
54166465461
|
4
|
CHERADO
|
DA SILVA
|
600000
|
156165651561
|
5
|
TROPEÇO
|
LIMA
|
600000
|
65164546541
|
Observe que o resultado é exatamente o mesmo, mas vale dizer
que isso somente em termos visuais, quando se lança um comando SELECT * FROM em
um banco de dados o desempenho do banco para realizar a consulta é bem menor do
que especificando exatamente as colunas que se deseja buscar como na clausula:
SELECT nome, sobrenome, salario, telefone
FROM funcionários;
Devido á muitos outros tópicos que se pode falar sobre SQL
que é uma linguagem simples mas completamente extensa, não irei comentar toda a
sua teoria, vou passar algumas funções básicas
e alguma referências do que estudar:
FUNÇÕES SQL BÁSICAS BASEADAS EM ORACLE:
SELECT SUM(2,2)
FROM DUAL; à Resultado:
4 (SOMA)
------------------------------------------------------------------------------------------------------------------------------
SELECT 2+2
FROM dual; à Resultado: 4 (SOMA)
SELECT MOD(3,2)
FROM DUAL à
Resultado: 1 (RESTO DA DIVISAO)
------------------------------------------------------------------------------------------------------------------------------
SELECT DISTINCT colunas
FROM tabela; à
Resultado: (REMOVE TODAS AS DUPLICADAS)
------------------------------------------------------------------------------------------------------------------------------
SELECT CONCAT(‘TESTE’, ‘TESTE2’)
FROM dual; à
Resultado: TESTETESTE2 (CONCATENA)
------------------------------------------------------------------------------------------------------------------------------
SELECT ‘TESTE’ || ‘TESTE2’
FROM dual à
Resultado: TESTETESTE2 (CONCATENA)
Existem muitas outras funções e comandos SQL á serem
estudados para se aprender o básico da SQL.
0 comentários:
Postar um comentário
Agradecemos seus comentários!!!