Configuração do Ambiente e Primeira Consulta

Lição 2: Configuração do Ambiente e Primeira Consulta

🎯 Analogia da Vida Real

Imagine que você quer aprender a cozinhar. Antes de começar a cozinhar, você precisa:

1. Preparar a cozinha — Instalar um banco de dados é como instalar um fogão e forno
2. Preparar as ferramentas — Linha de comando e ferramentas GUI são como espátulas e copos medidores
3. Preparar os ingredientes — Criar um banco de dados é como dispor os ingredientes no balcão
4. Começar a cozinhar — Sua primeira consulta SQL é como fazer o primeiro corte

Você não pode cozinhar sem uma cozinha, e da mesma forma, não pode aprender SQL sem configurar um ambiente de banco de dados. Esta lição irá guiá-lo do zero até construir sua própria "cozinha SQL".

📚 Conceitos Fundamentais

1. Instalando um Banco de Dados

Existem três bancos de dados relacionais mainstream. Iniciantes devem instalar um primeiro e expandir depois.

MySQL

MySQL é o banco de dados open source mais popular do mundo, amplamente utilizado em desenvolvimento web.

Instalação no Windows:

1. Acesse o site oficial do MySQL para baixar o instalador
2. Execute o instalador e selecione "Developer Default"
3. Defina a senha do root (lembre-se dela!)
4. Após a instalação, o serviço MySQL inicia automaticamente

Instalação no macOS:

# Instalar usando Homebrew
brew install mysql

# Iniciar o serviço MySQL
brew services start mysql

# Instalação segura
mysql_secure_installation

Instalação no Linux (Ubuntu):

sudo apt update
sudo apt install mysql-server
sudo systemctl start mysql
sudo mysql_secure_installation

PostgreSQL

PostgreSQL é o banco de dados open source mais poderoso, adequado para consultas complexas e aplicações corporativas.

Instalação no Windows:

1. Acesse o site oficial do PostgreSQL para baixar o instalador
2. Execute o instalador, defina senha e porta (padrão 5432)
3. Marque o componente "pgAdmin" (ferramenta de gerenciamento GUI)

Instalação no macOS:

brew install postgresql@16
brew services start postgresql@16

Instalação no Linux (Ubuntu):

sudo apt update
sudo apt install postgresql postgresql-contrib
sudo systemctl start postgresql

SQLite

SQLite é um banco de dados embarcado leve que não requer instalação de servidor, sendo perfeito para aprendizado e projetos pequenos.

Instalação no Windows:

1. Acesse a página de download do SQLite e baixe sqlite-tools-win64
2. Extraia para qualquer diretório e adicione esse diretório ao PATH do sistema

Instalação no macOS / Linux:

# macOS (geralmente pré-instalado)
brew install sqlite

# Linux
sudo apt install sqlite3

Verificar Instalação:

sqlite3 --version

2. Conectando-se a um Banco de Dados Usando a Linha de Comando

A linha de comando é a maneira mais direta de interagir com um banco de dados.

Conectar ao MySQL:

mysql -u root -p
# Digite a senha para acessar a interface interativa do MySQL

Após entrar, você verá o prompt mudar para mysql>, indicando que agora pode inserir instruções SQL.

Conectar ao PostgreSQL:

# Usando o cliente psql
psql -U postgres

# Especificar um banco de dados
psql -U postgres -d mydb

Após entrar, o prompt muda para mydb=#.

Conectar ao SQLite:

# Criar ou abrir um arquivo de banco de dados
sqlite3 mydb.db

# Se o arquivo não existir, será criado automaticamente

Após entrar, o prompt muda para sqlite>.

Sair da Linha de Comando do Banco de Dados:

3. Ferramentas GUI

Se você prefere uma interface visual, as seguintes ferramentas são recomendadas:

Exemplo de Instalação do DBeaver (Recomendado):

1. Acesse o site oficial do DBeaver e baixe a Edição Comunitária
2. Após a instalação, abra e clique em "New Database Connection"
3. Selecione o tipo de banco de dados (ex: MySQL)
4. Preencha host, porta, nome de usuário e senha
5. Clique em "Test Connection" — uma vez bem-sucedido, está pronto para usar

4. Plataformas Online de Prática SQL

Se você não quer instalar nenhum software por agora, pode praticar diretamente em plataformas online:

📝 Sintaxe e Uso Básico

A Primeira Instrução SQL: SELECT

SELECT é a instrução mais comumente usada em SQL, utilizada para consultar dados de um banco de dados. A forma mais simples é:

SELECT expressão;

Vamos começar com a consulta mais simples:

SELECT 1;

Esta instrução significa: calcule e retorne o valor 1. Não envolve nenhuma tabela — é puramente para verificar se o banco de dados está funcionando corretamente.

Sintaxe em Diferentes Bancos de Dados:

-- Funciona em MySQL / PostgreSQL / SQLite
SELECT 1;

-- Retornar uma string
SELECT 'Hello, SQL!';

-- Retornar um resultado de cálculo
SELECT 2 + 3;

Visualizando Informações do Banco de Dados

Após conectar-se a um banco de dados, você pode querer saber sobre o ambiente atual:

MySQL:

-- Visualizar todos os bancos de dados
SHOW DATABASES;

-- Visualizar banco de dados atual
SELECT DATABASE();

-- Visualizar versão
SELECT VERSION();

PostgreSQL:

-- Visualizar todos os bancos de dados
\l

-- Visualizar banco de dados atual
SELECT current_database();

-- Visualizar versão
SELECT version();

SQLite:

-- Visualizar todas as tabelas
.tables

-- Visualizar informações do banco de dados
.database

-- Visualizar versão
SELECT sqlite_version();

Criando Seu Primeiro Banco de Dados e Tabela

Antes de aprender formalmente o SELECT, precisamos de dados para consultar. Aqui está o processo completo para criar um banco de dados e tabela:

Exemplo MySQL:

-- Criar banco de dados
CREATE DATABASE learn_sql;

-- Mudar para o banco de dados
USE learn_sql;

-- Criar tabela
CREATE TABLE students (
    id INT PRIMARY KEY AUTO_INCREMENT,
    name VARCHAR(50) NOT NULL,
    age INT,
    city VARCHAR(50)
);

-- Inserir dados de exemplo
INSERT INTO students (name, age, city) VALUES
('John', 20, 'New York'),
('Jane', 22, 'Los Angeles'),
('Bob', 21, 'Chicago'),
('Alice', 23, 'Houston'),
('Charlie', 20, 'New York');

Exemplo PostgreSQL:

CREATE DATABASE learn_sql;

-- Desconectar e reconectar ao learn_sql
\c learn_sql

CREATE TABLE students (
    id SERIAL PRIMARY KEY,
    name VARCHAR(50) NOT NULL,
    age INT,
    city VARCHAR(50)
);

INSERT INTO students (name, age, city) VALUES
('John', 20, 'New York'),
('Jane', 22, 'Los Angeles'),
('Bob', 21, 'Chicago'),
('Alice', 23, 'Houston'),
('Charlie', 20, 'New York');

Exemplo SQLite:

-- SQLite não requer criar banco de dados; crie a tabela diretamente
CREATE TABLE students (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    name TEXT NOT NULL,
    age INTEGER,
    city TEXT
);

INSERT INTO students (name, age, city) VALUES
('John', 20, 'New York'),
('Jane', 22, 'Los Angeles'),
('Bob', 21, 'Chicago'),
('Alice', 23, 'Houston'),
('Charlie', 20, 'New York');

Executando Sua Primeira Consulta SELECT

Agora que os dados estão prontos, vamos consultá-los:

-- Consultar todas as informações de todos os alunos
SELECT * FROM students;

Saída:

+----+---------+------+-----------+
| id | name    | age  | city      |
+----+---------+------+-----------+
|  1 | John    |   20 | New York  |
|  2 | Jane    |   22 | Los Angeles|
|  3 | Bob     |   21 | Chicago   |
|  4 | Alice   |   23 | Houston   |
|  5 | Charlie |   20 | New York  |
+----+---------+------+-----------+

Consultar Apenas Colunas Específicas:

-- Consultar apenas nome e cidade
SELECT name, city FROM students;

Saída:

+---------+-----------+
| name    | city      |
+---------+-----------+
| John    | New York  |
| Jane    | Los Angeles|
| Bob     | Chicago   |
| Alice   | Houston   |
| Charlie | New York  |
+---------+-----------+

🧪 Exemplos

Exemplo: Verificar Conexão do Banco de Dados Usando SELECT

O primeiro passo após instalar um banco de dados é confirmar que a conexão está funcionando.

-- Verificar se o banco de dados responde normalmente
SELECT 'Database connected!' AS message;

-- Visualizar hora atual e usuário
SELECT NOW() AS current_time, CURRENT_USER AS db_user;

A sintaxe do SQLite é ligeiramente diferente:

SELECT 'Database connected!' AS message;

SELECT datetime('now') AS current_time;

Saída de exemplo:

+---------------------+
| message             |
+---------------------+
| Database connected! |
+---------------------+

Este teste simples pode ajudá-lo a solucionar rapidamente problemas de conexão — se esta instrução executar, seu ambiente está configurado corretamente.

Exemplo: Criar uma Tabela, Inserir Dados e Consultar

Suponha que queremos gerenciar uma pequena biblioteca de livros.

-- Criar tabela books
CREATE TABLE books (
    id INT PRIMARY KEY,
    title VARCHAR(100) NOT NULL,
    author VARCHAR(50),
    price DECIMAL(8, 2),
    publish_year INT
);

-- Inserir dados de exemplo
INSERT INTO books (id, title, author, price, publish_year) VALUES
(1, 'Database Systems', 'Connolly', 45.00, 2014),
(2, 'SQL in 10 Minutes', 'Ben Forta', 39.00, 2020),
(3, 'High Performance MySQL', 'Baron Schwartz', 89.00, 2013),
(4, 'PostgreSQL in Action', 'Tan Feng', 69.00, 2018);

-- Consultar todos os livros
SELECT * FROM books;

Saída:

+----+-------------------------+-----------------+-------+---------------+
| id | title                   | author          | price | publish_year  |
+----+-------------------------+-----------------+-------+---------------+
|  1 | Database Systems        | Connolly        | 45.00 |          2014 |
|  2 | SQL in 10 Minutes       | Ben Forta       | 39.00 |          2020 |
|  3 | High Performance MySQL  | Baron Schwartz  | 89.00 |          2013 |
|  4 | PostgreSQL in Action    | Tan Feng        | 69.00 |          2018 |
+----+-------------------------+-----------------+-------+---------------+

Consultar Apenas Título e Preço:

SELECT title, price FROM books;

Ao especificar nomes de colunas (title, price) em vez de usar *, você pode tornar a saída mais clara e a consulta mais eficiente.

Exemplo: Consulta com Cálculos e Aliases

O SELECT do SQL pode não apenas consultar dados, mas também realizar cálculos.

-- Calcular anos desde a publicação de cada livro (baseado em 2026)
SELECT
    title AS book_title,
    author AS book_author,
    price AS original_price,
    price * 0.8 AS discounted_price,
    2026 - publish_year AS years_since_publish
FROM books;

Saída:

+-------------------------+-------------+----------------+------------------+--------------------+
| book_title              | book_author | original_price | discounted_price | years_since_publish|
+-------------------------+-------------+----------------+------------------+--------------------+
| Database Systems        | Connolly    |          45.00 |            36.00 |                 12 |
| SQL in 10 Minutes       | Ben Forta   |          39.00 |            31.20 |                  6 |
| High Performance MySQL  | Baron S.    |          89.00 |            71.20 |                 13 |
| PostgreSQL in Action    | Tan Feng    |          69.00 |            55.20 |                  8 |
+-------------------------+-------------+----------------+------------------+--------------------+

Pontos-Chave:

• A palavra-chave AS é usada para criar aliases para colunas, tornando a saída mais legível
• Você pode realizar operações matemáticas em colunas (ex: price * 0.8)
• Você pode misturar constantes e nomes de colunas (ex: 2026 - publish_year)

🏢 Aplicações em Cenários Reais

Cenário 1: Configuração de Ambiente de Desenvolvimento

Você é um desenvolvedor backend e um novo projeto requer um banco de dados MySQL. Complete as seguintes tarefas:

1. Instale o MySQL e inicie o serviço
2. Crie o banco de dados do projeto project_db
3. Crie uma tabela users para armazenar informações de usuários
4. Insira um registro de teste e verifique

-- Passo 1: Criar banco de dados
CREATE DATABASE project_db CHARACTER SET utf8mb4;

-- Passo 2: Mudar de banco de dados
USE project_db;

-- Passo 3: Criar tabela users
CREATE TABLE users (
    id INT PRIMARY KEY AUTO_INCREMENT,
    username VARCHAR(50) NOT NULL UNIQUE,
    email VARCHAR(100) NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

-- Passo 4: Inserir dados de teste
INSERT INTO users (username, email) VALUES
('testuser', 'test@example.com');

-- Passo 5: Verificar
SELECT * FROM users;

Cenário 2: Preparação para Análise de Dados

Você é um analista de dados que precisa examinar rapidamente dados CSV. Importe os dados para o SQLite para consulta.

# Operar na linha de comando
sqlite3 sales.db

-- Criar tabela
CREATE TABLE sales (
    id INTEGER PRIMARY KEY,
    product TEXT,
    quantity INTEGER,
    unit_price REAL,
    sale_date TEXT
);

# Importar dados CSV (usando comando .import)
.mode csv
.import sales_data.csv sales

# Visualizar resultados da importação
SELECT * FROM sales LIMIT 5;

# Visualizar contagem total de registros
SELECT COUNT(*) AS total_records FROM sales;

❓ Perguntas Frequentes

P: Devo escolher MySQL, PostgreSQL ou SQLite? R: Iniciantes devem começar com SQLite — zero configuração, um arquivo é o banco de dados. Escolha MySQL para desenvolvimento web e PostgreSQL para aplicações corporativas ou consultas complexas. Aprender todos os três é ideal, mas domine um primeiro.

P: E se eu esqueci a senha do root durante a instalação? R: Para MySQL, inicie com mysqld_safe --skip-grant-tables e redefina a senha. Para PostgreSQL, modifique o arquivo pg_hba.conf para mudar a autenticação para trust e reinicie o serviço. SQLite não tem mecanismo de senha, então não se preocupe.

P: Nada acontece após digitar uma instrução SQL na linha de comando. O que faço? R: Verifique se você esqueceu o ponto e vírgula ;. Instruções SQL devem terminar com ponto e vírgula para executar. Se você já digitou conteúdo sem ponto e vírgula, apenas adicione ; e pressione Enter.

P: Qual a diferença entre plataformas online e instalação local? R: Plataformas online não requerem instalação e estão prontas para uso, mas normalmente têm limites de tempo e tamanho de dados, e os dados são perdidos ao fechar o navegador. A instalação local não tem limites, os dados são salvos persistentemente, e é adequada para aprendizado de longo prazo e desenvolvimento de projetos reais.

📖 Resumo

Nesta lição, completamos a preparação do ambiente para aprendizado de SQL:

1. Instalando bancos de dados — Aprendemos a instalar MySQL, PostgreSQL e SQLite
2. Conexão via linha de comando — Dominamos a conexão e operação de bancos de dados usando ferramentas de linha de comando
3. Ferramentas GUI — Exploramos DBeaver, Navicat, DB Browser e outras ferramentas gráficas
4. Plataformas online — Descobrimos SQL Fiddle, DB Fiddle e outros ambientes de prática online
5. Primeira consulta — Aprendemos o básico da instrução SELECT, incluindo consultas, cálculos e aliases

Configurar o ambiente pode ser tedioso, mas é a base para todo o aprendizado seguinte. Assim como aprender a cozinhar requer familiarizar-se primeiro com a cozinha, conhecer suas ferramentas permite que você se concentre em "cozinhar" em si.

📝 Exercícios

Exercício 1: Verificação do Ambiente

Conecte-se ao seu banco de dados instalado, execute a seguinte consulta e confirme que a saída está correta:

SELECT 'Hello SQL!' AS greeting, 1 + 1 AS result;

Exercício 2: Criar e Consultar uma Tabela de Produtos

Crie uma tabela products com os seguintes campos, insira pelo menos 3 registros e depois consulte todos os registros:

Exercício 3: Consulta com Cálculos

Usando a tabela products do Exercício 2, escreva uma consulta que calcule o valor total do estoque (preço × estoque) para cada produto, e use aliases em português para as colunas de saída.

Exemplo de saída esperada:

+----------+------+--------+------------+
| Nome do Produto | Preço | Estoque | Valor Total do Estoque |
+----------+------+--------+------------+
| ...      | ...  | ...    | ...        |
+----------+------+--------+------------+

Próxima Lição: Lição 3: Consultas Básicas — SELECT e FROM

Equipe Técnica Web-Tutorial

Uma plataforma de tutoriais mantida por diversos desenvolvedores. Cada tutorial é escrito e revisado por profissionais da área correspondente. Trabalhamos para manter nosso conteúdo preciso e confiável — se encontrar algum problema, avise-nos.

Sobre Nós