O que é SQL?

A biblioteca sem bibliotecário

Imagine uma biblioteca enorme com milhões de livros, mas sem bibliotecário. Os livros estão organizados nas prateleiras por categoria, autor e ano. Você não pode gritar "me dê algo bom!" Você precisa escrever um pedido preciso em um papel: qual prateleira, qual seção, quais critérios. A biblioteca lê seu papel e devolve os livros que correspondem.

Essa biblioteca é um banco de dados. O papel é uma query SQL.

SQL (Structured Query Language, pronunciado "síquel" ou "S-Q-L") é a linguagem que você usa para conversar com bancos de dados relacionais. Toda vez que sua aplicação Rails carrega um perfil de usuário, lista posts de um blog ou verifica uma senha: SQL é a conversa acontecendo por baixo dos panos.

Por que bancos de dados existem

Você poderia guardar dados em um arquivo de texto. Muitos iniciantes fazem isso. Mas arquivos de texto quebram no momento em que duas coisas acontecem ao mesmo tempo:

1. Dois usuários editam o arquivo simultaneamente: qual alteração vence?
2. Você precisa encontrar um registro entre milhões: vai ler o arquivo inteiro?

Um banco de dados relacional (PostgreSQL, MySQL, SQLite) resolve ambos os problemas. Ele oferece:

• Controle de concorrência: múltiplos usuários leem e escrevem sem corromper dados, O PostgreSQL e o MySQL fazem isso com MVCC (Multi-Version Concurrency Control): cada transação vê um snapshot consistente dos dados. O SQLite usa locks no lugar.
• Indexação: ao invés de escanear cada linha, o banco de dados constrói estruturas de dados (B-trees, hash indexes) que permitem pular diretamente para as linhas desejadas. Encontrar um usuário entre 10 milhões leva milissegundos, não minutos.
• Garantias ACID: toda operação é Atômica (tudo-ou-nada), Consistente (regras são respeitadas), Isolada (transações não interferem entre si) e Durável (dados commitados sobrevivem a um crash).

SQL é a interface padrão para todo esse poder. É a linguagem dominante para bancos de dados desde os anos 1970, e todo grande framework web (incluindo o Rails) fala SQL.

O modelo relacional: tabelas, linhas e colunas

Bancos de dados relacionais armazenam dados em tabelas. Uma tabela parece uma planilha, mas com regras rígidas.

+----+----------------+---------------------------+--------+
| id | name           | email                     | active |
+----+----------------+---------------------------+--------+
|  1 | Alice Müller   | [email protected]         | true   |
|  2 | Bob Santos     | [email protected]           | true   |
|  3 | Carol Tanaka   | [email protected]         | false  |
+----+----------------+---------------------------+--------+
       ↑ colunas (atributos)        ↑ cada linha horizontal = um registro (row)

• Tabela: uma coleção de dados relacionados (ex: users, orders, products). No Rails, cada model mapeia para uma tabela.
• Coluna: um único atributo com um tipo definido. name é uma coluna de texto. active é uma coluna booleana. O banco de dados aplica esses tipos: você não consegue guardar uma frase em uma coluna de inteiro.
• Linha (Row): um registro. Alice é uma linha. Bob é outra. Cada linha tem um valor para cada coluna.
• Chave Primária (Primary Key): uma coluna que identifica unicamente cada linha. Geralmente id, um inteiro auto-incrementado. Duas linhas nunca podem compartilhar a mesma chave primária.

Este é o modelo relacional, inventado por Edgar F. Codd na IBM em 1970. A palavra "relacional" vem do conceito matemático de uma relação: um conjunto de tuplas (linhas) com atributos nomeados (colunas). Não significa "tabelas são relacionadas entre si" (embora possam ser, via chaves estrangeiras).

O que o SQL faz

SQL é dividido em sub-linguagens, cada uma com um trabalho específico:

Este curso foca em DQL: especificamente SELECT e FROM. Esses são os comandos que você mais usará como desenvolvedor Rails, porque a maioria das requisições web são leituras (carregar páginas, buscar, filtrar).

Quando você escreve uma query SQL, o PostgreSQL a processa através de um pipeline:

flowchart TB
  Q["Sua query SQL (texto)"] --> P["Parser<br/>verifica a sintaxe, monta a árvore da query"]
  P --> R["Rewriter<br/>aplica regras, ex.: expande views"]
  R --> PL["Planner / otimizador<br/>index ou scan da tabela? ordem de join? escolhe o plano mais barato"]
  PL --> E["Executor<br/>executa o plano"]
  E --> RS["Result set (as linhas que você pediu)"]

Isso importa porque a mesma query pode ser executada de formas diferentes. O planner é o cérebro: ele analisa tamanhos de tabelas, indexes disponíveis e estatísticas para escolher o caminho de execução mais rápido. Entender esse pipeline é o que explica por que algumas queries são rápidas e outras são lentas.

Por que devs Rails precisam de SQL puro

O Rails tem o ActiveRecord: um ORM (Object-Relational Mapper) que permite escrever Ruby ao invés de SQL:

# Ruby (ActiveRecord)
User.where(active: true).order(:name)

# SQL que o ActiveRecord gera
SELECT "users".* FROM "users" WHERE "users"."active" = TRUE ORDER BY "users"."name" ASC

Então por que aprender SQL? Três razões críticas:

Primeiro, ActiveRecord gera SQL: você precisa ler. Quando uma página está lenta, você vai abrir o log do Rails e ver SQL puro. Se você não sabe ler, não consegue debugar.

Segundo, ActiveRecord não consegue expressar tudo. Relatórios complexos, window functions, CTEs (Common Table Expressions) e agregações avançadas frequentemente exigem find_by_sql ou Arel. Você precisa de SQL para escrevê-los.

Terceiro, SQL é portável. ActiveRecord é exclusivo do Rails. SQL funciona no PostgreSQL, MySQL, SQLite e em toda ferramenta de BI, pipeline de dados e console de admin que você vai usar. É a linguagem universal dos dados.

Todo dev Rails sênior lê SQL fluentemente. Começar agora coloca você à frente.

Sua primeira query SQL

Aqui está a query SQL mais simples possível:

SELECT 1;

Saída:

 ?column?
----------
        1
(1 row)

Essa query não tem tabela, não tem dados, não tem FROM. Ela pede ao banco de dados para avaliar a expressão 1 e retorná-la. O banco responde com uma linha contendo o valor 1.

Isso é importante: SELECT é um avaliador de expressões primeiro, um recuperador de dados depois. Você pode usá-lo como uma calculadora:

SELECT 2 + 3;

 ?column?
----------
        5

Vamos explorar isso em profundidade na próxima aula.

Erros comuns

Erro: Pensar que SQL é ultrapassado porque ORMs existem.
Por que está errado: ORMs geram SQL. Quando o SQL gerado é lento ou incorreto, a única forma de consertar é entender SQL. Toda aplicação Rails em produção bate nessa parede.

Erro: Confundir o banco de dados com a aplicação.
Por que está errado: O banco de dados é um processo separado rodando independentemente da sua aplicação Rails. Sua app Rails se conecta a ele através de um socket (geralmente TCP) e envia texto SQL. O banco de dados parseia, planeja e executa esse SQL, depois envia os resultados de volta. São dois sistemas distintos se comunicando via SQL.

Resumo