21 comandos SQL essenciais e avançados e conteúdos extras

Selecionamos 21 comandos e instruções SQL essenciais o qual todo programador, analistas de dados e Business Inteligence devem conhecer.

Além dos comandos, um e-book grátis sobre banco de dados e livros os quais recomendamos e o mais importante: uma aula com mais de 2 horas de duração sobre SQL.

O que é SQL?

SQL significa “Structured Query Language”, ou “Linguagem de Consulta Estruturada”, em português. Resumidamente, é uma linguagem de programação para lidar com banco de dados relacional (baseado em tabelas). Foi criado para que vários desenvolvedores pudessem acessar e modificar dados de uma empresa simultaneamente, de maneira descomplicada e unificada.

LEIA TAMBÉM: GeekHunter: Maior plataforma brasileira de empregos em TI

A programação SQL pode ser usada para analisar ou executar tarefas em tabelas, principalmente através dos seguintes comandos: inserir (‘insert’), pesquisar (‘search’), atualizar (‘update’) e excluir (‘delete’). Porém, isso não significa que o SQL não possa fazer coisas mais avançadas, como escrever queries (comandos de consulta) com múltiplas informações.

(Fonte: SQL Server Tutorial/Reprodução)

Por que aprender SQL?

Segundo a Dataquest, escola referência em ciência de dados, existem três motivos primordiais pelo qual profissionais que usem dados precisam se preocupar em aprender a linguagem SQL:

1. SQL é usado em qualquer lugar;
2. Está em alta demanda, já que muitas empresas o utilizam;
3. Embora já existam outras alternativas, o SQL nunca vai deixar de ser relevante.

É uma linguagem fundamental para qualquer profissional de análise, ciência ou engenharia de dados, sendo ainda mais usada do que Python e R. Contudo, devido a sua simplicidade, não é necessário ser um programador para aprendê-la, e em cada vez mais áreas têm sido exigido o conhecimento em SQL como complementar em tarefas cotidianas.

Áreas que requerem ou podem requerer SQL

1. Programação
2. Engenharia de software
3. Administrador de banco de dados
4. Analista de Qualidade
5. Business Intelligence
6. Desenvolvimento
7. Marketing e Conteúdo e Redes Sociais
8. Consultoria
9. Gestão de Projetos
10. Tecnologia da Informação
11. Engenharia de Redes
12. Suporte Técnico
13. Big Data
14. Jornalismo de Dados

E, basicamente, qualquer área que lide com tecnologia, e tenha seu próprio banco de dados, poderá exigir conhecimento em SQL como complemento profissional.

Do básico ao avançado separamos uma lista de comandos SQL que são obrigação conhecer e realizamos exemplos e explicações sobre os mesmos.

Lista de 21 comandos SQL que são uma obrigação conhecer

1# SELECT e FROM

A parte SELECT (selecionar, em inglês) de uma consulta determina quais colunas dos dados serão exibidas nos resultados. Também há opções que você pode aplicar para mostrar dados que não são uma coluna da tabela.

LIVROS SQL E BANCO DE DADOS RECOMENDADOS:

1. SQL para Análise de Dados: Técnicas avançadas para transformar dados em insights

2. Sistemas de Banco de Dados

O exemplo abaixo mostra três colunas selecionadas na tabela “student” (aluno, em inglês), para isso usamos o comando FROM (vindo de, em inglês) e uma coluna calculada. O banco de dados armazena o studentID, FirstName e LastName do aluno (id do aluno, nome e sobrenome em inglês, respectivamente). Podemos combinar as colunas FirstName e LastName para criar a coluna calculada FullName. (nome completo, em inglês)‌.

SELECT studentID, FirstName, LastName, FirstName + ' ' + LastName AS FullName
FROM student;

+-----------+-------------------+------------+------------------------+
| studentID | FirstName         | LastName   | FullName               |
+-----------+-------------------+------------+------------------------+
|         1 | Monique           | Davis      | Monique Davis          |
|         2 | Teri              | Gutierrez  | Teri Gutierrez         |
|         3 | Spencer           | Pautier    | Spencer Pautier        |
|         4 | Louis             | Ramsey     | Louis Ramsey           |
|         5 | Alvin             | Greene     | Alvin Greene           |
|         6 | Sophie            | Freeman    | Sophie Freeman         |
|         7 | Edgar Frank "Ted" | Codd       | Edgar Frank "Ted" Codd |
|         8 | Donald D.         | Chamberlin | Donald D. Chamberlin   |
|         9 | Raymond F.        | Boyce      | Raymond F. Boyce       |
+-----------+-------------------+------------+------------------------+
9 rows in set (0.00 sec)

2#  INNER JOIN

JOIN (junção, em inglês), também chamado de inner join (junção interna, em inglês), seleciona registros que têm valores correspondentes em duas tabelas.‌  

SELECT * FROM A x JOIN B y ON y.aId = x.Id

Sempre ligando os IDs das tabelas. No exemplo a cima, por exemplo, a Tabela A tem como ID o campo aId e a tabela B o ID como Id.

No artigo: “SQL – Entenda Inner, Left, Right, Outer/Full e Cross Join“, é realizada uma explicação mais detalhada dos INNERs.

3# CREATE TABLE

CREATE TABLE (criar tabela, em inglês) faz exatamente o que parece: cria uma tabela no banco de dados. Você pode especificar o nome da tabela e as colunas que devem estar nela.

CREATE TABLE nome_da_tabela (
    coluna_1 tipo_de_dados,
    coluna_2 tipo_de_dados,
    coluna_3 tipo_de_dados
);

Com o comando create é possível criar uma nova tabela dentro de um banco de dados.

Para utilizá-lo, é preciso, primeiro, criar um objeto dentro do banco de dados, ou um banco de dados completamente vazio:

CREATE DATABASE banco exemplo;

No exemplo acima, criamos o banco de dados banco exemplo. Para criar, dentro deste banco, uma tabela, é preciso o comando create table:

CREATE TABLE tabela exemplo (id INT PRIMARY KEY, campo1 VARCHAR(50), campo2 (VARCHAR(100));

No exemplo acima, criamos a tabela exemplo, onde o comando INT PRIMARY KEY indica que o campo id é a chave primária da tabela, ou seja, a identificação principal do registro. 

Em seguida, estipulamos as colunas com os campos 1 e 2 e, com o comando VARCHAR, definimos a quantidade máxima de caracteres que estes campos comportarão (50 a 100, respectivamente).

4# ALTER TABLE

ALTER TABLE (alterar tabela, em inglês) altera a estrutura de uma tabela. Aqui está demonstrado como você adicionaria uma coluna a um banco de dados:

ALTER TABLE nome_da_tabela
ADD coluna tipo_de_dados;

O comando alter é utilizado para alterar uma tabela pré existente e pode ser manipulado da seguinte maneira:

ALTER TABLE tabela exemplo ADD nome INT;

No exemplo acima, estamos alterando a tabela exemplo ao adicionar uma nova coluna: a coluna nome.

5# WHERE (AND ,OR , IN, BETWEEN e LIKE)

A instrução WHERE (onde, em inglês) é usada para limitar o número de linhas retornadas.

Como exemplo, primeiro mostraremos uma instrução SELECT e resultados sem declaração WHERE. Em seguida, adicionaremos uma instrução WHERE que usa todos os cinco qualificadores acima.‌  

SELECT studentID, FullName, sat_score, rcd_updated FROM student;

+-----------+------------------------+-----------+---------------------+
| studentID | FullName               | sat_score | rcd_updated         |
+-----------+------------------------+-----------+---------------------+
|         1 | Monique Davis          |       400 | 2017-08-16 15:34:50 |
|         2 | Teri Gutierrez         |       800 | 2017-08-16 15:34:50 |
|         3 | Spencer Pautier        |      1000 | 2017-08-16 15:34:50 |
|         4 | Louis Ramsey           |      1200 | 2017-08-16 15:34:50 |
|         5 | Alvin Greene           |      1200 | 2017-08-16 15:34:50 |
|         6 | Sophie Freeman         |      1200 | 2017-08-16 15:34:50 |
|         7 | Edgar Frank "Ted" Codd |      2400 | 2017-08-16 15:35:33 |
|         8 | Donald D. Chamberlin   |      2400 | 2017-08-16 15:35:33 |
|         9 | Raymond F. Boyce       |      2400 | 2017-08-16 15:35:33 |
+-----------+------------------------+-----------+---------------------+
9 rows in set (0.00 sec)

Agora, repetiremos a consulta SELECT, mas limitaremos as linhas retornadas usando uma instrução WHERE.

STUDENT studentID, FullName, sat_score, recordUpdated
FROM student
WHERE (studentID BETWEEN 1 AND 5 OR studentID = 8)
        AND
        sat_score NOT IN (1000, 1400);

+-----------+----------------------+-----------+---------------------+
| studentID | FullName             | sat_score | rcd_updated         |
+-----------+----------------------+-----------+---------------------+
|         1 | Monique Davis        |       400 | 2017-08-16 15:34:50 |
|         2 | Teri Gutierrez       |       800 | 2017-08-16 15:34:50 |
|         4 | Louis Ramsey         |      1200 | 2017-08-16 15:34:50 |
|         5 | Alvin Greene         |      1200 | 2017-08-16 15:34:50 |
|         8 | Donald D. Chamberlin |      2400 | 2017-08-16 15:35:33 |
+-----------+----------------------+-----------+---------------------+
5 rows in set (0.00 sec)

É importante usar esse elemento para definir exatamente qual dado será usado para alteração, bem como a linha.

Quando ocorre a situação em que as pessoas esquecem o WHERE, há um risco grande de fazer uma alteração global, ou seja, em todas as linhas da tabela, o que gera uma grande confusão. 

6# CHECK

A instrução SQL CHECK (verificar, em inglês) é usada para limitar o intervalo de valores que pode ser colocado em uma coluna.

Se você definir uma instrução CHECK em uma única coluna, ela permitirá apenas determinados valores para essa coluna. Se você definir uma instrução CHECK em uma tabela, ela poderá limitar os valores em determinadas colunas com base nos valores de outras colunas dessa linha.

O SQL a seguir cria uma instrução CHECK na coluna “Age” (idade, em inglês) quando a tabela “Persons” (pessoas, em inglês) é criada. CHECK garante que você não tenha pessoas com menos de 18 anos.‌

CREATE TABLE Persons (
    ID int NOT NULL,
    LastName varchar(255) NOT NULL,
    FirstName varchar(255),
    Age int,
    CHECK (Age>=18)
);

Para permitir a nomeação de uma instrução CHECK e para definir uma instrução CHECK em várias colunas, use a seguinte sintaxe no SQL:

CREATE TABLE Persons (
    ID int NOT NULL,
    LastName varchar(255) NOT NULL,
    FirstName varchar(255),
    Age int,
    City varchar(255),
    CONSTRAINT CHK_Person CHECK (Age>=18 AND City='Sandnes')
);

7# UPDATE

Para atualizar um registro em uma tabela, você usa a instrução SQL UPDATE (atualizar, em inglês).

Use a instrução WHERE para especificar quais registros você deseja atualizar. É possível atualizar uma ou mais colunas por vez. A sintaxe é:‌

UPDATE nome_da_tabela
SET coluna1 = valor1, 
    coluna2 = valor2, ...
WHERE condição;

Aqui está um exemplo atualizando Name (nome, em inglês) do registro com Id 4:‌  

UPDATE Person
SET Name = "Elton John"
WHERE Id = 4;

Você também pode atualizar colunas em uma tabela usando valores de outras tabelas. Use a instrução JOIN (unir, em inglês) para obter dados de várias tabelas. A sintaxe é:

UPDATE nome_da_tabela1
SET nome_da_tabela1.coluna1 = nome_da_tabela2.colunaA
    nome_da_tabela1.coluna2 = nome_da_tabela2.colunaB
FROM nome_da_tabela1
JOIN nome_da_tabela2 ON nome_da_tabela1.ChaveEstrangeira = nome_da_tabela2.Chave

Aqui está um exemplo de atualização de Manager (gerenciador, em inglês) de todos os registros:‌      

UPDATE Person
SET Person.Manager = Department.Manager
FROM Person
JOIN Department ON Person.DepartmentID = Department.ID

A instrução SQL UPDATE tem as partes abaixo:

1. tabela: O nome da tabela cujos os dados você quer modificar.
2. valor novo: Uma expressão que determina o valor a ser inserido em um campo específico nos registros atualizados.
3. critério: Uma expressão que determina quais registros devem ser atualizados. Só os registros que satisfazem a expressão são atualizados.

Comentários

UPDATE é especialmente útil quando você quer alterar muitos registros ou quando os registros que você quer alterar estão em várias tabelas. Você pode alterar vários campos ao mesmo tempo. O exemplo abaixo aumenta o Valor do Pedido em 10 por cento e o valor do Frete em 3 por cento para embarques do Reino Unido:

UPDATE Pedidos SET ValorPedido = ValorPedido * 1.1, Frete = Frete * 1.03
WHERE PaísEmbarque = 'RU';

UPDATE não gera um conjunto de resultados. Se você quiser saber quais resultados serão alterados, examine primeiro os resultados da consulta seleção que use os mesmos critérios e então execute a consulta atualização.

Exemplo de instrução UPDATE: Esse exemplo muda os valores no campo “RelatórioPara” para 5 para todos os registros de funcionários que atualmente têm valores de RelatórioPara de 2.

UPDATE Funcionários SET RelatórioPara = 5 WHERE RelatórioPara = 2;

Esse exemplo aumenta o “PreçoUnit” de todos os produtos não suspensos do fornecedor 8 em 10 porcento.

UPDATE Produtos SET PreçoUnit = PreçoUnit * 1.1 WHERE
FornecedorID = 8 AND Suspenso = No;

Esse exemplo reduz o PreçoUnit de todos os produtos não suspensos fornecidos pela Tokyo Traders em 5 porcento. As tabelas “Produtos” e “Fornecedores” têm uma relação um para vários.

UPDATE Fornecedores INNER JOIN Produtos ON Fornecedores.FornecedorID = Produtos.FornecedorID SET PreçoUnit = PreçoUnit * .95 WHERE NomeEmpresa = 'Tokyo Traders' AND Suspenso = No;

8# GROUP BY

GROUP BY (agrupar por, em inglês) permite combinar linhas e agregar dados.

Aqui está a sintaxe de GROUP BY:‌    

SELECT nome_da_coluna, COUNT(*)
FROM nome_da_tabela
GROUP BY nome_da_coluna;

GROUP BY é opcional. Valores de resumo são omitidos se não houver qualquer função aggregate SQL na instrução SELECT. Os valores Null nos campos GROUP BY são agrupados e não omitidos. No entanto, os valores Null não são avaliados em qualquer função aggregate SQL. Use a cláusula WHERE para excluir linhas que você não quer agrupadas e use a cláusula HAVING para filtrar os registros após eles terem sido agrupados.

A não ser que contenha dados Memo ou OLE Object, um campo na lista de campos GROUP BY pode fazer referência a qualquer campo em qualquer tabela listada na cláusula FROM. Mesmo que o campo não esteja incluído na instrução SELECT, fornecida a instrução SELECT, inclua pelo menos uma função SQL. O programa principal de banco de dados do Jet não pode agrupar campos Memo ou OLE Objects. Todos os campos na lista de campos SELECT devem ser incluídos na cláusula GROUP BY ou incluídos como argumentos em uma função aggregate SQL.

9# HAVING

HAVING é opcional. HAVING é semelhante a WHERE, que determina quais registros são selecionados. Depois que os registros são agrupados com GROUP BY, HAVING determina quais registros são exibidos:

SELECT CategoriaID, Sum(UnidadesNoEstoque) FROM Produtos GROUP BY CategoriaID HAVING Sum
(UnidadesNoEstoque) > 100 AND LIKE "BOS*";

Uma cláusula HAVING pode conter até 40 expressões vinculadas por operadores lógicos, como And ou Or.

Aqui está outra sintaxe de HAVING:‌  

SELECT nome_da_coluna, COUNT(*)
FROM nome_da_tabela
GROUP BY nome_da_coluna
HAVING COUNT(*) > valor;

10# AVG()

AVG() é função agregada seria que traz a média de valores de uma determinada coluna informada na consulta. Suponhamos que seja necessário agora saber a média de preço dos produtos cadastrados.

SELECT
  AVG(preco) as PRECO_MEDIO
FROM
  produto

No trecho de código acima, selecionamos a média de preço de todos os produtos cadastrados no banco de dados, nomeando a coluna da média como PRECO_MEDIO.

Outras funções agregadas em SQL são MAX, MIN, SUM e COUNT os quais faremos referência nesta listagem de comandos SQL.

11# AS

AS (como, em inglês – similar a like, que vemos posteriormente) permite renomear uma coluna ou tabela usando um alias.‌  

SELECT user_only_num1 AS AgeOfServer, (user_only_num1 - warranty_period) AS NonWarrantyPeriod FROM server_table

Isso resulta na saída abaixo.‌

+-------------+------------------------+
| AgeOfServer | NonWarrantyPeriod      | 
+-------------+------------------------+
|         36  |                     24 |
|         24  |                     12 | 
|         61  |                     49 |
|         12  |                      0 | 
|          6  |                     -6 |
|          0  |                    -12 | 
|         36  |                     24 |
|         36  |                     24 | 
|         24  |                     12 | 
+-------------+------------------------+

Você também pode usar AS para atribuir um nome a uma tabela para facilitar a referência em junções.‌  

SELECT ord.product, ord.ord_number, ord.price, cust.cust_name, cust.cust_number FROM customer_table AS cust

JOIN order_table AS ord ON cust.cust_number = ord.cust_number

Isso resulta na saída como abaixo.

+-------------+------------+-----------+-----------------+--------------+
| product     | ord_number | price     | cust_name       | cust_number  |
+-------------+------------+-----------+-----------------+--------------+
|     RAM     |   12345    |       124 | John Smith      |  20          |
|     CPU     |   12346    |       212 | Mia X           |  22          |
|     USB     |   12347    |        49 | Elise Beth      |  21          |
|     Cable   |   12348    |         0 | Paul Fort       |  19          |
|     Mouse   |   12349    |        66 | Nats Back       |  15          |
|     Laptop  |   12350    |       612 | Mel S           |  36          |
|     Keyboard|   12351    |        24 | George Z        |  95          |
|     Keyboard|   12352    |        24 | Ally B          |  55          |
|     Air     |   12353    |        12 | Maria Trust     |  11          |
+-------------+------------+-----------+-----------------+--------------+

12# ORDER BY

ORDER BY (ordenar por, em inglês) nos dá uma maneira de classificar o conjunto de resultados por um ou mais itens na seção SELECT. Aqui está um SQL classificando os alunos por FullName em ordem decrescente. A ordem de classificação padrão é crescente (ASC), mas, para classificar na ordem oposta (decrescente), você usa DESC.‌  

SELECT studentID, FullName, sat_score
FROM student
ORDER BY FullName DESC;

Os comandos SQL mostrados abaixo usam a cláusula ORDER BY para classificar os registros em ordem alfabética e depois por categoria. Esse exemplo ordena os registros pelo sobrenome, em ordem descendente (Z-A).

SELECT Sobrenome, Nome FROM Funcionários ORDER BY Sobrenome DESC;

Esse exemplo ordena, primeiro, por categoria ID e depois por nome do produto.

SELECT CategoriaID, ProdutoNome, PreçoUnit FROM Produtos
ORDER BY CategoriaID, NomeProduto;

#13 COUNT

COUNT (contar, em inglês) contará o número de linhas e retornará essa contagem como uma coluna no conjunto de resultados.

Aqui estão alguns exemplos onde você usaria COUNT:

• Para contar todas as linhas em uma tabela (GROUP BY não é obrigatório)
• Para contar os totais de subconjuntos de dados (requer um GROUP BY na instrução)

Essa instrução SQL fornece uma contagem de todas as linhas. Observe que você pode dar um nome à coluna COUNT resultante usando “AS”.‌  

SELECT count(*) AS studentCount FROM student; 

#14 DELETE

DELETE (excluir, em inglês) é usado para excluir um registro em uma tabela.

Tome cuidado. Você pode excluir todos os registros da tabela ou apenas alguns deles. Use a condição WHERE para especificar quais registros você deseja excluir. A sintaxe é:‌

DELETE FROM table_name
WHERE condition;

Aqui está um exemplo de exclusão do registro com Id 3 na tabela Person:‌

DELETE FROM Person
WHERE Id = 3;

Atenção: para que um delete tenha validade fisica no banco de dados, é necessário após executar o comando “commit“.

A instrução DELETE tem as partes abaixo:

1. tabela.* O nome opcional da tabela da qual os registros são excluídos.
2. tabela. O nome da tabela da qual os registros são excluídos.
3. critério: Uma expressão que determina qual registro deve ser excluído.

Comentários

DELETE é especialmente útil quando você quer excluir muitos registros. Para eliminar uma tabela inteira do banco de dados, você pode usar o método Execute com uma instrução DROP. Entretanto, se você eliminar a tabela, a estrutura é perdida. Por outro lado, quando você usa DELETE, apenas os dados são excluídos. A estrutura da tabela e todas as propriedades da tabela, como atributos de campo e índices, permanecem intactos.

Você pode usar DELETE para remover registros de tabelas que estão em uma relação um por vários com outras tabelas. Operações de exclusão em cascata fazem com que os registros das tabelas que estão no lado “vários” da relação sejam excluídos quando os registros correspondentes do lado “um” da relação são excluídos na consulta. Por exemplo, nas relações entre as tabelas Clientes e Pedidos, a tabela Clientes está do lado “um” e a tabela Pedidos está no lado “vários” da relação. Excluir um registro em Clientes faz com que os registros correspondentes em Pedidos sejam excluídos se a opção de exclusão em cascata for especificada.

Uma consulta de exclusão exclui registros inteiros e não apenas dados em campos específicos. Se você quiser excluir valores de um campo específico, crie uma consulta atualização que mude os valores para Null.

Importante:  Após remover os registros usando uma consulta exclusão, você não poderá desfazer a operação. Se quiser saber quais arquivos foram excluídos, primeiro examine os resultados de uma consulta seleção que use o mesmo critério e então, execute a consulta exclusão. Mantenha os backups de seus dados. Se você excluir os registros errados, poderá recuperá-los a partir dos seus backups.

Exemplo de instrução DELETE

Esse exemplo exclui todos os registros de funcionários cujo título seja Estagiário. Quando a cláusula FROM inclui apenas uma tabela, não é necessário indicar o nome da tabela na instrução DELETE.

DELETE *FROM Funcionários WHERE Título = 'Estagiário';

Esse exemplo exclui todos os registros de funcionários cujo título seja Estagiário e que também tenham um registro na tabela “FolhadePagamento”. As tabelas “Funcionários” e “FolhadePagamento” têm uma relação um por um.

DELETE Funcionários.* FROM Funcionários INNER JOIN FolhaDePagamento
ON Funcionários.FuncionárioID = FolhadePagamento.FuncionárioID
WHERE Funcionários.Título = 'Estagiário';

#15 INSERT

INSERT (inserir, em inglês) é uma maneira de inserir dados em uma tabela.‌

INSERT INTO nome_da_tabela (coluna_1, coluna_2, coluna_3) 
VALUES (valor_1, 'valor_2', valor_3);

Adiciona um ou vários registros a uma tabela. Isto é referido como consulta anexação

Sintaxe:Consulta anexação de vários registros:

INSERT INTO destino [IN bancodedadosexterno] [(campo1[, campo2[, ...]])]
SELECT [origem.]campo1[, campo2[, ...] FROM expressãodetabela

Consulta anexação de um único registro:

INSERT INTO destino [(campo1[, campo2[, ...]])] VALUES (valor1[, valor2[, ...])

INSERT INTO Clientes SELECT [Novos Clientes].* FROM [Novos Clientes]

Esse exemplo cria um novo registro na tabela “Funcionários”

INSERT INTO Funcionários (Nome,Sobrenome, Título) VALUES
("André", "Pereira", "Estagiário");

Esse exemplo seleciona todos os estagiários de uma tabela hipotética “Estagiários” que foram contratados há mais de 30 dias e adiciona seus registros à tabela “Funcionários”.

INSERT INTO Funcionários SELECT Estagiários.* FROM Estagiários
WHERE DataContrato < Now() - 30;

16# LIKE

LIKE  (como, em inglês – comparar com “as” acima) é usado em uma instrução com WHERE ou HAVING(como parte de GROUP BY) para limitar as linhas selecionadas aos itens quando uma coluna possui um determinado padrão de caracteres contido nela.

Este SQL selecionará os alunos que tem FullName começando com “Monique” ou que terminam com “Greene”.‌    

SELECT studentID, FullName, sat_score, rcd_updated
FROM student 
WHERE 
    FullName LIKE 'Monique%' OR 
    FullName LIKE '%Greene'; 

+-----------+---------------+-----------+---------------------+
| studentID | FullName      | sat_score | rcd_updated         |
+-----------+---------------+-----------+---------------------+
|         1 | Monique Davis |       400 | 2017-08-16 15:34:50 |
|         5 | Alvin Greene  |      1200 | 2017-08-16 15:34:50 |
+-----------+---------------+-----------+---------------------+
2 rows in set (0.00 sec)

Você pode colocar NOT antes de LIKE para excluir as linhas com o padrão de string em vez de selecioná-las. Esse SQL exclui registros que contenham “encer Pauti” e “Ted” na coluna FullName.‌    

SELECT studentID, FullName, sat_score, rcd_updated
FROM student 
WHERE FullName NOT LIKE '%encer Pauti%' AND FullName NOT LIKE '%"Ted"%';

+-----------+----------------------+-----------+---------------------+
| studentID | FullName             | sat_score | rcd_updated         |
+-----------+----------------------+-----------+---------------------+
|         1 | Monique Davis        |       400 | 2017-08-16 15:34:50 |
|         2 | Teri Gutierrez       |       800 | 2017-08-16 15:34:50 |
|         4 | Louis Ramsey         |      1200 | 2017-08-16 15:34:50 |
|         5 | Alvin Greene         |      1200 | 2017-08-16 15:34:50 |
|         6 | Sophie Freeman       |      1200 | 2017-08-16 15:34:50 |
|         8 | Donald D. Chamberlin |      2400 | 2017-08-16 15:35:33 |
|         9 | Raymond F. Boyce     |      2400 | 2017-08-16 15:35:33 |
+-----------+----------------------+-----------+---------------------+
7 rows in set (0.00 sec)

17# WITH OWNERACCESS OPTION

A declaração WITH OWNERACCESS OPTION é opcional. O exemplo abaixo habilita o usuário a ver as informações de salário (mesmo que não tenha outra permissão para ver a tabela Folha de Pagamentos) desde que o proprietário da consulta tenha tal permissão:

SELECT Sobrenome, Nome, Salário FROM Funcionários ORDER BY Sobrenome WITH OWNERACCESS OPTION;

Se, por outro lado, um usuário for impedido de criar ou anexar a uma tabela, você poderá usar WITH OWNERACCESS OPTION para habilitá-lo a executar uma consulta construção de tabela ou consulta anexação. Se você quiser reforçar as configurações de segurança do grupo de trabalho e as permissões dos usuários, não inclua a declaração WITH OWNERACCESS OPTION. Esta opção exige que você tenha acesso ao arquivo System.mda associado ao banco de dados. É realmente útil em implementações de multiusuários seguras.

VAI GOSTAR:

18# GRANT

Com o comando grant é possível permitir diferentes tipos de privilégios nos acessos a uma tabela.

Em suma, podemos dizer que determinadas ações só podem ser tomadas por determinados usuários.

Veja o exemplo de utilização abaixo:

GRANT SELECT, INSERT, UPDATE ON tabela exemplo TO Usuario1;

Na linha acima, estipulamos que os comandos select, insert e update só podem ser utilizados na tabela exemplo pelo Usuario1.

19# REVOKE

Com o comando revoke, podemos fazer o oposto ao comando anterior: ele revoga os privilégios concedidos a determinados usuários.

Para utilizá-lo, basta seguir a seguinte sintaxe:

REVOKE SELECT ON tabela exemplo FROM  Usuario1;

Na linha acima, revogamos o privilégios do Usuario1 de utilizar o comando select na tabela exemplo.

20# DENY

O comando deny é mais amplo, negando explicitamente o acesso ou permissões, a um banco de dados ou tabela, a um usuário específico.

Veja, abaixo, um exemplo de sua utilização:

DENY SELECT ON tabela exemplo TO Usuario2;

Acima, estamos estipulando que o Usuario2 teve o seu acesso ao comando select, na tabela exemplo, totalmente negado.

21# DROP

O comando drop é aquele que utilizamos para excluir objetos, ou tabelas, de nossa base de dados.

Esse comando também pode ser utilizados para excluir um banco de dados inteiro, como veremos nos exemplos abaixo.

Com a linha DROP TABLE tabela exemplo;, é possível excluir a tabela exemplo de um banco de dados.

Com a linha DROP DATABASE banco exemplo;, é possível excluir o banco de dados banco exemplo inteiro.

Aula sobre SQL em Português da Universidade de Harvard

Para deixar este conteúdo mais rico e completo, segue aula sobre SQL pela Universidade de Harvard, totalmente em Português.

Este vídeo faz parte do programa da Universidade de Harvard que é excelente e há um projeto que traz todo o seu conteúdo em Português em: https://cs50xemportugues.github.io/2022/

Conteúdo da aula:

1. 00:00:00 – Introduction
2. 00:01:17 – SQL
3. 00:03:21 – Data Collection
4. 00:07:46 – Flat File Databases
5. 00:09:24 – Reading from a CSV
6. 00:14:26 – Filtering Duplicates
7. 00:21:21 – Counting Titles
8. 00:28:53 – Sorting Data
9. 00:30:26 – Lambda Functions
10. 00:36:07 – Cleaning Data
11. 00:39:48 – Regular Expressions
12. 00:45:50 – Search
13. 00:48:17 – Relational Databases
14. 00:51:20 – Create, Read, Update, Delete
15. 00:53:32 – sqlite3
16. 00:57:09 – SQL SELECT
17. 01:01:58 – SQL WHERE
18. 01:04:37 – SQL DELETE
19. 01:05:59 – SQL UPDATE
20. 01:11:31 – Redundancies
21. 01:18:00 – Table Relationships
22. 01:27:49 – INSERT
23. 01:30:10 – Python and SQL
24. 01:39:55 – shows.db
25. 01:41:49 – SQL Types
26. 01:43:11 – Many-to-Many Relationships
27. 01:48:27 – Indexes
28. 01:59:14 – SQL JOIN
29. 02:03:38 – SQL Injection Attacks
30. 02:11:15 – Race Conditions
31. 02:20:10 – Transactions
32. 02:21:26 – This was CS50

E-Book Grátis sobre Banco de Dados

Faça o download do E-Book grátis: “SQL e Modelagem com Banco de dados“.

Neste e-book de forma resumida aprenderá:

1. “que o aluno saia apto a utilizar qualquer sistema de banco de dados relacional (exemplos: MySQL, Oracle, PostgreSQL, SQL Server). Para isso usamos sempre que possível o padrão SQL que todos eles aceitam.
2. Para acompanhar a apostila sugerimos o MySQL, para que passe pelos mesmos desafios e soluções que encontramos nesse curso.
3. Após aprender a base a todos eles, estudar detalhes específicos de cada banco passa a ser bem mais simples.
4. Salientar que o uso de alguns conceitos, como as vantagens e desvantagens da modelagem, são entendidos por completo depois de um tempo de prática, além de mudarem com o tempo.
5. mostrar que decorar comandos não é importante.”

DEVE GOSTAR:

1. Comandos SQL: 10 essenciais para todo programador!(Abre numa nova aba do navegador)
2. VIEWS em SQL: Vantagens e desvantagens(Abre numa nova aba do navegador)
3. Usando dicionário de um jeito Python(Abre numa nova aba do navegador)
4. Ghost v4: Como atualizar para a última versão(Abre numa nova aba do navegador)
5. Guia rápido de comandos SQLite3

Lista de 4 Livros sobre SQL os quais recomendamos

1# SQL para Análise de Dados: Técnicas avançadas para transformar dados em insights

Com a explosão do uso de dados, do poder computacional e dos data warehouses na nuvem, o SQL tornou-se uma ferramenta ainda mais indispensável para o cientista de dados ou o analista experiente. Este livro prático revela maneiras novas e ainda desconhecidas de você melhorar suas habilidades em SQL, resolver problemas e aproveitar ao máximo os recursos do SQL como parte de seu fluxo de trabalho.

Você aprenderá a usar funções SQL comuns e inusitadas, como as junções, funções de janela, subconsultas, e expressões regulares, de maneiras novas e avançadas – e também a combinar técnicas do SQL para atingir seus objetivos com mais rapidez, com um código de fácil compreensão. Se você trabalha com bancos de dados SQL, esta é uma referência indispensável.

Aprenda as principais etapas para a preparação de seus dados para análise

Execute análises de séries temporais usando as manipulações de data e hora do SQL

Use a análise de coorte para investigar como os grupos mudam com o tempo

Use as funções e os operadores poderosos do SQL para a análise de texto

Detecte anomalias em seus dados e substitua-as por valores alternativos

Estabeleça causalidade usando a análise experimental, também conhecida como teste A/B

Link do livro.

2# Introdução à Linguagem SQL: Abordagem Prática Para Iniciantes

O autor Thomas Nield fornece exercícios no decorrer de todo o livro para ajudá-lo a praticar em casa suas recém descobertas aptidões no uso do SQL, sem precisar empregar um ambiente de servidor de banco de dados. Além de aprender a usar instruções-chave do SQL para encontrar e manipular seus dados, você descobrirá como projetar e gerenciar eficientemente bancos de dados que atendam às suas necessidades.

Também veremos como:

Explorar bancos de dados relacionais, usando modelos leves e centralizados

Usar o SQLite e o SQLiteStudio para criar bancos de dados leves em minutos

Consultar e transformar dados de maneira significativa usando SELECT, WHERE, GROUP BY e ORDER BY

Associar tabelas para obter uma visualização mais completa dos dados da empresa

Construir nossas próprias tabelas e bancos de dados centralizados usando princípios de design normalizado

Gerenciar dados aprendendo como inserir, excluir e atualizar registros

Link do livro.

3# Storytelling com dados: Um guia sobre visualização de dados para profissionais de negócios

Este livro mais focado em quem precisa utilizar ferramentas de BI (como o PowerBI, Tableau e outros) para montar gráficos e análise de dados. Não é um livro sobre SQL, mas mostra insights e como contar histórias através de dados.

Link do livro.

4# DOMINE O SQL: Torne-se um especialista em banco de dados com 100 perguntas e respostas

Na verdade um livro para Kindle, bastante básico mas interessante para quem esteja iniciando.

Link do Kindle.

Quais os bancos de dados relacionais (SBDBs SQL) mais populares?

Esse é o nosso top 10 de bancos de dados relacionais utilizados no mundo, agora vou mostrar pra você uma breve descrição de cada um deles.

Os 4 primeiros nós já falamos bastante aqui no blog, então temos conteúdo aqui sobre cada um deles.

1 – ORACLE DATABASE

O Oracle Database surgiu no final dos anos 70 e atualmente, de acordo com o site db-engines, é o SGBD mais utilizado do mundo.

2 – MYSQL

O MySQL é um sistema de gerenciamento de banco de dados, que utiliza a linguagem SQL como interface. É atualmente um dos sistemas de gerenciamento de bancos de dados mais populares da Oracle.

3 – SQL SERVER

O Microsoft SQL Server é um sistema gerenciador de Banco de dados relacional desenvolvido pela Sybase em parceria com a Microsoft. Foi lançado em 1994, tendo sua versão mais estável a de 2019.

4 – POSTGRESQL

PostgreSQL é um sistema gerenciador de banco de dados objeto relacional, desenvolvido como projeto de código aberto, lançado em 1996.

5 – IMB DB2

O DB2 é um Sistema de Gestão de Banco de Dados Relacionais (SGDBR) produzido pela IBM, lançado em 1983. Inicialmente se chamava System R, o primeiro exemplar de banco de dados da história.

6 – MICROSOFT ACCESS

Criado em 1992, o Microsoft Access, conhecido por MSAccess, é um sistema de gerenciamento de banco de dados da Microsoft, incluído no pacote do Microsoft Office.

7 – SQLITE

Lançado em 2000, mais um exemplar de sistema de bancos de dados. Ao contrário dos servidores de banco de dados tradicionais, como MySQL ou PostgreSQL, sua particularidade não é reproduzir o esquema cliente-servidor usual, mas estar diretamente integrado aos programas.

8 – MARIADB

Teve sua primeira versão em 2009. O MariaDB é um sistema de gerenciamento de banco de dados que surgiu como fork do MySQL, criado pelo próprio fundador do projeto após sua aquisição pela Oracle. O nome Maria DB vem do nome da 2ª filha do criador do MySQL, que se chamava Maria.

9 – SNOWFLAKE

Criado em 2012, outro exemplar de sistema de gerenciamento de banco de dados em nuvem, que permite aos usuários armazenar e analisar dados em nuvem.

10 – MICROSOFT AZURE

Lançado em 2010, o Banco de Dados SQL do Microsoft Azure é um banco de dados de nuvem gerenciado fornecido como parte do Microsoft Azure. Um banco de dados em nuvem é um banco de dados executado em uma plataforma de computação em nuvem.

CONCLUSÃO

Apesar de haver profissionais de TI especializados somente na manipulação de bancos de dados, como são os DBAs, um conhecimento básico sobre essa linguagem é indispensável a qualquer programador (assim como outras profissões as quais cada vez mais há a exigência deste conhecimento).

Uma vez que os bancos de dados são o pano de fundo de grande parte das aplicações utilizadas hoje na web, inclusive sites e aplicativos, uma necessidade repentina pode exigir de um profissional, inclusive de nível júnior, uma ação com SQL. Ou mesmo em uma Startup você pode acabar precisando assumir outras atividades que requerem o uso de instruções SQL.

Dúvidas?

1. Ficaram dúvidas sobre estas ou outras instruções SQL?
2. No E-Book gratuito tem alguma dúvida?
3. Sugestão de novos temas?

Então comenta que vamos responder ou escrever novos artigos sobre o tema.

Incentive a Ramos da Informática:

Gostou deste conteúdo? Então compartilhe em suas redes sociais e e-mails para colegas de trabalho ou estudo.

VOCÊ ESTÁ NA SEÇÃO: BANCO DE DADOS. Sempre com conteúdos atualizados sobre SQL e Banco de dados Relacionais.

LEIA TAMBÉM:

Instrução SQL: WHERE + 1 entenda como funciona

Maneiras de aprender SQL e banco de dados online (de graça!)

Como aprender a programar, um guia definitivo(Abre numa nova aba do navegador)

Tutorial sobre o banco de dados PostgreSql – parte 1(Abre numa nova aba do navegador)

Usando dicionário de um jeito Python(Abre numa nova aba do navegador)

Django Rest Framework – #2 Requests and Responses(Abre numa nova aba do navegador)

SQL Server: DISTINCT e GROUP BY entenda as diferenças

PARTICIPE DA COMUNIDADE

O Comunidade Dev Ramos da Informática (CDRI) é uma comunidade orientada para desenvolvedores.

O uso da palavra “orientado” aqui é importante porque mais precisamente é para programadores de todos os tipos. Se você é um novato verde com 5 linhas de código em seu currículo, ou se você é um veterano com 15 anos de experiência no setor, a CDRI tem um lugar para você.

Conheça os Recursos Disponíveis para toda a comunidade: desde perguntas e respostas, passando pelo nosso Discord, área exclusiva para membros, possibilidade de escrever artigos e criar eventos e muito mais. Conheça todos os recursos, aqui.

LIVROS SQL E BANCO DE DADOS RECOMENDADOS:

1. SQL para Análise de Dados: Técnicas avançadas para transformar dados em insights

2. Sistemas de Banco de Dados

NOVOS CONTEÚDOS