Aprender SQL: Tutorial introdutório

A linguagem de programação SQL é baseada em álgebra relacional, por isso ela difere das demais linguagens em importantes aspectos. Para aprender SQL é essencial que se compreenda sua sintaxe. Os exemplos práticos do nosso tutorial introdutório certamente ajudarão você a começar.

Noções básicas de sintaxe SQL

Sintaxe nada mais é que a forma como uma linguagem de programação é “escrita”. Ela estabelece as construções básicas de um código e determina como estas podem se relacionar. Compreender a sintaxe de uma linguagem é pré-requisito imprescindível para se ler e escrever códigos.

As estruturas de sintaxe mais importantes do SQL são as declarações SQL que contêm cláusulas. Embora esta não seja, tecnicamente, a nomenclatura mais correta, declarações SQL são geralmente chamadas de “comandos SQL”. Existem, ainda, outras estruturas de sintaxe SQL relevantes. Apresentamo-las abaixo, somente para fins informativos.

Como códigos SQL são executados?

Códigos-fonte SQL são arquivos de texto que ganham vida somente quando no ambiente de execução adequado. Eles são lidos por um interpretador SQL e convertidos em ações por um sistema gerenciador de banco de dados relacional (SGBDR — ou RDBMS, se em inglês). O processo pode se dar de duas formas:

1. Executar código SQL em sessão interativa Nessa abordagem, um código SQL é inserido ou copiado diretamente em uma janela de texto para ser executado e ter o resultado exibido. Aqui, existe a possibilidade de se ajustar e reexecutar o código, em caso de necessidade. A rapidez com a qual códigos podem ser sequenciados e/ou manipulados para exibir resultados torna essa abordagem mais adequada ao aprendizado e à realização de consultas complexas.

2. Executar código SQL como script Permite a execução, linha por linha, de um arquivo de código-fonte SQL completo. Aqui, o feedback só é apresentado ao final da execução, o que torna a abordagem mais adequada à automatização de processos e à importação de backups de bancos de dados MySQL com MySQL dump.

SQL para criar um sistema de gerenciamento de produtos fictício

O jeito mais fácil de aprender SQL, assim como qualquer outra linguagem de programação, é escrevendo e executando códigos na prática. Entenda, a seguir, como criar um mini banco de dados e executar consultas dentro dele. Faça isso utilizando o interpretador SQL on-line do sql.js. Ao acessar o site, substitua o código SQL já inserido pelos códigos dos nossos exemplos. Execute-os parte a parte para obter os mesmos resultados que este tutorial.

Procedimento básico para configurar um banco de dados SQL

Criaremos um gerenciador de produtos comerciais como exemplo, para ser usado por uma loja fictícia, virtual ou física. Neste primeiro momento, definiremos seus requisitos de forma generalizada:

• Oferecemos uma gama variada de produtos, cada um estocado em diferentes quantidades.
• Nossa clientela também é variada.
• Um cliente pode fazer um pedido que contenha mais de um produto.
• Cada pedido deve ser armazenado com a data da compra, com os produtos encomendados e com as quantidades correspondentes.

Para começar, traduziremos esses requisitos em descrições abstratas para, em seguida, escrevermos o código SQL. Seguiremos o procedimento abaixo:

1. Criar modelo
2. Definir esquema
3. Inserir registros de dados
4. Definir consultas

Criar modelo entidade-relacionamento

O primeiro passo é dado no papel ou utilizando ferramentas de modelagem especiais. Ele consiste em coletar informações sobre o sistema a ser modelado para extrair dele entidades-relacionamento. Geralmente essa etapa é representada por diagramas entidade-relacionamento (ER).

O que são entidades-relacionamento? Entidades são, simplesmente, classes de coisas. Nosso exemplo de gerenciador de produtos tem três entidades: produto, cliente e pedido. Cada uma exige a criação de uma tabela. Devido a recursos especiais presentes em modelos relacionais, tabelas adicionais devem ser inseridas para modelar os respectivos relacionamentos. Identificá-los e implementá-los requer conhecimento e experiência.

Como entidades-relacionamento se conectam? É importante entender como se dá o processo de ligação entre entidades-relacionamento. Observe aqui ambas as direções de um relacionamento, que distinguimos entre singular e plural. Utilizaremos a relação proprietário-carro para melhor exemplificação:

1. “Um dono de carro tem, potencialmente, outros veículos.”
2. “Um carro pertence, exclusivamente, a um único proprietário.”

Assim sendo, existem três padrões de relacionamento possíveis entre as duas entidades:

Implementar produto

Agora implementaremos a tabela de produtos. Para tanto, definimos um esquema, inserimos registros de dados e executamos algumas consultas simples, para fim de teste. Cada etapa será abordada individualmente, em detalhes.

Definir esquema

O principal comando SQL para definir tabelas de banco de dados é “CREATE TABLE”. Além de criar uma tabela já nomeada e definir as propriedades das colunas, ele estabelece os tipos de dados e, quando necessário, restrições de valores a serem armazenados:

DROP TABLE IF EXISTS Products;
CREATE TABLE Products ( product_id int, product_name text, stocked int, price int );

Inserir registros de dados

Criamos alguns registros de teste. Usamos o comando SQL “INSERT INTO” e a função “VALUES” para preencher os campos:

INSERT INTO Products VALUES (10, 'ABC Product', 74, 1050);
INSERT INTO Products VALUES (20, 'KLM Product', 23, 750);
INSERT INTO Products VALUES (30, 'XYZ Product', 104, 350);

Definir consultas

Para verificar o status da tabela de produtos, escrevemos um código de consulta simples. Usamos o comando “SELECT FROM” para gerar a tabela completa:

SELECT * FROM Products;

Ainda, escrevemos uma consulta um pouco mais complexa para calcular o valor total dos produtos armazenados:

SELECT product_name AS 'Name', (stocked * price) AS 'Value' FROM Products;

Implementar outras tabelas

Agora criaremos as demais tabelas necessárias. Executaremos, para tanto, o mesmo processo da tabela de produtos. Primeiramente geraremos a tabela de clientes:

DROP TABLE IF EXISTS Customers;
CREATE TABLE Customers ( customer_id int, customer_name text, contact text );

Vamos inserir registros de dados para dois clientes fictícios:

INSERT INTO Customers VALUES (100, 'EDC Customer', 'ED@example.com');
INSERT INTO Customers VALUES (200, 'WVU Customer', 'WV@example.com');

Para verificação, geraremos uma tabela de clientes:

SELECT * FROM Customers;

Em seguida criaremos a tabela de pedidos:

DROP TABLE IF EXISTS Orders;
CREATE TABLE Orders ( order_id int, customer_id int, order_date text );

Inserimos três pedidos fictícios. Observe que atribuímos como primeiro valor de registros um ID com uma chave primária. Em contrapartida, o segundo valor (com uma chave estrangeira) corresponde a IDs de clientes já existentes. Além disso, armazenamos a data de cada pedido.

INSERT INTO Orders VALUES (1000, 100, '2022-05-03');
INSERT INTO Orders VALUES (1001, 100, '2022-05-04');
INSERT INTO Orders VALUES (1002, 200, '2022-05-08')

Para verificação, emitiremos uma encomenda:

SELECT * FROM Orders;

Por fim, precisamos de uma tabela para organizar os produtos contidos em um pedido e seu respectivo número. Este se trata de um relacionamento m:n, porque um pedido pode conter vários produtos, assim como um produto pode estar presente em vários pedidos. Definimos uma tabela que contém IDs de pedidos e produtos como chaves estrangeiras:

DROP TABLE IF EXISTS OrderItems;
CREATE TABLE OrderItems ( orderitem_id int, order_id int, product_id int, count int );

Inserimos alguns produtos encomendados. Selecionamos IDs de pedidos e produtos, de modo que estejam presentes um pedido com dois produtos e um pedido com um único produto:

INSERT INTO OrderItems VALUES (10001, 1000, 10, 3);
INSERT INTO OrderItems VALUES (10002, 1000, 20, 2);
INSERT INTO OrderItems VALUES (10003, 1002, 30, 12);

Para a verificação, fornecemos os produtos solicitados:

SELECT * FROM OrderItems;

Escrever consultas complexas

Se tiver executado todos os trechos de código apresentados por nosso tutorial de como aprender SQL, você já será capaz de entender a estrutura do banco de dados de teste. Assim sendo, é hora de seguir para consultas mais complexas, que demonstram, na prática, o poder do SQL.

Vamos escrever, agora, uma consulta que combina dados distribuídos entre várias tabelas. Para unir dados presentes na tabela de clientes e na tabela de pedidos, usaremos o comando “SQL JOIN”. Ao fazermos uso da condição “JOIN”, atribuímos nomes a algumas colunas e definimos o ID do cliente correspondente. Veja que usamos identificadores qualificados para diferenciar as colunas de cada tabela:

SELECT customers.customer_name as 'Customer', customers.customer_id, orders.order_id, orders.order_date AS 'Date' FROM Customers JOIN Orders ON Orders.customer_id = Customers.customer_id ORDER BY Customers.customer_id;

Finalmente, usamos mais um comando “JOIN”, desta vez para calcular o custo total dos produtos encomendados:

SELECT OrderItems.order_id, OrderItems.orderitem_id AS 'Order Item', Products.product_name AS 'Product', Products.price AS 'Unit Price', OrderItems.count AS 'Count', (OrderItems.count * Products.price) AS 'Total' FROM OrderItems JOIN Products ON OrderItems.product_id = Products.product_id;