Aprender SQL: Tutorial in­tro­du­tó­rio

A linguagem de pro­gra­ma­ção SQL é baseada em álgebra re­la­ci­o­nal, por isso ela difere das demais lin­gua­gens em im­por­tan­tes aspectos. Para aprender SQL é essencial que se com­pre­enda sua sintaxe. Os exemplos práticos do nosso tutorial in­tro­du­tó­rio cer­ta­mente ajudarão você a começar.

Noções básicas de sintaxe SQL

Sintaxe nada mais é que a forma como uma linguagem de pro­gra­ma­ção é “escrita”. Ela es­ta­be­lece as cons­tru­ções básicas de um código e determina como estas podem se re­la­ci­o­nar. Com­pre­en­der a sintaxe de uma linguagem é pré-requisito im­pres­cin­dí­vel para se ler e escrever códigos.

As es­tru­tu­ras de sintaxe mais im­por­tan­tes do SQL são as de­cla­ra­ções SQL que contêm cláusulas. Embora esta não seja, tec­ni­ca­mente, a no­men­cla­tura mais correta, de­cla­ra­ções SQL são ge­ral­mente chamadas de “comandos SQL”. Existem, ainda, outras es­tru­tu­ras de sintaxe SQL re­le­van­tes. Apre­sen­tamo-las abaixo, somente para fins in­for­ma­ti­vos.

Como códigos SQL são exe­cu­ta­dos?

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 in­ter­pre­ta­dor SQL e con­ver­ti­dos em ações por um sistema ge­ren­ci­a­dor de banco de dados re­la­ci­o­nal (SGBDR — ou RDBMS, se em inglês). O processo pode se dar de duas formas:

1. Executar código SQL em sessão in­te­ra­tiva Nessa abordagem, um código SQL é inserido ou copiado di­re­ta­mente em uma janela de texto para ser executado e ter o resultado exibido. Aqui, existe a pos­si­bi­li­dade de se ajustar e re­e­xe­cu­tar o código, em caso de ne­ces­si­dade. A rapidez com a qual códigos podem ser se­quen­ci­a­dos e/ou ma­ni­pu­la­dos para exibir re­sul­ta­dos torna essa abordagem mais adequada ao apren­di­zado e à re­a­li­za­çã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ó é apre­sen­tado ao final da execução, o que torna a abordagem mais adequada à au­to­ma­ti­za­ção de processos e à im­por­ta­ção de backups de bancos de dados MySQL com MySQL dump.

SQL para criar um sistema de ge­ren­ci­a­mento de produtos fictício

O jeito mais fácil de aprender SQL, assim como qualquer outra linguagem de pro­gra­ma­ção, é es­cre­vendo e exe­cu­tando códigos na prática. Entenda, a seguir, como criar um mini banco de dados e executar consultas dentro dele. Faça isso uti­li­zando o in­ter­pre­ta­dor 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 re­sul­ta­dos que este tutorial.

Pro­ce­di­mento básico para con­fi­gu­rar um banco de dados SQL

Criaremos um ge­ren­ci­a­dor de produtos co­mer­ci­ais como exemplo, para ser usado por uma loja fictícia, virtual ou física. Neste primeiro momento, de­fi­ni­re­mos seus re­qui­si­tos de forma ge­ne­ra­li­zada:

• Ofe­re­ce­mos uma gama variada de produtos, cada um estocado em di­fe­ren­tes quan­ti­da­des.
• Nossa clientela também é variada.
• Um cliente pode fazer um pedido que contenha mais de um produto.
• Cada pedido deve ser ar­ma­ze­nado com a data da compra, com os produtos en­co­men­da­dos e com as quan­ti­da­des cor­res­pon­den­tes.

Para começar, tra­du­zi­re­mos esses re­qui­si­tos em des­cri­ções abstratas para, em seguida, es­cre­ver­mos o código SQL. Se­gui­re­mos o pro­ce­di­mento abaixo:

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

Criar modelo entidade-re­la­ci­o­na­mento

O primeiro passo é dado no papel ou uti­li­zando fer­ra­men­tas de modelagem especiais. Ele consiste em coletar in­for­ma­ções sobre o sistema a ser modelado para extrair dele entidades-re­la­ci­o­na­mento. Ge­ral­mente essa etapa é re­pre­sen­tada por diagramas entidade-re­la­ci­o­na­mento (ER).

O que são entidades-re­la­ci­o­na­mento? Entidades são, sim­ples­mente, classes de coisas. Nosso exemplo de ge­ren­ci­a­dor 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 re­la­ci­o­nais, tabelas adi­ci­o­nais devem ser inseridas para modelar os res­pec­ti­vos re­la­ci­o­na­men­tos. Iden­ti­ficá-los e im­ple­mentá-los requer co­nhe­ci­mento e ex­pe­ri­ên­cia.

Como entidades-re­la­ci­o­na­mento se conectam? É im­por­tante entender como se dá o processo de ligação entre entidades-re­la­ci­o­na­mento. Observe aqui ambas as direções de um re­la­ci­o­na­mento, que dis­tin­gui­mos entre singular e plural. Uti­li­za­re­mos a relação pro­pri­e­tá­rio-carro para melhor exem­pli­fi­ca­ção:

1. “Um dono de carro tem, po­ten­ci­al­mente, outros veículos.”
2. “Um carro pertence, ex­clu­si­va­mente, a um único pro­pri­e­tá­rio.”

Assim sendo, existem três padrões de re­la­ci­o­na­mento possíveis entre as duas entidades:

Im­ple­men­tar produto

Agora im­ple­men­ta­re­mos a tabela de produtos. Para tanto, definimos um esquema, inserimos registros de dados e exe­cu­ta­mos algumas consultas simples, para fim de teste. Cada etapa será abordada in­di­vi­du­al­mente, 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 pro­pri­e­da­des das colunas, ele es­ta­be­lece os tipos de dados e, quando ne­ces­sá­rio, res­tri­ções de valores a serem ar­ma­ze­na­dos:

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, es­cre­ve­mos um código de consulta simples. Usamos o comando “SELECT FROM” para gerar a tabela completa:

SELECT * FROM Products;

Ainda, es­cre­ve­mos uma consulta um pouco mais complexa para calcular o valor total dos produtos ar­ma­ze­na­dos:

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

Im­ple­men­tar outras tabelas

Agora criaremos as demais tabelas ne­ces­sá­rias. Exe­cu­ta­re­mos, para tanto, o mesmo processo da tabela de produtos. Pri­mei­ra­mente 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 ve­ri­fi­ca­çã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 atri­buí­mos como primeiro valor de registros um ID com uma chave primária. Em con­tra­par­tida, o segundo valor (com uma chave es­tran­geira) cor­res­ponde a IDs de clientes já exis­ten­tes. Além disso, ar­ma­ze­na­mos 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 ve­ri­fi­ca­ção, emi­ti­re­mos uma encomenda:

SELECT * FROM Orders;

Por fim, pre­ci­sa­mos de uma tabela para organizar os produtos contidos em um pedido e seu res­pec­tivo número. Este se trata de um re­la­ci­o­na­mento 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 es­tran­gei­ras:

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

Inserimos alguns produtos en­co­men­da­dos. Se­le­ci­o­na­mos 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 ve­ri­fi­ca­ção, for­ne­ce­mos os produtos so­li­ci­ta­dos:

SELECT * FROM OrderItems;

Escrever consultas complexas

Se tiver executado todos os trechos de código apre­sen­ta­dos 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 de­mons­tram, na prática, o poder do SQL.

Vamos escrever, agora, uma consulta que combina dados dis­tri­buí­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”, atri­buí­mos nomes a algumas colunas e definimos o ID do cliente cor­res­pon­dente. Veja que usamos iden­ti­fi­ca­do­res qua­li­fi­ca­dos para di­fe­ren­ciar 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;

Fi­nal­mente, usamos mais um comando “JOIN”, desta vez para calcular o custo total dos produtos en­co­men­da­dos:

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;