Há inúmeras linguagens no mercado de informática: linguagens de programação orientadas a objeto, estruturadas, de marcação de texto e por aí vai. Entre elas há uma linguagem que voltada para banco de dados, estamos falando do SQL. SQL (Linguagem de consulta estruturada, em português) é uma linguagem que todo programador, técnico ou administrador de banco de dados deve conhecer. Sua aplicação é extremamente ampla no mercado de banco de dados e programação.
A definição, linguagem de banco de dados é minha e talvez você não encontre outras referências desta forma. Usei este termo pois na prática ela é uma linguagem de banco de dados relacionais.
O que é SQL?
A linguagem SQL (Structure query Language - Linguagem de Consulta Estruturada) é a linguagem padrão ANSI (American National Standards Institute - Instituto Nacional de Padronização Americano) para a operação em bancos de dados relacionais. A linguagem SQL foi criada para atender a todos os bancos de dados relacionais e permitir que usuários possam acessar qualquer banco usando a mesma base de conhecimento.
O que é um banco de dados relacional?
É um tipo de banco onde a sua estrutura ou objetos relacionam-se entre si. Este é o ponto alto dos bancos relacionais, pois ao atrelar um objeto a outro ele se torna muito mais consistente, evitando acidentes com os dados e garantindo a integridade dos mesmos.
O termo muito comum neste tipo de banco é a chamada integridade relacional onde um objeto A relaciona-se com um objeto B atrelando uma chave primária a uma chave estrangeira.
SQL é igual em todos os bancos de dados?
Inicialmente imagina-se que a linguagem SQL seria a mesma para todos os bancos de dados, porém, algumas empresas desenvolvedoras de banco de dados, entre elas a Microsoft e a Oracle, fizeram aperfeiçoamentos na linguagem SQL e acabaram criando versões próprias de acesso ao seu banco de dados.
Geralmente o padrão é chamado de SQL ANSI que é padronizado e serve para qualquer banco de dados. Já os específicos podem ser o PL SQL adotado pela Oracle ou o Transact-SQL adotado pela Microsoft para o seu principal banco de dados.
SQL é a mesma coisa que SQL Server?
Não. SQL é uma linguagem universal para trabalhar com banco de dados relacional, SQL Server é um software de banco de dados da Microsoft.
Se eu aprender SQL poderei trabalhar então com qualquer banco de dados?
Em tese sim, é preciso considerar duas coisas neste caso:
Quais os principais comandos do SQL?
Os comandos DDL - Data Definition Language são : Create, Alter e Drop.
Os comandos DML - Data Manipulation Language são: Select, Insert, Update e Delete.
Dê um exemplo de SQL que rode em todos os bancos de dados?
select * from [tabela]
Dê um exemplo de SQL que seja específico para determinados bancos de dados?
Um caso bem simples é quando você precisa concatenar dois campos. Veja como seria o exemplo em SQL Server e Access.
select campoA + campoB from [tabelas]
Já em MySQL será necessário usar uma função que o concat. Veja o exemplo abaixo:
select concat(campoA, campoB) from [tabelas]
O que significa SGDB?
Significa Sistema Gerenciador de Banco de Dados e é o termo mais corretamente aplicado aos principais softwares de banco, como o Oracle, por exemplo. É comum usar a sigla SGDB para os sistemas ou softwares e o termo base de dados para cada banco em si que eles gerenciam.
Quais os principais SGDB do mercado?
DDL é Data Definition Language, ou Linguagem de Definição de Dados. Faz parte os comandos usados para criar objetos no banco (CREATE), modificar as estruturas de um objeto (ALTER) e apagar objetos (DROP).
Serve para criar objetos no banco, quem podem ser tabelas, visões, procedures, funções, entre outros. O mais comum são é tabela, pois é nela que ficará armazenado os dados.
Veja abaixo um exemplo de como criar uma tabela com o nome colaboradores e com os atributos ou campos: idColaborador, nome, dataNascimento, salario, cidade e estado.
CREATE TABLE colaboradores (idColaborador int primary key identity,
nome varchar(60),
dataNascimento datetime,
salario decimal(10,2),
cidade varchar(60),
estado varchar(30)
);
Existem diversos tipos de campos que podemos usar no SQL Server, veja a lista dos principais:
Uma vez criada, uma tabela poderá sofrer alterações em sua estrutura, para realizar essas alterações usamos o comando ALTER TABLE.
As alterações na estrutura da tabela podem ser para:
Adicionar um campo
Vamos adicionar o campo sexo na tabela colaboradores criada no exemplo acima.
ALTER TABLE colaboradores ADD sexo varchar(10);
Observe que usamos a condição ADD que indica que estamos adicionando.
É possível ainda adicionar mais de um campo de uma mesma vez, para isto basta usar uma vírgula para separar os itens da lista de campos a serem inseridas. Veja o próximo exemplo onde iremos adicionar os campos CPF e RG na tabela colaboradores.
ALTER TABLE colaboradores ADD cpf varchar(20), ADD rg varchar(15);
Alterar um campo
Para alterar o campo sexo já existente, usamos a condição ALTER COLUMN ou MODIFY COLUMN. Exemplo:
SQL Server: ALTER TABLE colaboradores ALTER COLUMN sexo varchar(30);
MySQL: ALTER TABLE colaboradores MODIFY COLUMN sexo varchar(30);
Podemos alterar o tipo e o tamanho, mas não o nome do campo. Veja ainda outro exemplo onde estaremos alterando o tipo de dados do campo cpf.
SQL Server: ALTER TABLE colaboradores ALTER COLUMN cpf int;
MySQL: ALTER TABLE colaboradores MODIFY COLUMN cpf int;
Remover um campo
Para excluir um campo usamos a condição DROP COLUMN. Exemplo:
ALTER TABLE colaboradores DROP COLUMN sexo;
ou ainda
ALTER TABLE colaboradores DROP COLUMN cpf, DROP COLUMN rg;
Para excluir uma tabela do nosso banco de dados, usamos o comando DROP TABLE como no exemplo a seguir.
DROP TABLE colaboradores;
Ao excluir uma tabela todos os dados serão excluídos, naturalmente.
DML é Data Manipulation Language, ou Linguagem de Manipulação de Dados. Faz parte os comandos usados para inserir (INSERT INTO), atualizar (UPDATE), excluir (DELETE) e realizar consultas ao banco (SELECT).
O comando INSERT INTO é usado para inserir dados ou registros em uma tabela criada.
INSERT INTO colaboradores(nome, dataNascimento, salario, cidade, estado)VALUES('José','1965-15-14',1000,'Brasilia','DF');
No caso da coluna idColaborador nós não podemos incluí-la no insert para tentar inserir um valor nesta coluna, pois a mesma foi criada com o Identity, auto_increment ou SERIAL, que faz a geração automática dos valores desta coluna.
Observe que as colunas do tipo texto (nome, cidade e estado) e a coluna do tipo data (dataNascimento) recebem os valores entre (aspas simples ou apóstrofo), porém, na coluna numérica (salário) o valor foi passado sem o uso do apóstrofo.
Sim. Veja o exemplo abaixo:
INSERT INTO colaboradores(nome, dataNascimento)VALUES('João','1960-12-15');
Observe que não usamos todas as colunas da tabela colaboradores criada anteriormente, ou seja, você pode fazer um insert em apenas algumas colunas. Neste caso as demais colunas irão receber valores nulos.
Valores decimais podem ser problemas no insert ou update se não for tratado da forma correta. Veja um exemplo com um ERRO:
INSERT INTO colaboradores(nome, dataNascimento, salario)VALUES('Maria','1954-06-22',1420,52);
O exemplo acima causou um erro porque houve excesso de valores, ou seja, perceba que o valor 1420,52 tem uma vírgula e isto fez com que o banco de dados entendesse como sendo dois valores. Neste caso a vírgula deverá ser substituída por ponto, ao invés de usar 1420,52, use 1420.52.
Agora o exemplo CORRETO:
INSERT INTO colaboradores(nome, dataNascimento, salario)VALUES('Maria','1954-06-22',1420.52);
O comando UPDATE é usado para modificar os dados em uma tabela. No exemplo abaixo o nome José será alterado para José da Silva.
UPDATE colaboradores SET nome='José da Silva'WHERE idColaborador=1;
No exemplo abaixo, alteramos o nome para João da Silva e a cidade para São Paulo, mas é importante observar que esta alteração só irá ocorrer onde o código do colaborador for igual a 2.
UPDATE colaboradores SET nome='João da Silva',cidade='São Paulo'WHERE idColaborador=2;
A cláusula WHERE é usada para criar um filtro, ou seja, para determinar quais as linhas serão afetadas.
CUIDADO: Se você não especificar a cláusula WHERE as modificações serão aplicadas em todas as linhas da tabela, como no exemplo abaixo:
UPDATE colaboradores SET salario=2000;
O comando DELETE é usado para excluir linhas em uma tabela. No exemplo abaixo iremos excluir o colaborador cujo identificador for 1.
DELETE FROM colaboradores WHERE idColaborador=1;
CUIDADO: Se você não especificar a cláusula WHERE todas as linhas da tabela serão excluídas.
No exemplo acima, será excluído a linha em que o código do colaborador for igual a 1. A cláusula WHERE é usada para criar um filtro, ou seja, para determinar quais as linhas serão afetadas. Para excluir todas as linhas de uma tabela use o comando DELETE como no exemplo a seguir:
DELETE FROM colaboradores;
O comando SELECT do SQL é usado para efetuar consultas no banco de dados. Ele é muito extenso com diversas possibilidade e aceita muitos argumentos.
Estrutura do comando SELECT é a seguinte:
Para usar este comando adequadamente será necessário inserirmos uma quantidade de registros para que possamos analisar melhor as variações dele. Os dados abaixo serão inseridos na tabela colaboradores:
INSERT INTO colaboradores(nome,dataNascimento,salario,cidade,estado) VALUES('João da Silva','1965-01-23',1500,'São Paulo', 'SP');INSERT INTO colaboradores(nome,dataNascimento,salario,cidade,estado) VALUES('Paulo da Silva','1968-01-23',1500,'São Paulo', 'SP');
INSERT INTO colaboradores(nome,dataNascimento,salario,cidade,estado) VALUES('Maria da Silva','1970-02-26',2200,'Campinas', 'SP');
INSERT INTO colaboradores(nome,dataNascimento,salario,cidade,estado) VALUES('José da Silva','1963-12-11',1900,'São Paulo', 'SP');
INSERT INTO colaboradores(nome,dataNascimento,salario,cidade,estado) VALUES('Regina da Silva','1981-11-23',3500,'Belo Horizonte','MG');
INSERT INTO colaboradores(nome,dataNascimento,salario,cidade,estado) VALUES('Luis da Silva','1965-10-19',1100,'São Paulo', 'SP');
INSERT INTO colaboradores(nome,dataNascimento,salario,cidade,estado) VALUES('Marcelo da Silva','1981-11-23',8500,'São Paulo', 'SP');
INSERT INTO colaboradores(nome,dataNascimento,salario,cidade,estado) VALUES('Mateus da Silva','1965-04-03',1850,'Sorocaba', 'SP');
INSERT INTO colaboradores(nome,dataNascimento,salario,cidade,estado) VALUES('Vania Maria da Silva','1991-06-06',1500,'São Paulo', 'SP');
INSERT INTO colaboradores(nome,dataNascimento,salario,cidade,estado) VALUES('Pedro da Silva','1965-09-09',1600,'Belo Horizonte', 'MG');
INSERT INTO colaboradores(nome,dataNascimento,salario,cidade,estado) VALUES('Lula da Silva','1990-11-23',1500,'Campinas', 'SP');
INSERT INTO colaboradores(nome,dataNascimento,salario,cidade,estado) VALUES('Obama da Silva','1978-07-28',1700,'São Paulo', 'SP');
INSERT INTO colaboradores(nome,dataNascimento,salario,cidade,estado) VALUES('Luana da Silva','1977-05-23',1500,'São Paulo', 'SP');
INSERT INTO colaboradores(nome,dataNascimento,salario,cidade,estado) VALUES('Adriana Maria da Silva','1972-11-14',1700,'Belo Horizonte', 'MG');
INSERT INTO colaboradores(nome,dataNascimento,salario,cidade,estado) VALUES('Marcos da Silva','1985-03-11',1500,'São Paulo', 'SP');
INSERT INTO colaboradores(nome,dataNascimento,salario,cidade,estado) VALUES('Joana da Silva','1984-01-10',12500,'Sorocaba', 'SP');
INSERT INTO colaboradores(nome,dataNascimento,salario,cidade,estado) VALUES('Marcela da Silva','1983-04-15',1500,'São Paulo', 'SP');
INSERT INTO colaboradores(nome,dataNascimento,salario,cidade,estado) VALUES('Juliana da Silva','1973-11-21',950,'Curitiba', 'PR');
INSERT INTO colaboradores(nome,dataNascimento,salario,cidade,estado) VALUES('Bruno da Silva','1990-06-20',1500,'Campinas', 'SP');
INSERT INTO colaboradores(nome,dataNascimento,salario,cidade,estado) VALUES('Gustavo da Silva','1969-11-03',750,'Belo Horizonte', 'MG');
INSERT INTO colaboradores(nome,dataNascimento,salario,cidade,estado) VALUES('Roberta da Silva','1971-12-07',800,'Curitiba', 'PR');
INSERT INTO colaboradores(nome,dataNascimento,salario,cidade,estado) VALUES('Marília da Silva','1961-11-10',1800,'São Paulo', 'SP');
INSERT INTO colaboradores(nome,dataNascimento,salario,cidade,estado) VALUES('Rose da Silva Maria','1964-06-30',2650,'Campinas', 'SP');
INSERT INTO colaboradores(nome,dataNascimento,salario,cidade,estado) VALUES('Madalena da Silva','1979-07-25',5000,'São Paulo', 'SP');
INSERT INTO colaboradores(nome,dataNascimento,salario,cidade,estado) VALUES('Lucas da Silva','1981-03-19',750,'Belo Horizonte', 'MG');
SELECT *FROM colaboradores;
No exemplo acima, usamos as cláusulas SELECT e FROM. O * (asterisco) indica que todas as colunas da tabela devem ser retornadas.
Em muitos casos é recomendável selecionar algumas colunas apenas e não todas como no exemplo acima, isto deve ser considerado pois quando o tamanho do banco aumentar as consultas poderá ficar lentas em função do grande volume de informações contida nas tabelas.
Para retornar apenas as colunas desejadas, basta indicar os seus nomes na instrução SELECT como no exemplo a seguir, onde selecionamos o nome, salário e cidade.
SELECT nome, salario, cidadeFROM colaboradores;
Veja o exemplo abaixo:
SELECT nome, dataNascimento As Aniversario, cidade As residenciaFROM colaboradores;
É importante observar que a coluna foi renomeada apenas nesta consulta, mas não houve alteração no nome da coluna no banco de dados.
Concatenamos colunas quando queremos unir o resultado de dois campos em um só. Imagine que numa determinada tabela exista o campo nome, sobrenome, rua e numero da casa, neste caso ao fazermos uma consulta seria interessante concatenar o nome com o sobrenome e a rua com o numero da casa.
Mysql:SELECT concat(nome, ' mora em ', cidade, '/', estado
FROM colaboradores;
SQL Server:SELECT nome + ' mora em ' + cidade + '/' + estado
FROM colaboradores;
O sinal + (mais) indica concatenação e deve ser usado para concatenar colunas ou uma coluna com um texto. Só poderá ser concatenado colunas do tipo texto, caso for necessário concatenar colunas do tipo data ou numérico, é necessário fazer a conversão dessas colunas para texto.
Em alguns casos é necessário fazer a conversão dos valores para que a concatenação possa ocorrer. A função CONVERT() do SQL Server é usada para fazer a conversão de valores de uma coluna.
Exemplo 1:SELECT nome + ' ganha ' + convert(varchar, salario)
FROM colaboradores;
Exemplo 2:SELECT nome + ' nasceu em ' + Convert(VarChar, dataNascimento, 103)
FROM colaboradores;
No primeiro caso, estamos convertendo o valor da coluna salário para texto, já que esta coluna é do tipo Decimal.
No segundo exemplo, estamos convertendo o valor de uma coluna do tipo data para texto. Perceba que neste caso usamos o 103 na função, isto é necessário para informarmos que queremos que a data seja convertida no formato dd/mm/aaaa.
Para eliminar linhas duplicadas, usamos a palavra-chave DISTINCT na cláusula SELECT.
SELECT distinct cidadeFROM colaboradores;
No exemplo acima, usamos a palavra-chave distinct na coluna cidade, mas é possível relacionar mais de uma coluna, por exemplo, cidade e estado. Neste caso a combinação das duas colunas deve ser distinta.
Limitar o número de linhas é usado quando não queremos listar todas as linhas de uma tabela, seja pelo volume de linhas ou por não haver necessidade.
Em SQL Server use o Top para indicar o limite de linhas desejado na consulta.
SELECT top 7 *FROM colaboradores;
Em Mysql use o Limit para indicar o limite de linhas desejado na consulta.
SELECT *FROM colaboradores limit 0,7;
O resultado será o mesmo, porém a leitura pode ser um pouco diferente, já que o top vai pegar as sete primeiras linhas e o limit vai pegar a partir de 0 até 7. Lembre-se que todo array, matriz ou vetor tem a linha inicial como 0 e não 1.
Para criar expressões aritméticas em uma consulta SQL usamos os operadores abaixo:
Os operadores acima podem ser usados apenas em colunas do tipo numérico.
Você poderá usar operadores aritméticos em qualquer cláusula, exceto na cláusula FROM.
SELECT nome, salario, salario*12 As salarioAnual
FROM colaboradores;
No exemplo acima multiplicamos o valor da coluna salário por 12 nomeamos a saída de salarioAnual.
Quando usamos vários operadores em uma consulta é importante observarmos qual será a precedência dos operadores.
Na tabela colaboradores temos a coluna salário. Além do salário, cada colaborador irá receber no final do ano um bônus de 200.
Para descobrir quanto esse colaborador irá receber anualmente, temos de multiplicar o salário por 12 meses e adicionar o bônus de 200.
SELECT nome, salario, 12*salario+200 As salarioAnualFROM colaboradores;
No exemplo acima cada colaborador receberia o bônus uma vez no ano, mas vamos considerar agora que o bônus passou a ser mensal.
Neste caso será necessário somar o salário mais o bônus e depois multiplicar por 12. Para resolver esse problema teremos de mudar a precedência e para isto usamos os parênteses, ou seja, tudo que estiver dentro do parêntese é executado primeiro.
Veja o mesmo exemplo com a mudança de precedência:
SELECT nome, salario, 12*(salario+200) As salarioAnualFROM colaboradores;
Os operadores de comparação são usados em condições que comparam uma expressão a outro valor ou expressão. A tabela abaixo mostra os operadores:
SELECT idColaborador, nome, salarioFROM colaboradores
WHERE idColaborador=8;
No exemplo acima, usamos o igual para criar um filtro na cláusula WHERE, este filtro diz que os dados retornados deverão ser do código de colaborador IGUAL a 8.
O uso de um operador lógico faz com que duas condições tenham de produzir um resultado único. Uma linha só poderá ser retornada se o resultado global da condição for verdadeiro.
A tabela abaixo mostra os operadores lógicos disponíveis em SQL:
No exemplo abaixo uma linha será retornada se o colaborador for do estado de SP e o seu salário maior que 2200.
SELECT nome, salario, cidade, estadoFROM colaboradores
WHERE estado='SP' and salario > 2200;
Para produzir um resultado diferente basta alterar esta consulta, trocando o operador AND por OR.
SELECT nome, salario, cidade, estadoFROM colaboradores
WHERE estado='SP' or salario > 2200;
Neste caso uma linha será retornada se o colaborador for do estado de SP ou se o seu salário for maior que 2200.
Filtrar dados com between, like e IN em consultas a banco de dados é uma prática comum e suportada pelos principais bancos de dados, como o SQL Server, Mysql, PostgreSQL, Oracle e outros. Filtros são extremamente úteis para dar performance às consultas, aliviando possíveis sobrecargas no banco de dados.
O Between serve para retornar linhas baseadas em uma faixa de valores. Muito propício para campos do tipo numérico ou data.
Como exemplo poderemos efetuar uma consulta para retornar o salário dos colaboradores que ganham entre 1000 e 5000 ou uma consulta por todos os prédios tombados entre o ano 2000 e 2005.
Veja um exemplo abaixo:
SELECT nome, dataNascimento, cidade, estadoFROM empregados
WHERE dataNascimento between '1975-01-01' and '1985-12-31';
No exemplo as linhas retornadas têm a data de nascimento do colaborador entre 01 de janeiro de 1975 e 13 de dezembro de 1985. (observe que a comparação de data deve ser feita no formato americano).
Além da coluna do tipo data é possível também usar o BETWEEN em uma coluna numérica.
Use a condição IN para retornar linhas cujos valores atendem a uma determinada lista ou a NOT IN para os valores que não atendem a lista.
Entenda por lista valores separados por vírgulas, exemplo: 1,2,3,4 ou 'um','dois','três'.
Esta condição poderia efetuar uma imobiliária encontrar por exemplo, todos os imóveis alugados nas cidades de São Paulo, Rio de Janeiro e Belo Horizonte ou todos os prédios comerciais de luxo disponíveis nos bairros do Broklin, Morumbi e Vila Olímpia.
Veja um exemplo abaixo:
SELECT idColaborador, nome, dataNascimento, cidadeFROM colaboradores
WHERE idColaborador IN(3,7,9,11,14);
Neste exemplo as linhas retornadas têm o valor da coluna idColaborador igual a 3,7,9,11 e 14.
Se trocarmos a condição IN por NOT IN, teremos o resultado inverso.
SELECT idColaborador, nome, dataNascimento, cidadeFROM colaboradores
WHERE idColaborador NOT IN(3,7,9,11,14);
Use a condição LIKE para executar pesquisas curingas.
O caracter curinga %(porcentagem) deve ser usado para substituir um caracter ou grupo de caracteres, não importando a sua natureza.
Esta condição é muito usada na internet para fazer as buscas tradicionais, muito provavelmente como no caso dos sites de busca (google, yahoo, Bing, etc).
SELECT idColaborador, nome, dataNascimento, cidadeFROM colaboradores
WHERE nome LIKE '%Maria%';
Neste exemplo foi mostrado as linhas cujo nome tinha a palavra Maria.
Uma pequena mudança pode ser feita neste código para que os nomes iniciados com Maria sejam mostrados.
SELECT idColaborador, nome, dataNascimento, cidadeFROM colaboradores
WHERE nome LIKE 'Maria%';
O mesmo exemplo pode ainda ser modificado para que os nomes terminados com Maria sejam mostrados:
SELECT idColaborador, nome, dataNascimento, cidadeFROM colaboradores
WHERE nome LIKE '%Maria';
Agora veja o mesmo exemplo com o NOT LIKE.
SELECT idColaborador, nome, dataNascimento, cidadeFROM colaboradores
WHERE nome NOT LIKE '%Maria%';
Neste caso será mostrado todas as linhas, exceto as que tiverem Maria no nome.
Classifique linhas resultantes de uma consulta usando a cláusula ORDER BY.
SELECT idColaborador, nome, dataNascimento, cidadeFROM colaboradores
ORDER BY nome;
O fato de omitirmos o ASC ou DESC indica que o ORDER BY assumirá por padrão ASC. Para classificar em ordem decrescente, basta adicionar DESC.
SELECT idColaborador, nome, salario, cidadeFROM colaboradores
ORDER BY salario DESC;
Você poderá ainda classificar por mais de uma coluna, como estado e cidade, por exemplo. Neste caso basta relacionar as colunas separando-as por vírgula. Ficaria assim:
SELECT idColaborador, nome, dataNascimento, cidadeFROM colaboradores
ORDER BY estado, cidade;
As funções de grupo operam em conjunto de linhas para fornecer um resultado agrupado. Muito útil em tabelas financeiras e matemáticas de maneira geral.
A tabela abaixo mostra as funções de grupo e sua aplicação:
Uma função de grupo geralmente é usada com a cláusula GROUP BY, já que esta cláusula tem a finalidade de criar grupos de dados. Veja os exemplos abaixo:
Para somar o salário e agrupar por cidade:
SELECT cidade, SUM(salario) As totalSalarioFROM colaboradores
GROUP BY cidade;
Para calcular a média de salário e agrupar por cidade:
SELECT cidade, AVG(salario) As salarioMedioFROM colaboradores
GROUP BY cidade;
Para encontrar o maior salário e mostrar o nome do colaborador:
SELECT nome, MAX(salario) As maiorSalarioFROM colaboradores
GROUP BY nome;
Para encontrar o menor salário e mostrar o nome do colaborador:
SELECT nome, MIN(salario) As menorSalarioFROM colaboradores
GROUP BY nome;
Para contar a quantidade de registros de cada estado:
SELECT estado, COUNT(*) As totalColaboradoresFROM colaboradores
GROUP BY estado;
Use a cláusula having para especificar quais grupos serão exibidos e, desta forma, restringir ainda mais os grupos com base nas informações agregadas.
SELECT cidade, Count(cidade) As totalcidadeFROM colaboradores
GROUP BY cidade
HAVING Count(cidade) > 2;
Join é um importante recurso que permite que dados de duas ou mais tabelas possam ser mostradas em uma mesma consulta. Isto é muito útil, pois a maioria dos bancos de dados não se resumem a uma única tabela e sim a várias delas. Desta forma, com o join podermos juntar dados das tabelas clientes, vendas e produtos em um único relatório, por exemplo.
No mínimo duas tabelas e que entre exista um campo em comum, que em modelagem de dados, costumamos chamar de chave primária e chave estrangeira. Veja um exemplo abaixo.
Primeiro vou criar duas tabelas simples no banco de dados: Marcas e Carros.
CREATE TABLE marcas(idMarca int,
nome varchar(100),
paisOrigem varchar(100)
);
CREATE TABLE carros(
idCarro int,
idMarca int,
modelo varchar(100),
ano int,
cor varchar(100)
);
Com as tabelas criadas, vou inserir alguns dados nelas:
insert into marcas values(1,'Volkswagem','Alemanha');insert into marcas values(2,'Ford','EUA');
insert into marcas values(3,'General Motors','EUA');
insert into marcas values(4,'Fiat','Itália');
insert into marcas values(5,'Renault','França');
insert into marcas values(6,'Mercedes Bens','Alemanha');
insert into carros values(1,1,'Fox',2005,'preto');insert into carros values(2,1,'Fox',2008,'preto');
insert into carros values(3,2,'Ecosport',2009,'verde');
insert into carros values(4,2,'KA',2008,'prata');
insert into carros values(5,4,'Punto',2008,'branco');
insert into carros values(6,4,'Uno',2007,'preto');
insert into carros values(7,4,'Stilo',2004,'prata');
insert into carros values(8,4,'Uno',2005,'prata');
insert into carros values(9,4,'Stilo',2008,'verde');
insert into carros values(10,4,'Uno',2009,'branco');
insert into carros values(11,5,'Scenic',2010,'prata');
insert into carros values(12,5,'Megane',2010,'prata');
insert into carros values(13,5,'Scenic',2007,'azul');
insert into carros values(14,7,'Chrysler 300 C',2008,'verde');
Vamos analisar como ficaram as duas tabelas:
SELECT * FROM marcas;SELECT * FROM carros;
Perceba que temos 6 registros na tabela Marcas e 14 registros na tabela Carros. Agora com os dados inseridos, vamos aos exemplos de cross join, inner join, left join, right join e full outer join.
A junção cross join irá juntar todos os registros da tabela marcas com todos os registros da tabela carros, formando um produto cartesiano e de pouca utilidade. Veja o exemplo abaixo:
SELECT marcas.nome, carros.modeloFROM marcas CROSS JOIN carros;
A junção inner join irá juntar os registros da tabela marca que tiver um correspondente na tabela carros. Essa correspondência é feita pelos campos marca que está presente nas duas tabelas. Embora não esteja explícito, mas o campo marca seria a chave primária (na tabela marcas) e chave estrangeira (na tabela carros). Veja o exemplo:
SELECT marcas.nome, carros.modelo, carros.ano, carros.corFROM marcas INNER JOIN carros
ON carros.idMarca = marcas.idMarca;
Apenas 10 registros satisfazem o inner join. Podemos dizer que 10 carros estão associados a alguma marca, enquanto que os demais não.
O left join irá fazer a junção das duas tabelas “dando preferência” aos registros da tabela marcas. Assim, todos os registros da tabela marcas serão mostrados, independente de haver correspondência na tabela carros. Quando não houver correspondência na tabela carros, será mostrado o valor NULL ou nulo. Exemplo:
SELECT marcas.nome, carros.modelo, carros.ano, carros.corFROM marcas LEFT JOIN carros
ON carros.idMarca = marcas.idMarca;
Percebam que as marcas General Motors e Mercedes Bens não tem nenhum carro cadastrado, mesmo assim elas apareceram no resultado.
A junção right join funciona de forma inversa ao left join. Aplica-se o mesmo conceito, porém, de forma invertida. Com o right join será mostrado todos os carros, mesmo aqueles que não estejam associados a nenhum registro da tabela marcas. Exemplo:
SELECT marcas.nome, carros.modelo, carros.ano, carros.corFROM marcas RIGHT JOIN carros
ON carros.idMarca = marcas.idMarca;
Chrysler 300 C é um modelo que está cadastrado em carros, mas não está associado a nenhuma marca.
A junção full outer join seria o mesmo que left join e right join juntas, ou seja, ela irá mostrar todos as marcas e todos os carros, independente de existir valores correspondente na tabela oposta. Veja um exemplo:
SELECT marcas.nome, carros.modelo, carros.ano, carros.corFROM marcas FULL OUTER JOIN carros
ON carros.idMarca = marcas.idMarca;
Transações são unidades lógicas que ocorrem em operações de banco de dados e são responsáveis por manter a consistência, isolamento, coerência e durabilidade dos dados. Sem as transações corre-se o risco de termos dados inconsistentes o que tornaria duvidoso ou questionável qualquer operação de banco e dados.
Imagine uma transação bancária. Você vai a um caixa eletrônico e faz uma transferência de determinado valor da sua conta para a conta de outra pessoa. Depois de você informar o valor e os dados da conta que irá receber o crédito, pelo menos duas operações importantes serão realizadas no banco:
1º – Debitar o valor da sua conta
2º – Creditar o valor na conta destinatária
Mas, e se entre a operação 1 e 2 houver uma falha e o sistema parar justamente no meio? O valor será debitado e não será creditado, certo? Para evitar esse problema existe as transações.
Uma transação poderá ser implícita ou explicita.
A transação implícita inicia quando um dos seguintes comandos são executados: Insert, Update, DELETE, Create, Drop, Alter, entre outros.
A transação explicita é iniciada pelo comando Begin transaction e é encerrada por um dos seguintes comandos:
Exemplos de transações
Primeiro, criaremos uma tabela com a seguinte estrutura:
create table contas(numero varchar(50),
debito decimal(10,2),
credito decimal(10,2)
);
Exemplo de Rollback
Após criar a tabela, a transação será iniciada e um registro será inserido:
begin transactioninsert into contas values('500-x',80,0);
Feito isso, vou executar três instruções em seguida, sendo um deles o comando Rollback para desfazer o insert.
SELECT * FROM contasrollback
SELECT * FROM contas;
Perceba que o primeiro SELECT mostrou que o registro havia sido feito e o segundo SELECT mostrou que o mesmo havia sido desfeito.
Exemplo de Commit
Podemos usar o mesmo exemplo, mas trocando o Rollback pelo Commit. Veja o resultado:
begin transaction;insert into contas values('600-x',110,0);
SELECT * FROM contas;
commit;
SELECT * FROM contas;
Exemplos condicionais de Commit e Rollback
Os exemplos acimas mostram o uso isolado do Commit e Rollback para conformar ou desfazer uma operação no banco de dados, mas podemos fazer isso baseado em uma condição. Essa condição poderá ser a existência ou não de erros durante a transação. O exemplo abaixo explica melhor isso:
SELECT * FROM contasbegin transaction
insert into contas values('1000-x',500,0)
SELECT * FROM contas
insert into contas values('2000-x',0,500)
if @@ERROR <> 0
rollback
else
commit
SELECT * FROM contas;
No exemplo acima faço dois inserts, logo após iniciar uma transação e depois verifico se houve erros. Esta verificação de erros está baseada na variável global @@ERROR que sempre retornará 0 se não houve erros.
Agora, usando a mesma transação acima, vou inserir um erro na segunda instrução insert. (note que o valor está com virgula e isto causará um erro):
SELECT * FROM contasbegin transaction
insert into contas values('3000-x',850,0)
SELECT * FROM contas
insert into contas values('4000-x',0,850,00)
if @@ERROR <> 0
rollback
else
commit
SELECT * FROM contas;
Ao executar novamente o SELECT, notaremos que a transação foi desfeita:
SELECT * FROM contas
Uma View é uma tabela virtual no banco de dados. Em uma view poderemos combinar dados de uma ou mais tabelas, inserir dados ou fazer outras operações DML. Uma view não armazena os dados em si, ou seja, ela sempre ficará dependente da tabela real.
Uma view é criada com o comando create view, conforme o modelo abaixo:
create view fiat asSELECT * FROM carros WHERE idMarca=4;
Criei uma tabela virtual chamada fiat e defini que ela irá acessar a tabela real Carros e filtrará apenas os carros da marca Fiat. O filtro é opcional.
Para usar a view acima, basta fazer um SELECT comum:
SELECT * FROM fiat;
Perceba que fizemos um SELECT comum, como se fiat fosse uma tabela do banco de dados, mas ela é apenas uma tabela virtual. Você poderá fazer filtros dentro da view, conforme mostrado no modelo abaixo:
SELECT * FROM fiatWHERE combustivel='GNV';
Se houver alterações nos dados da tabela, eles serão enxergados normalmente na view. Veja um exemplo abaixo, onde adiciono mais um carro da marca fiat na tabela principal Carros:
insert into carros(marca, modelo, combustivel) values('fiat','Mio','GNV');
Após a alteração acima, vamos ver como ficou a view:
SELECT * FROM fiatWHERE combustivel='GNV';
Como pode perceber uma tabela virtual sempre retornará os dados atuais da tabela. Porém, se houver alterações estruturais na tabela principal, elas não serão atualizadas na view. No exemplo abaixo eu adiciono o campo motor na tabela Carros.
alter table carros add motor varchar(100);
Se dermos um SELECT direto na tabela Carros, veremos que a coluna motor está lá, porém, não foi atualizada na view.
Podemos usar uma tabela virtual para inserir, alterar e excluir dados sem problemas. Veja os exemplos abaixo:
insert into fiat(marca, modelo, cor) values('fiat','Mio','prata');
Executamos a view com o filtro modelo:
SELECT * FROM fiatWHERE modelo='Mio';
Agora a alteração:
update fiat set ano=2011 WHERE modelo='Mio' and cor='prata';
Ao executarmos novamente a view, veremos o valor alterado:
Agora, a exclusão:
DELETE FROM fiat WHERE modelo='Mio';
O resultado abaixo mostra que não há mais o modelo Mio:
COMPARTILHE: Facebook Twitter WhatsApp