{"id":19775409,"url":"https://github.com/manuseiro/sql-cheat-sheet","last_synced_at":"2026-03-19T11:38:59.839Z","repository":{"id":166294822,"uuid":"574726807","full_name":"manuseiro/sql-cheat-sheet","owner":"manuseiro","description":"O SQL Basics Cheat Sheet fornece a sintaxe de todas as cláusulas básicas, e mostra como escrever condições diferentes seguido com exemplos.","archived":false,"fork":false,"pushed_at":"2025-02-22T02:10:22.000Z","size":60,"stargazers_count":2,"open_issues_count":0,"forks_count":0,"subscribers_count":1,"default_branch":"main","last_synced_at":"2025-02-22T03:17:57.394Z","etag":null,"topics":["aggregation","aliases","grouping","join","managing","operators","sql","subqueries","trigger","views"],"latest_commit_sha":null,"homepage":"","language":null,"has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":null,"status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/manuseiro.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":null,"code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2022-12-06T00:06:38.000Z","updated_at":"2025-02-22T02:10:26.000Z","dependencies_parsed_at":"2024-05-19T19:45:40.874Z","dependency_job_id":"b4a607d3-0b67-4938-83d8-6a675bcc6b91","html_url":"https://github.com/manuseiro/sql-cheat-sheet","commit_stats":null,"previous_names":["manuseiro/sql-cheat-sheet"],"tags_count":0,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/manuseiro%2Fsql-cheat-sheet","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/manuseiro%2Fsql-cheat-sheet/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/manuseiro%2Fsql-cheat-sheet/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/manuseiro%2Fsql-cheat-sheet/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/manuseiro","download_url":"https://codeload.github.com/manuseiro/sql-cheat-sheet/tar.gz/refs/heads/main","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":241105891,"owners_count":19910716,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["aggregation","aliases","grouping","join","managing","operators","sql","subqueries","trigger","views"],"created_at":"2024-11-12T05:16:01.344Z","updated_at":"2026-02-13T03:02:51.618Z","avatar_url":"https://github.com/manuseiro.png","language":null,"readme":"# SQL Basics Cheat Sheet\n\nEste repositório contém uma coleção abrangente de cheat sheets de SQL para ajudar desenvolvedores, analistas de dados e estudantes a realizar consultas e manipulações de banco de dados de forma eficiente. Ele serve como uma referência rápida para iniciantes e profissionais que precisam dos comandos SQL mais comuns, com exemplos práticos.\n\n## Introdução\nStructured Query Language (SQL) é a linguagem padrão para manipulação de dados em sistemas de gerenciamento de banco de dados relacionais (**RDBMS**) ou para processamento de fluxos em sistemas de gerenciamento de dados relacionais (**RDSMS**). Desenvolvida na década de 1970 pela **IBM**, é amplamente usada em dialetos como MySQL, PostgreSQL, SQL Server e Oracle SQL. O PostgreSQL é um bom ponto de partida por seguir de perto a sintaxe SQL padrão, sendo facilmente adaptável a outros dialetos.\n\n### Componentes\n- **Consultas (Queries)**: Permitem recuperar dados com o comando `SELECT`.\n- **DDL (Data Definition Language)**: Define estruturas como tabelas e bancos de dados (`CREATE`, `ALTER`, `DROP`, `TRUNCATE`).\n- **DML (Data Manipulation Language)**: Manipula dados dentro das tabelas (`SELECT`, `INSERT`, `UPDATE`, `DELETE`).\n- **DCL (Data Control Language)**: Gerencia permissões e controle (`GRANT`, `REVOKE`).\n\n## Sintaxe SQL Básica \n\nSQL utiliza comandos para interagir com bancos de dados, como criar, modificar ou consultar tabelas e dados. \n\n A instrução **` SELECT `** é usada para recuperar dados de um banco de dados. Os dados retornados são armazenados em uma tabela de resultados, chamada conjunto de resultados. \n\n```sql\nSELECT nome_coluna1, nome_coluna2 FROM nome_tabela; \n```\nExemplo: **` SELECT nome, idade FROM usuarios; `**\n\nA instrução **` INSERT INTO `** é usada para inserir novas linhas de dados em uma tabela. \n\n```sql\nINSERT INTO tabela_usuarios (coluna_nome, coluna_idade) VALUES ('João', 25);\n```\n\nA instrução **` UPDATE `** é usada para modificar registros existentes em uma tabela.\n\n```sql\nUPDATE tabela_usuarios SET coluna_idade = 26 WHERE coluna_nome = 'João';\n```\n\nA instrução **` DELETE `** é usada para remover linhas de uma tabela.\n\n```sql\nDELETE FROM tabela_usuarios WHERE coluna_idade \u003c 18;\n```\n\nA instrução **` CREATE TABLE `** é usada para criar uma nova tabela em um banco de dados.\n\n```sql\nCREATE TABLE tabela_usuarios (\n    coluna_id INT PRIMARY KEY,\n    coluna_nome VARCHAR(50),\n    coluna_idade INT\n);\n```\n\nA instrução **` ALTER TABLE `** é usada para adicionar, excluir/descartar ou modificar colunas na tabela existente. Também é usado para adicionar e eliminar restrições na tabela existente.\n\n```sql\n-- Para adicionar uma coluna\nALTER TABLE tabela_usuarios ADD coluna_email VARCHAR(100);\n```\n\n```sql\n-- Para excluir/descartar coluna\nALTER TABLE nome_tabela\nDROP COLUMN nome_coluna;\n```\n\n```sql\n-- Para modificar a coluna existente\nALTER TABLE nome_tabela\nMODIFY COLUMN nome_coluna datatype;\n```\n\nA instrução DROP TABLE é usada para eliminar uma tabela existente em um banco de dados.\n\n```sql\nDROP TABLE tabela_usuarios;\n```\n\n### Palavras-chave (SQL keywords)\n\nSQL emprega uma série de palavras-chave de comando padrão que são essenciais para interagir com bancos de dados. Palavras-chave em SQL fornecem instruções sobre qual ação deve ser executada.\n\nAqui estão algumas das principais palavras-chave SQL:\n\n**SELECT**: Esta palavra-chave recupera dados de um banco de dados. Por exemplo,\n\n```sql\nSELECT * FROM tabela_clientes;\n```\n\nNa instrução acima ` * ` indica que todos os registros devem ser recuperados da tabela Clientes.\n\n**DISTINCT**: Usado para remover resultados duplicados\n\n**FROM**: Usado em conjunto com **` SELECT `** para especificar a tabela da qual buscar dados.\n\n**WHERE**: Usado para filtrar registros. Incorporando uma cláusula **` WHERE `**, você pode especificar condições que devem ser atendidas. Por exemplo,\n\n```sql\nSELECT * FROM tabela_clientes WHERE coluna_pais='Germany';\n```\n\n**INSERT INTO**: Este comando é usado para inserir novos dados em um banco de dados.\n\n```sql\nINSERT INTO tabela_clientes (coluna_cliente_ID, coluna_cliente_nome, coluna_nome_contato, coluna_endereco, Cidade, Codigo_Postal, coluna_pais)\nVALUES ('Cardinal','Tom B. Erichsen','Skagen 21','Stavanger','4006','Norway');\n```\n\n**UPDATE**: esta palavra-chave atualiza os dados existentes em uma tabela. Por exemplo,\n\n```sql\nUPDATE tabela_clientes SET coluna_nome_contato='Alfred Schmidt', coluna_cidade='Frankfurt' WHERE coluna_cliente_ID=1;\n```\n\n**DELETE**: Este comando remove um ou mais registros de uma tabela. Por exemplo,\n\n```sql\nDELETE FROM tabela_clientes WHERE coluna_cliente_nome='Alfreds Futterkiste';\n```\n\n**CREATE DATABASE**: Como seu nome indica, esta palavra-chave cria um novo banco de dados.\n\n```sql\nCREATE DATABASE meu_banco_dados;\n```\n\n**ALTER DATABASE**, **DROP DATABASE**, **CREATE TABLE**, **ALTER TABLE**, **DROP TABLE**: Essas palavras-chave são usadas para modificar bancos de dados e tabelas.\n\nLembre-se de que o SQL não diferencia maiúsculas de minúsculas, o que significa que as palavras-chave podem ser escritas em letras minúsculas. O ideal é escreve-las em ` MAIÚSCULAS ` para facilitar a leitura. Existem muito mais palavras-chave em SQL, mas estas são algumas das mais comuns.\n\n### Tipos de Dados (Data Types)\n\nOs tipos de dados SQL definem o tipo de dados que podem ser armazenados na coluna de uma tabela de banco de dados. Dependendo do **SGBD**, os nomes dos tipos de dados podem diferir ligeiramente. Aqui estão os tipos gerais:\n\n**` INT `** é usado para números inteiros. Por exemplo:\n\n```sql\nCREATE TABLE tabela_funcionarios (\n    ID INT,\n    coluna_nome VARCHAR(30)\n);\n```\n\n**` DECIMAL `** é usado para números decimais e fracionários. Por exemplo:\n\n```sql\nCREATE TABLE tabela_itens (\n    ID INT,\n    coluna_preco DECIMAL(5,2)\n);\n```\n\n**` CHAR `** é usado para strings de comprimento fixo. Por exemplo:\n\n```sql\nCREATE TABLE tabela_funcionarios (\n    ID INT,\n    coluna_inicial_nome CHAR(1)\n);\n```\n\n**` VARCHAR `** é usado para strings de comprimento variável. Por exemplo:\n\n```sql\nCREATE TABLE tabela_funcionarios (\n    ID INT,\n    Name VARCHAR(30)\n);\n```\n\n**` DATE `** é usado para datas no formato (YYYY-MM-DD).\n\n```sql\nCREATE TABLE tabela_funcionarios (\n    ID INT,\n    coluna_data_nascimento DATE\n);\n```\n\n**` DATETIME `** é usado para valores de data e hora no formato (YYYY-MM-DD HH:MI:SS).\n\n```sql\nCREATE TABLE tabela_pedidos (\n    ID INT,\n    coluna_data_pedido DATETIME\n);\n```\n\n**` BINARY `** é usado para strings binárias.\n\n**` BOOLEAN `** é usado para valores booleanos (**` TRUE `** or **` FALSE `**).\n\n\n*Lembre-se, a sintaxe específica para criar tabelas e definir tipos de dados de coluna pode variar um pouco dependendo do banco de dados SQL que você está usando (MySQL, PostgreSQL, SQL Server, SQLite, Oracle, etc.), mas o conceito geral e a organização dos tipos de dados são plataforma cruzada.*\n\n### Operadores (Operators)\n\nOperadores SQL são usados para realizar operações como comparações e cálculos aritméticos. Eles são muito cruciais na formação de consultas. Os operadores SQL são divididos nos seguintes tipos:\n\n**Operadores Aritméticos**: São usados para realizar operações matemáticas. Aqui está uma lista desses operadores:\n\n- **` + `** : Adição\n- **` - `** : Subtração\n- **` * `** : Multiplicação\n- **` / `** : Divisão\n- **` % `** : Modulo\n\nExemplo:\n\n```sql\nSELECT coluna_produto, coluna_preco, (coluna_preco * 0.18) as tax\nFROM tabela_produtos;\n```\n\n**Operadores de comparação**: são usados na cláusula where para comparar uma expressão com outra. Alguns desses operadores são:\n\n- **` = `**: Igual\n- **` != or \u003c\u003e `**: Diferente\n- **` \u003e `**: Maior que\n- **` \u003c `**: Menor que\n- **` \u003e= `**: Maior ou Igual\n- **` \u003c= `**: Menor ou Igual\n\nExemplo:\n\n```sql\nSELECT COLUNA_NOME, coluna_idade\nFROM tabela_estudante\nWHERE age \u003e 18;\n```\n**Operadores Lógicos**: São usados para combinar o conjunto de resultados de duas condições de componentes diferentes. Esses incluem:\n\n- **` AND `**: Retorna verdadeiro se ambos os componentes forem verdadeiros.\n- **` OU `**: Retorna verdadeiro se algum dos componentes for verdadeiro.\n- **` NOT `**: Retorna o valor booleano oposto da condição.\n\nExample:\n\n```sql\nSELECT * \nFROM tabela_funcionarios\nWHERE coluna_salario \u003e 50000 AND age \u003c 30;\n```\n\n**Operadores bitwise (bit a bit)**: executam operações em nível de bit nas entradas. Aqui está uma lista desses operadores:\n\n- **` \u0026 `**: Realiza uma conjunção lógica em duas expressões numéricas (E).\n- **` | `**: Realiza uma disjunção lógica em duas expressões numéricas (OU).\n- **` ^ `**: Executa uma exclusão lógica em duas expressões numéricas (OU Exclusivo).\n\nOperadores Bitwise são muito menos usados em SQL do que outros tipos de operadores.\n\n*Lembre-se de que o tipo de dados do resultado depende dos tipos dos operandos.*\n\n## Tabelas para Exemplos de uso:\n\nTabela **TABELA_PAIS**:\n| coluna_pais_id | coluna_nome   | coluna_populacao | coluna_area |\n|----------------|---------------|------------------|-------------|\n| 1              | Itália        | 60000000         | 301340      |\n| 2              | Brasil        | 214000000        | 8515767     |\n| 3              | Estados Unidos| 331900000        | 9833517     |\n| 4              | Argentina     | 45000000         | 2780400     |\n\nTabela **TABELA_CIDADE**:\n### Tabela `tabela_cidade`\n| coluna_cidade_id | coluna_nome | coluna_pais_id | coluna_populacao | coluna_rating |\n|------------------|-------------|----------------|------------------|---------------|\n| 1                | Florença    | 1              | 366000           | 3             |\n| 2                | Fortaleza   | 2              | 2700000          | 5             |\n| 3                | São Paulo   | 2              | 12300000         | 1             |\n| 4                | São Luís    | 2              | 1100000          | 4             |\n\nTabela **TABELA_FUNCIONARIOS**:\n| funcionarios_ID | coluna_nome | coluna_idade |coluna_posicao | coluna_salario | departamento_ID |\n| :---: | :---: | :---: | :---: | :---: | :---: |  \n| 1 | Janete | 25 | Manager | 50000 | 01|\n| 2 | Joao | 18 | Clerk | 30000 | 02 |\n| 3 | Roberto | 19 | Engineer | 40000 | 03 |\n| 4 | Carlos | 20 | CEO | 60000 | 04 |\n| 5 | Julio | 21 | Engineer | 40000 | 04 |\n| ... | ... | ... | ... | ... | ... |\n\nTabela **TABELA_DEPARTAMENTO**:\n| departamento_ID | coluna_departamento |\n| :---: | :---: | \n| 1 | Setor Pessoal |\n| 2 | Compras |\n| 3 | Contabilidade |\n| 4 | Administração |\n| ... | ... |\n\nTabela **TABELA_ESTUDANTE**:\n| estudante_ID | coluna_nome | coluna_idade | coluna_genero | coluna_data_nascimento |\n| :---: | :---: | :---: | :---: | :---: |  \n| 1 | Janete | 33 | Feminino | 01/04/1990 |\n| 2 | Joao | 32 | Masculino | 02/03/1991 |\n| 3 | Roberto | 31 | Masculino | 03/02/1992 |\n| 4 | Carlos | 30 | Masculino | 04/01/1993 |\n| ... | ... | ... | ... | ... | ... |\n\nTabela **TABELA_PRODUTOS**:\n| produtos_ID | coluna_produto | coluna_preco |\n| :---: | :---: | :---: |\n| 1 | Chocolate | 50000 |\n| 2 | Café | 30000 |\n| 3 | Leite | 40000 |\n| 4 | Mantega | 60000 | \n| ... | ... | ... | \n\nTabela **TABELA_PEDIDOS**:\n| pedidos_ID | coluna_pedido | cliente_id | coluna_valor_pedido | coluna_data_pedido |\n| :---: | :---: | :---: | :---: | :---: |  \n| 1 | 20230826001 | 01 | 50000 | 26-08-2023  00:00:00 |\n| 2 | 20230826002 | 02 | 30000 | 26-08-2023  00:00:00 |\n| 3 | 20230826003 | 03 | 40000 | 26-08-2023  00:00:00 |\n| 4 | 20230826004 | 04 | 60000 | 26-08-2023  00:00:00 |\n| ... | ... | ... | ... | ... |\n\n## SELECT\nA instrução ` SELECT ` em SQL é usada principalmente para buscar dados do banco de dados. É um dos elementos mais essenciais do SQL.\n\nEsta será a aparência do seu comando SELECT:\n\nSintaxe:\n```sql\nSELECT coluna_nome, coluna_posição FROM tabela_funcionarios;\n```\nSe quiser selecionar todas as colunas de uma tabela, você pode usar * assim:\n\n```sql\nSELECT * FROM tabela_funcionarios;\n```\n### Exemplo - SELECT\nConsidere que temos uma tabela ` TABELA_FUNCIONARIOS ` com colunas ` coluna_nome `, ` coluna_posicao ` e ` coluna_salario `. Podemos usar ` SELECT ` da seguinte maneira:\n\n```sql\nSELECT coluna_nome, coluna_posicao \nFROM tabela_funcionarios;\n```\nIsso recuperará todos os nomes e posicao de todos os funcionários da tabela `  TABELA_FUNCIONARIOS `:\n| coluna_nome | coluna_posicao |\n|-------------|----------------|\n| Janete      | Manager        |\n| Joao        | Clerk          |\n| Roberto     | Engineer       |\n| Carlos      | CEO            |\n| Julio       | Engineer       |\n| ........... | .............. |\n\n\n### SELECT DISTINCT\nA instrução ` SELECT DISTINCT ` é usada para retornar apenas valores distintos (diferentes). A palavra-chave ` DISTINCT ` elimina registros duplicados dos resultados.\n\nSintaxe:\n```sql\nSELECT DISTINCT coluna_nome1, coluna_nome2, ...\nFROM tabela_nome;\n```\n\n### Exemplo - SELECT DISTINCT\nSe quisermos selecionar todas as POSIÇÃO exclusivas da tabela ` TABELA_FUNCIONARIOS `, a consulta ficará assim:\n\n```sql\nSELECT DISTINCT coluna_posicao \nFROM tabela_funcionarios;\n```\n\nA consulta retornaria os valores únicos encontrados na coluna coluna_posicao da tabela ` TABELA_FUNCIONARIOS `:\n| coluna_posicao |\n| :---: |\n| Manager |\n| Clerk |\n| Engineer |\n| CEO |\n\n### SELECT WHERE\nA instrução `SELECT` combinada com `WHERE` nos dá a capacidade de filtrar registros com base em uma condição.\n\nSintaxe:\n```sql\nSELECT column1, column2, ...\nFROM TABELA_NOME\nWHERE CONDITION;\n```\n\n### Exemplo - SELECT WHERE\nConsiderando que temos a tabela ` TABELA_FUNCIONARIOS ` com as colunas ` funcionarios_ID `,\t` coluna_nome `, ` coluna_posicao ` e ` coluna_salario `. Para selecionar funcionários com salário superior a 50.000, você pode usar esta consulta:\n\n```sql\nSELECT * \nFROM tabela_funcionarios \nWHERE coluna_salario \u003e 50000;\n```\n\nA consulta retornaria somente os valores onde o Salario é superior a 50.000:\n\n| funcionarios_ID | coluna_nome | coluna_posicao | coluna_salario | coluna_data_nascimento |\n| :---: | :---: | :---: | :---: | :---: |  \n| 4 | Carlos | CEO | 60000 | 04-01-1993 |\n\n##  FROM\n\nA cláusula FROM em SQL especifica as tabelas das quais a recuperação deve ser feita. É parte integrante das instruções SELECT e variantes de SELECT como ` SELECT INTO ` e ` SELECT WHERE `. ` FROM ` também pode ser usado para unir tabelas.\n\nNormalmente, ` FROM ` é seguido por uma lista delimitada por espaço de tabelas nas quais a operação ` SELECT ` deve ser executada. Se precisar extrair dados de várias tabelas, separe cada tabela com uma vírgula.\n\nAqui estão alguns exemplos:\n\n### Exemplo 1 – Uso Simples\n\nSe você tiver uma tabela chamada ` TABELA_FUNCIONARIOS `, poderá selecionar todos os dados dos funcionários assim:\n\n```sql\nSELECT * \nFROM tabela_funcionarios;\n```\n\nNeste exemplo, ` * ` significa “todas as colunas”. Então, ` SELECT * FROM tabela_funcionarios; ` recuperará todos os dados da tabela de **Funcionários**.\n\n### Exemplo 2 – FROM com múltiplas tabelas\n\nSe você tiver várias tabelas, digamos, ` TABELA_FUNCIONARIOS ` e ` TABELA_DEPARTAMENTO `, e quiser selecionar dados de ambos, poderá fazer o seguinte:\n\n```sql\nSELECT tabela_funcionarios.coluna_nome, tabela_departamento.coluna_departamento \nFROM tabela_funcionarios, tabela_departamento \nWHERE tabela_funcionarios.departamento_ID = tabela_departamento.departamento_ID;\n```\nNeste exemplo, a cláusula FROM é seguida por duas tabelas: ` TABELA_FUNCIONARIOS ` e ` TABELA_DEPARTAMENTO `. ` tabela_funcionarios.coluna_nome ` e ` tabela_departamento.coluna_departamento.coluna_departamento ` indicam que estamos selecionando a ` coluna_nome ` da ` TABELA_FUNCIONARIOS ` e a coluna ` coluna_departamento ` da tabela ` TABELA_DEPARTAMENTO `.\n\n| coluna_nome | coluna_departamento |\n| :---------: | :-----------------: |\n| Janete      | Setor Pessoal       |\n| Joao        | Compras             |\n| Roberto     | Contabilidade       |\n| Carlos      | Administração       |\n| Julio       | Administração       |\n| ...         | ...                 |\n\nLembre-se, sempre respeite a ordem das operações no SQL. A cláusula ` FROM ` funciona somente após a identificação das tabelas.\n\nEm consultas SQL complexas em que pode ser necessário extrair dados de diversas tabelas, os aliases são usados para renomear temporariamente as tabelas na instrução SQL individual.\n\n### Exemplo 3 – FROM com Aliases\n\nAbaixo está um exemplo de cláusula ` FROM ` com aliases:\n\n```sql\nSELECT e.coluna_nome, d.coluna_departamento \nFROM tabela_funcionarios AS e, tabela_departamento AS d\nWHERE e.departamento_ID = d.departamento_ID;\n```\n\nNeste exemplo, as tabelas ` TABELA_FUNCIONARIOS ` e ` TABELA_DEPARTAMENTO ` são denominadas ` E ` e ` D `, respectivamente.\n\n| coluna_nome | coluna_departamento |\n| :---------: | :-----------------: |\n| Janete      | Setor Pessoal       |\n| Joao        | Compras             |\n| Roberto     | Contabilidade       |\n| Carlos      | Administração       |\n| Julio       | Administração       |\n| ...         | ...                 |\n\nÉ isso! Lembre-se que ` FROM ` não se limita apenas a ` SELECT `. Também é aplicável às operações ` UPDATE ` e ` DELETE `.\n\n## WHERE\n\nSQL fornece uma cláusula ` WHERE ` que é basicamente usada para filtrar os registros. Se a condição especificada na cláusula ` WHERE ` for satisfeita, somente ela retornará o valor específico da tabela. Você deve usar a cláusula WHERE para filtrar os registros e buscar apenas os registros necessários.\n\nA cláusula ` WHERE ` não é usada apenas na instrução ` SELECT `, mas também nas instruções ` UPDATE `, ` DELETE `, etc., que aprenderemos nos capítulos subsequentes.\n\nUm exemplo de sua implementação é:\n\n```sql\nSELECT * FROM tabela_estudante WHERE coluna_idade \u003e 10;\n```\n\nNeste exemplo, a instrução seleciona todos os campos da tabela ‘Alunos’ onde o valor do campo ‘Idade’ é maior que 10.\n\nA cláusula ` WHERE ` pode ser combinada com os operadores ` AND `, ` OR ` e ` NOT `. Aqui está um exemplo:\n\n```sql\nSELECT * FROM tabela_estudante WHERE coluna_idade \u003e 10 AND coluna_genero = 'Feminino';\n```\n\nNeste exemplo, a instrução seleciona todos os campos da tabela ‘tabela_estudante’ onde o valor do campo ‘Idade’ é maior que 10 e o ‘Sexo’ é Feminino.\n\nA sintaxe geralmente é assim:\n\n```sql\nSELECT coluna_nome1, coluna_nome2, ...\nFROM tabela_nome\nWHERE condicao;\n```\n## ORDER BY\n\nA cláusula ` ORDER BY ` em SQL é usada para classificar o conjunto de resultados de uma instrução ` SELECT ` em ordem crescente ou decrescente. Ele classifica os registros em ordem crescente por padrão. Se quiser classificar os registros em ordem decrescente, você deve usar a palavra-chave ` DESC `.\n\n**Sintaxe para Ordem Crescente:**\n\n```sql\nSELECT column1, column2, ...\nFROM TABELA_NOME\nORDER BY column1, column2, ... ASC;\n```\nAqui, ` ASC ` é usado para ordem crescente. Se você usar ` ORDER BY ` sem ` ASC ` ou ` DESC `, ` ASC ` será usado por padrão.\n\n**Sintaxe para Ordem Decrescente:**\n\n```sql\nSELECT column1, column2, ...\nFROM TABELA_NOME\nORDER BY column1, column2, ... DESC;\n```\n\nAqui, ` DESC ` é usado para ordem decrescente.\n\n**Exemplo de uso**\n\nConsidere a seguinte tabela ` TABELA_CLIENTES `:\n\n| clientes_ID | coluna_nome | coluna_idade | coluna_salario | departamento_ID |\n| :---------: | :---------: | :----------: | :------------: | :-------------: | \n| 1           | Janete      | 25           | 50000          | 01              |\n| 2           | Joao        | 18           | 30000          | 02              |\n| 3           | Roberto     | 19           | 40000          | 03              |\n| 4           | Carlos      | 20           | 60000          | 04              |\n| 5           | Julio       | 21           | 40000          | 04              |\n| ...         | ...         | ...          | ...            | ...             |\n\n**Exemplo 1 - Ordem Crescente:**\n\nClassifique a tabela pela coluna ` coluna_nome ` em Ordem Crescente:\n\n```sql\nSELECT * FROM tabela_clientes\nORDER BY coluna_nome ASC;\n```\n\n**Exemplo 2 - Ordem Decrescente:**\n\nClassifique a tabela pela coluna coluna_salario em Ordem Decrescente:\n\n```sql\nSELECT * FROM tabela_clientes\nORDER BY coluna_salario DESC;\n```\n\n**Exemplo 3 - Múltiplas Colunas:**\n\nVocê também pode classificar por várias colunas. Classifique a tabela pela coluna ` coluna_idade ` em ordem crescente e depois ` coluna_salario ` em Ordem Decrescente:\n\n```sql\nSELECT * FROM tabela_clientes\nORDER BY coluna_idade ASC, coluna_salario DESC;\n```\n\nNeste caso, a cláusula ` ORDER BY ` primeiro classifica a tabela ` TABELA_CLIENTES ` pela coluna ` coluna_idade ` e depois classifica o resultado classificado pela coluna ` coluna_salario `.\n\n## GROUP BY\n“Group By” é uma cláusula SQL usada para organizar dados idênticos em grupos. Esta cláusula se enquadra na categoria de Funções de Grupo, junto com Contagem, Soma, Média, etc.\n\n**A sintaxe para 'Group by' é:**\n\n```sql\nSELECT coluna_nome1, coluna_nome2\nFROM tabela_nome\nGROUP BY coluna_nome1, coluna_nome2;\n```\nAqui, coluna_nome1, coluna_nome2, são os nomes das colunas com base nas quais queremos agrupar os resultados.\n\n**Exemplo:**\n\nSuponha que temos uma tabela ` TABELA_VENDAS `. Esta tabela possui três colunas: vendas_ID, coluna_item e coluna_valor.\n| vendas_ID | coluna_item | coluna_valor |\n| :---:     | :---:       | :---:        |\n| 1         | carro       | 50000        |\n| 2         | moto        | 30000        |\n| 3         | barco       | 40000        | \n| 4         | casa        | 60000        |\n| 5         | apartamento | 40000        |\n| 6         | carro       | 30000        |\n| 7         | casa        | 60000        |\n| 8         | moto        | 30000        |\n| ...       | ...         | ...          |\n\nExecute a seguinte instrução SQL…\n\n```sql\nSELECT coluna_item, SUM(coluna_valor)\nFROM tabela_vendas\nGROUP BY coluna_item;\n```\n| coluna_item | SUM(coluna_valor) |\n| ----------- | ----------------- |\n| carro       | 80000             |\n| moto        | 60000             |\n| barco       | 40000             |\n| casa        | 120000            |\n| apartamento | 40000             |\n| ...         | ...               |\n\nIsso irá concatenar, ou “**agrupar**”, todos os itens iguais em uma linha, aplicando a função ` SUM() ` em seus respectivos Valores. A saída será então:\n\n**Group By com cláusula HAVING**\n\nA cláusula Group By também pode ser usada com a palavra-chave HAVING. A palavra-chave HAVING permite filtrar os resultados da função de grupo.\n\nPor exemplo:\n\n```sql\nSELECT coluna_item, SUM(coluna_valor)\nFROM tabela_vendas\nGROUP BY coluna_item\nHAVING SUM(coluna_valor) \u003e 150;\n```\n\nIsso retornará todos os itens agrupados onde o valor total for superior a 150. Portanto, o resultado será:\n\n| coluna_item | SUM(coluna_valor) |\n| ----------- | ----------------- |\n| casa        | 120000            |\n| ...         | ...               |\n\n\n## APELIDOS (ALIASES)\n\n### Exemplo em Colunas\nUm alias ou apelido é um nome alternativo que pode ser atribuído a uma tabela ou a uma coluna em uma consulta. Isso pode ser útil para simplificar a consulta, melhorar a legibilidade do código ou evitar conflitos de nome.\n\nExemplo de consulta utilizando alias na coluna ` coluna_nome ` da tabela ` TABELA_CLIDADE `, com o apelido (AS) ` coluna_cidade `:\n\n```sql\nSELECT COLUNA_NOME AS coluna_cidade\nFROM TABELA_CIDADE;\n```\nNeste exemplo, em vez de retornar a coluna ` coluna_nome ` com o nome original, a consulta retorna a mesma coluna com o apelido ` coluna_cidade `. Esse apelido pode ser usado para se referir à coluna em outras partes da consulta, como em cláusulas ` WHERE ` ou em outras junções.\n\nResultado:\n| cidade_ID | coluna_cidade |\n| :---: | :---: | \n| 4 | Maranhão | \n| 3 | São Paulo | \n| 2 | Fortaleza | \n| 1 | Florença | \n| ... | ... | \n\n### Exemplo em Tabela\nOutra forma de utilizar aliases é atribuir apelidos às tabelas em uma consulta.\n\nExemplo de consulta utilizando alias nas tabelas CITY e COUNTRY, com os apelidos CI e CO, respectivamente:\n```sql\nSELECT co.COLUNA_NOME, ci.COLUNA_NOME\nFROM TABELA_CIDADE AS ci\nJOIN tabela_pais AS co\n  ON ci.COLUNA_PAIS_ID = co.id;\n```\n\nNeste exemplo, as tabelas CITY e COUNTRY foram apelidadas de CI e CO, respectivamente. Isso permite referenciar as tabelas de forma mais concisa na consulta. A junção é realizada comparando os valores das colunas COUNTRY_ID da tabela CI (apelido para CITY) e ID da tabela CO (apelido para COUNTRY).\n\nResultado:\n| id | name | population | area |\n| :---: | :---: | :---: | :---: |\n| 1 | Italia | 66600000 | 640000 |\n| 2 | Brazil | 21400000 | 851000000 |\n\n| id | name | COLUNA_PAIS_ID | population | rating |\n| :---: | :---: | :---: | :---: | :---: |\n| 1 | Florença | 1 | 22400000 | 3 |\n| 2 | Fortaleza | 2 | 26800000 | 5 |\n| 3 | São Paulo | 2 | 12300000 | 1 |\n| 4 | Maranhão | 2 | 685000000 | 33 |\n\n_OBS: JOIN (ou explicitamente INNER JOIN) retorna linhas que possuem valores correspondentes em ambas as tabelas._\n\n## SUBCONSULTAS (SUBQUERIES)\nUma subconsulta é uma consulta aninhada dentro de outra consulta ou dentro de outra subconsulta. Existem diferentes tipos de subconsultas.\n\n### SINGLE VALUE\nA subconsulta mais simples retorna exatamente uma coluna e exatamente uma linha. Pode ser usado com operadores de comparação =, \u003c, \u003c=, \u003e ou \u003e=.\n\nEsta consulta encontra cidades com a mesma classificação de Paris:\n```sql\nSELECT COLUNA_NOME \nFROM TABELA_CIDADE\nWHERE rating = (\n\tSELECT rating\n\tFROM TABELA_CIDADE\n\tWHERE name = 'Paris'\n);\n```\n### MULTIPLE VALUES\nUma subconsulta também pode retornar várias colunas ou várias linhas. Essas subconsultas podem ser usadas com os operadores IN, EXISTS, ALL ou ANY.\n\nEsta consulta encontra cidades em países com população acima de 20 milhões:\n```sql\nSELECT COLUNA_NOME\nFROM TABELA_CIDADE\nWHERE COLUNA_PAIS_ID IN (\n\tSELECT COLUNA_PAIS_ID\n\tFROM tabela_pais\n\tWHERE population \u003e 20000000\n);\n```\n\n### CORRELATED\nUma subconsulta correlacionada refere-se às tabelas introduzidas na consulta externa. Uma subconsulta correlacionada depende da consulta externa. Ele não pode ser executado independentemente da consulta externa.\n\nEsta consulta encontra cidades com uma população maior que a população média do país:\n```sql\nSELECT *\nFROM TABELA_CIDADE main_TABELA_CIDADE\nWHERE population \u003e (\n\tSELECT AVG(population)\n\tFROM TABELA_CIDADE average_TABELA_CIDADE\n\tWHERE average_TABELA_CIDADE.COLUNA_PAIS_ID = main_TABELA_CIDADE.COLUNA_PAIS_ID\n);\n```\nEsta consulta encontra países que possuem pelo menos uma cidade:\n```sql\nSELECT COLUNA_NOME\nFROM tabela_pais\nWHERE EXISTS (\n\tSELECT *\n\tFROM TABELA_CIDADE\n\tWHERE COLUNA_PAIS_ID = tabela_pais.id\n);\n```\n### OPERADORES DE COMPARAÇÃO (COMPARISON OPERATORS)\n\na) Consultar **`coluna_nome`** da **`CITY`** com **`RATING`** acima de 3\n```sql\nSELECT COLUNA_NOME\nFROM TABELA_CIDADE\nWHERE rating \u003e 3;\n```\nResultado:\n| name |\n| :---: |\n| Fortaleza |\n| Maranhão |\n\nb) Consultar **`coluna_nome`** de **`CITY`** diferente de `FLORENÇA` e `FORTALEZA`\n```sql\nSELECT COLUNA_NOME\nFROM TABELA_CIDADE\nWHERE name != 'Florença'\n  AND name != 'Fortaleza';\n```\nResultado:\n| name |\n| :---: |\n| São Paulo |\n| Maranhão |\n\n### OPERADORES DE TEXTO (TEXT OPERATORS)\n\na) Consultar **`coluna_nome`** de **`CITY`** que começam com 'f' ou terminam com 'a':\n```sql\nSELECT COLUNA_NOME\nFROM TABELA_CIDADE\nWHERE name LIKE 'f%'\n  OR name LIKE '%a';\n```\nResultado:\n| id | name |\n| :---: | :---: |\n| 1 | Florença |\n| 2 | Fortaleza |\n\nb) Consultar **`coluna_nome`** de **`CITY`** que começe com qualquer letra seguida por 'ortaleza':\n```sql\nSELECT COLUNA_NOME\nFROM TABELA_CIDADE\nWHERE name LIKE '_ortaleza';\n```\nResultado:\n| id | name |\n| :---: | :---: |\n| 2 | Fortaleza |\n\n### OUTROS OPERADORES (OTHER OPERATORS)\n\na) Consultar **`coluna_nome`** de **`CITY`** com `POPULATION` entre(between) 500K e 5M:\n```sql\nSELECT COLUNA_NOME\nFROM TABELA_CIDADE\nWHERE population BETWEEN 500000 AND 5000000;\n```\nb) Consultar **`coluna_nome`** de **`CITY`** que não possuem um valor de **`RATING`**:\n```sql\nSELECT COLUNA_NOME\nFROM TABELA_CIDADE\nWHERE rating IS NOT NULL;\n```\nc) Consultar **`coluna_nome`** de **`CITY`** que estão em `COUNTRY` com `IDs` 1, 4, 7 ou 8:\n```sql\nSELECT COLUNA_NOME\nFROM TABELA_CIDADE\nWHERE COLUNA_PAIS_ID IN (1, 4, 7, 8);\n```\n\n## GERENCIANDO TABELAS\n\n### Criar Tabela\n```sql\nCREATE TABLE tabela_bairro (\n    coluna_id INT PRIMARY KEY,\n    coluna_nome VARCHAR(50) NOT NULL,\n    coluna_preco INT DEFAULT 0\n);\n\n```\n\nAdicionar Coluna\n```sql\nALTER TABLE tabela_bairro ADD coluna_riqueza BIGINT;\n```\n\nInserir Dados\n```sql\nINSERT INTO tabela_bairro (coluna_nome, coluna_preco, coluna_riqueza)\nVALUES ('Fortaleza', 2000000, 4000000000);\n```\n\nExcluir Coluna\n```sql\nALTER TABLE tabela_bairro DROP COLUMN coluna_riqueza;\n```\n\nAdicionar Restrição\n```sql\nALTER TABLE tabela_bairro ADD CONSTRAINT chk_preco CHECK (coluna_preco \u003e= 0);\n```\n\nRenomear Tabela\n```sql\nALTER TABLE tabela_bairro REcoluna_nome TO tabela_distrito;\n```\n\n## GERENCIANDO GATILHOS(TRIGGERS)\n\nGatilhos (**Triggers**) são regras automáticas definidas em uma tabela que disparam ações específicas em resposta a eventos como inserção (`INSERT`), atualização (`UPDATE`) ou exclusão (`DELETE`) de dados. Eles são úteis para auditoria, validação de dados ou manutenção de consistência.\n\n### Sintaxe Básica\n```sql\nCREATE TRIGGER nome_do_gatilho\n[BEFORE | AFTER] [INSERT | UPDATE | DELETE]\nON nome_da_tabela\nFOR EACH ROW\nEXECUTE FUNCTION nome_da_funcao();\n```\n\n- **`BEFORE`**: Executa o gatilho antes do evento.\n- **`AFTER`**: Executa o gatilho após o evento.\n- **`FOR EACH ROW`**: Aplica o gatilho a cada linha afetada.\n- **`EXECUTE FUNCTION`**: Chama uma função (ou procedimento) definida previamente.\n\n### Criando uma Função para o Gatilho\n\nAntes de criar um gatilho, é necessário definir uma função que ele executará. Aqui está um exemplo em PostgreSQL para registrar alterações:\n\n```sql\nCREATE OR REPLACE FUNCTION registrar_log()\nRETURNS TRIGGER AS $$  \nBEGIN\n    INSERT INTO tabela_log (coluna_acao, coluna_data, coluna_usuario)\n    VALUES (TG_OP, NOW(), CURRENT_USER);\n    RETURN NEW;\nEND;\n  $$ LANGUAGE plpgsql;\n```\n- **`TG_OP`**: Retorna o tipo de operação (`INSERT`, `UPDATE`, `DELETE`).\n- **`NEW`**: Representa a nova linha (usado em `INSERT` e `UPDATE`).\n- **`OLD`**: Representa a linha antiga (usado em `DELETE` e `UPDATE`).\n\n### Exemplo 1 – Gatilho de Auditoria (AFTER INSERT)\n\nVamos usar a `tabela tabela_funcionarios` para registrar inserções em uma tabela de log.\n\n### Tabela de Log\n```sql\nCREATE TABLE tabela_log (\n    coluna_id SERIAL PRIMARY KEY,\n    coluna_acao VARCHAR(10),\n    coluna_data TIMESTAMP,\n    coluna_usuario VARCHAR(50)\n);\n```\n\n### Gatilho\n```sql\nCREATE TRIGGER log_insercao_funcionario\nAFTER INSERT ON tabela_funcionarios\nFOR EACH ROW\nEXECUTE FUNCTION registrar_log();\n```\n\n### Teste\n```sql\nINSERT INTO tabela_funcionarios (coluna_nome, coluna_idade, coluna_posicao, coluna_salario, departamento_id)\nVALUES ('Maria', 30, 'Analista', 45000, '03');\n```\n### Resultado em 'tabela_log'\n\n| coluna_id      | coluna_acao   | coluna_data        | coluna_usuario |\n|----------------|---------------|--------------------|----------------|\n| 1              | INSERT        | 2025-02-21 10:00:00| usuario_atual  |\n\n### Exemplo 2 – Validação (BEFORE UPDATE)\n\nImpedir que o salário em `tabela_funcionarios` seja reduzido.\n\n### Função\n```sql\nCREATE OR REPLACE FUNCTION validar_salario()\nRETURNS TRIGGER AS $$  \nBEGIN\n    IF NEW.coluna_salario \u003c OLD.coluna_salario THEN\n        RAISE EXCEPTION 'O salário não pode ser reduzido!';\n    END IF;\n    RETURN NEW;\nEND;\n  $$ LANGUAGE plpgsql;\n```\n  \n### Gatilho\n```sql\nCREATE TRIGGER impedir_reducao_salario\nBEFORE UPDATE ON tabela_funcionarios\nFOR EACH ROW\nEXECUTE FUNCTION validar_salario();\n```\n\n### Teste\n```sql\nUPDATE tabela_funcionarios SET coluna_salario = 40000 WHERE coluna_nome = 'Carlos';\n-- Erro: \"O salário não pode ser reduzido!\"\n```\n### Exemplo 3 – Gatilho de Exclusão (AFTER DELETE)\n\nRegistrar exclusões em `tabela_log`.\n\n### Função\n```sql\nCREATE OR REPLACE FUNCTION log_exclusao()\nRETURNS TRIGGER AS $$  \nBEGIN\n    INSERT INTO tabela_log (coluna_acao, coluna_data, coluna_usuario)\n    VALUES ('DELETE', NOW(), CURRENT_USER);\n    RETURN OLD;\nEND;\n  $$ LANGUAGE plpgsql;\n```  \n### Gatilho\n```sql\nCREATE TRIGGER log_exclusao_funcionario\nAFTER DELETE ON tabela_funcionarios\nFOR EACH ROW\nEXECUTE FUNCTION log_exclusao();\n```\n### Teste\n```sql\nDELETE FROM tabela_funcionarios WHERE coluna_nome = 'João';\n```\n\n### Resultado em `tabela_log`\n| coluna_id      | coluna_acao   | coluna_data        | coluna_usuario |\n|----------------|---------------|--------------------|----------------|\n| 2              | DELETE        | 2025-02-21 10:05:00| usuario_atual  |\n\n### Excluir um Gatilho\n```sql\nDROP TRIGGER log_insercao_funcionario ON tabela_funcionarios;\n```\n\n## GERENCIANDO VISUALIZAÇÕES (VIEWS)\nViews (ou visualizações) são tabelas virtuais criadas a partir de uma consulta SQL. Elas não armazenam dados fisicamente, mas exibem resultados de uma query como se fossem uma tabela real. São úteis para simplificar consultas complexas, restringir acesso a dados sensíveis ou fornecer uma visão personalizada de uma tabela.\n\n### Sintaxe Básica\n```sql\nCREATE VIEW nome_da_view AS\nSELECT coluna1, coluna2\nFROM tabela\n[WHERE condição];\n```\n\n### Exemplo 1 – Criar uma View Simples\n\nVamos criar uma view para exibir apenas nomes e posições da tabela **`tabela_funcionarios`**.\n```sql\nCREATE VIEW vista_funcionarios AS\nSELECT coluna_nome, coluna_posicao\nFROM tabela_funcionarios;\n```\n\n### Uso\n```sql\nSELECT * FROM vista_funcionarios;\n```\n\n### Resultado\n| coluna_nome | coluna_posicao |\n| :---------: | :------------: |\n| Janete      | Manager        |\n| João        | Clerk          |\n| Roberto     | Engineer       |\n| Carlos      | CEO            |\n| Julio       | Engineer       |\n| ........... | .............. |\n\n### Exemplo 2 – View com Filtro\n\nCriar uma view para mostrar apenas funcionários com salário acima de 40.000.\n\n```sql\nCREATE VIEW vista_funcionarios_alta_renda AS\nSELECT coluna_nome, coluna_posicao, coluna_salario\nFROM tabela_funcionarios\nWHERE coluna_salario \u003e 40000;\n```\n\n### Uso\n```sql\nSELECT * FROM vista_funcionarios_alta_renda;\n```\n\n### Resultado\n\n| coluna_nome | coluna_posicao | coluna_salario |\n| :---------: | :------------: | :------------: |\n| Janete      | Manager        | 50000          |\n| Carlos      | CEO            | 60000          |\n| ........... | .............. | .............. |\n\n### Exemplo 3 – View com Junção\n\nCriar uma view combinando tabela_funcionarios e tabela_departamento.\n\n```sql\nCREATE VIEW vista_funcionarios_departamento AS\nSELECT f.coluna_nome, f.coluna_posicao, d.coluna_departamento\nFROM tabela_funcionarios f\nINNER JOIN tabela_departamento d\nON f.departamento_id = d.departamento_id;\n```\n\n### Uso\n```sql\nSELECT * FROM vista_funcionarios_departamento;\n```\n\n| coluna_nome | coluna_posicao | coluna_departamento |\n| :---------: | :------------: | :-----------------: |\n| Janete      | Manager        | Setor Pessoal       |\n| João        | Clerk          | Compras             |\n| Roberto     | Engineer       | Contabilidade       |\n| Carlos      | CEO            | Administração       |\n| Julio       | Engineer       | Administração       |\n| ........... | .............. | ................... |\n\n### Exemplo 4 – View com Atualização (Updatable View)\n\nViews podem ser configuradas para permitir atualizações, desde que tenham uma relação direta com uma única tabela e não usem junções ou agregações.\n\n```sql\nCREATE VIEW vista_funcionarios_editable AS\nSELECT coluna_nome, coluna_idade\nFROM tabela_funcionarios\nWHERE coluna_idade \u003e 20;\n```\n\n### Atualização\n\n```sql\nUPDATE vista_funcionarios_editable\nSET coluna_idade = 26\nWHERE coluna_nome = 'Janete';\n```\n\n### Resultado na tabela Base\n\nA tabela `tabela_funcionarios` será atualizada onde `coluna_nome = 'Janete'`.\n\n### Exemplo 5 – View Materializada (PostgreSQL)\n\nViews materializadas armazenam dados fisicamente para melhorar a performance em consultas pesadas. Elas precisam ser atualizadas manualmente.\n\n```sql\nCREATE MATERIALIZED VIEW vista_cidades_populosas AS\nSELECT coluna_nome, coluna_populacao\nFROM tabela_cidade\nWHERE coluna_populacao \u003e 1000000;\n```\n\n### Atualizar Dados\n```sql\nREFRESH MATERIALIZED VIEW vista_cidades_populosas;\n```\n\n### Uso\n```sql\nSELECT * FROM vista_cidades_populosas;\n```\n\n### Resultado\n| coluna_nome | coluna_populacao |\n| :---------: | :--------------: |\n| Fortaleza   | 2700000          |\n| São Paulo   | 12300000         |\n| São Luís    | 1100000          |\n| ........... | ................ |\n\n### Exemplo 6 – View Temporária\n\nCria uma view que existe apenas durante a sessão atual.\n```sql\nCREATE TEMPORARY VIEW vista_temp_funcionarios AS\nSELECT coluna_nome, coluna_salario\nFROM tabela_funcionarios;\n```\n\n### Substituir uma View Existente\n\nSe precisar recriar uma view, use `CREATE OR REPLACE`.\n```sql\nCREATE OR REPLACE VIEW vista_funcionarios AS\nSELECT coluna_nome, coluna_posicao, coluna_salario\nFROM tabela_funcionarios;\n```\n### Excluir uma View\n```sql\nDROP VIEW vista_funcionarios;\n```\n### Com Verificação\nPara evitar erros se a view não existir:\n\n```sql\nDROP VIEW IF EXISTS vista_funcionarios;\n```\n\n## MODIFICANDO DADOS (MODIFYING DATA)\n\n## CONSULTANDO EM MÚLTIPLAS TABELAS (QUERYING FROM MULTIPLE TABLES)\n\nTabela COUNTRY (País)\n| id | name |\n| :---: | :---: |\n| 1 | Italia |\n| 2 | Brazil |\n| 3 | Estados Unidads |\n| 4 | Argentina |\n| ... | ... |\n\nTabela CITY (Cidade)\n| id | name | COLUNA_PAIS_ID |\n| :---: | :---: | :---: |\n| 1 | Florença | 1 |\n| 2 | Fortaleza | 2 |\n| 3 | São Paulo | 2 |\n| 4 | Maranhão | 2 |\n| ... | ... | ... |\n\n### INNER JOIN\nJOIN (ou explicitamente INNER JOIN) retorna apenas as linhas das tabelas que têm correspondência na outra tabela. Em outras palavras, somente os registros que possuem valores correspondentes em ambas as tabelas são incluídos no resultado.\n```sql\nSELECT TABELA_CIDADE.COLUNA_NOME, TABELA_PAIS.COLUNA_NOME\nFROM TABELA_CIDADE\n[INNER] JOIN tabela_pais\nON TABELA_CIDADE.COLUNA_PAIS_ID = tabela_pais.id;\n```\nResultado:\n| TABELA_CIDADE.COLUNA_NOME | TABELA_PAIS.COLUNA_NOME |\n| :---: | :---: |\n| Florença | Italia |\n| Fortaleza | Brazil |\n| São Paulo | Brazil |\n| Maranhão | Brazil |\n| ... | ... |\n\n### LEFT JOIN\nLEFT JOIN retorna todas as linhas da tabela esquerda com linhas correspondentes da tabela à direita. Se não houver linha correspondente, NULLs são retornados como valores do segunda mesa.\n```sql\nSELECT TABELA_CIDADE.COLUNA_NOME, TABELA_PAIS.COLUNA_NOME\nFROM TABELA_CIDADE\nLEFT JOIN tabela_pais\nON TABELA_CIDADE.COLUNA_PAIS_ID = tabela_pais.id;\n```\n### RIGHT JOIN\nRIGHT JOIN retorna todas as linhas da tabela da direita com linhas correspondentes da tabela à esquerda. Se não houver linha correspondente, NULLs são retornados como valores da esquerda tabela.\n```sql\nSELECT TABELA_CIDADE.COLUNA_NOME, TABELA_PAIS.COLUNA_NOME\nFROM TABELA_CIDADE\nRIGHT JOIN tabela_pais\nON TABELA_CIDADE.COLUNA_PAIS_ID = tabela_pais.id;\n```\n### FULL JOIN\nFULL JOIN (ou explicitamente FULL OUTER JOIN) retorna todas as linhas de ambas as tabelas, incluindo registros que não têm correspondência na outra tabela. Quando um registro não possui correspondência na outra tabela, o valor para essa tabela é nulo. Em outras palavras, o resultado inclui todos os registros de ambas as tabelas, independentemente de haver correspondência ou não.\n```sql\nSELECT TABELA_CIDADE.COLUNA_NOME, TABELA_PAIS.COLUNA_NOME\nFROM TABELA_CIDADE\nFULL [OUTER] JOIN tabela_pais\nON TABELA_CIDADE.COLUNA_PAIS_ID = tabela_pais.id;\n```\n\n### CROSS JOIN\nCROSS JOIN retorna o produto cartesiano de duas tabelas. Em outras palavras, ele combina cada linha da primeira tabela com todas as linhas da segunda tabela, sem levar em consideração qualquer condição de junção. Existem duas sintaxes disponíveis.\n```sql\nSELECT TABELA_CIDADE.COLUNA_NOME, TABELA_PAIS.COLUNA_NOME\nFROM TABELA_CIDADE\nCROSS JOIN TABELA_PAIS;\n```\n\n```sql\nSELECT TABELA_CIDADE.COLUNA_NOME, TABELA_PAIS.COLUNA_NOME\nFROM TABELA_CIDADE, TABELA_PAIS;\n```\n### NATURAL JOIN\nNATURAL JOIN combina duas tabelas usando todas as colunas com o mesmo nome automaticamente, sem precisar especificar as condições de junção explicitamente. Em outras palavras, o NATURAL JOIN compara as colunas de ambas as tabelas com o mesmo nome e retorna as linhas que têm valores iguais nessas colunas.\n\n```sql\nSELECT TABELA_CIDADE.COLUNA_NOME, TABELA_PAIS.COLUNA_NOME\nFROM TABELA_CIDADE\nNATURAL JOIN TABELA_PAIS;\n```\n\n## FUNÇÕES AGREGADAS (AGGREGATE FUNCTIONS)\nFunções agregadas SQL são funções integradas usadas para realizar alguns cálculos nos dados e retornar um único valor. É por isso que eles formam a base para “consultas agregadas”. Essas funções operam em um conjunto de linhas e retornam um único resultado resumido.\n\n- count(COLUNA_NOME) − Conta o número de linhas de uma coluna.\n```sql\nSELECT COUNT(COLUNA_NOME) \nFROM TABELA_NOME \nWHERE CONDITION;\n```\n- sum(COLUNA_NOME) − Retorna a soma de uma coluna numérica.\n```sql\nSELECT SUM(COLUNA_NOME) \nFROM TABELA_NOME \nWHERE CONDITION;\n```\n- avg(COLUNA_NOME) − Retorna o valor médio de uma coluna numérica.\n```sql\nSELECT AVG(COLUNA_NOME) \nFROM TABELA_NOME \nWHERE CONDITION;\n```\n- min(COLUNA_NOME) − Retorna o menor valor da coluna selecionada.\n```sql\nSELECT MIN(COLUNA_NOME) \nFROM TABELA_NOME \nWHERE CONDITION;\n```\n- max(COLUNA_NOME) − Retorna o maior valor da coluna selecionada.\n```sql\nSELECT MAX(COLUNA_NOME) \nFROM TABELA_NOME \nWHERE CONDITION;\n```\n\nVeja alguns exemplo de uso:\n\nDescubra o número de cidades:\n```sql\nSELECT COUNT(rating)\nFROM TABELA_CIDADE;\n```\nDescubra o número de cidades com classificações não nulas:\n```sql\nSELECT COUNT(DISTINCT COLUNA_PAIS_ID)\nFROM TABELA_CIDADE;\n```\nDescubra o número de valores de país distintos:\n```sql\nSELECT MIN(population), MAX(population)\nFROM TABELA_PAIS;\n```\nDescubra as menores e as maiores populações do país:\n```sql\nSELECT COLUNA_PAIS_ID, SUM(population)\nFROM TABELA_CIDADE\nGROUP BY COLUNA_PAIS_ID;\n```\nDescubra a população total das cidades nos respectivos países:\n```sql\nSELECT COLUNA_PAIS_ID, AVG(rating)\nFROM TABELA_CIDADE\nGROUP BY COLUNA_PAIS_ID\nHAVING AVG(rating) \u003e 3.0;\n```\n## AGRUPAMENTO (GROUPING)\n\n### GROUP BY\nGROUP BY agrupa linhas que possuem os mesmos valores em colunas especificadas.\nEle calcula resumos (agregados) para cada combinação exclusiva de valores.\n\n#### CITY (Cidade)\n| id | name | COLUNA_PAIS_ID | \n| :---: | :---: | :---: | \n| 1 | Florença | 1 | \n| 2 | Fortaleza | 2 | \n| 3 | São Paulo | 2 | \n| 4 | Maranhão | 2 |\n| 5 | Lyon | 3 | \n| 6 | Berlin | 1 | \n| 7 | Warsaw | 3 | \n| ... | ... | ... |\n\nAgrupo todos os valores da coluna **`COLUNA_PAIS_ID`** agrupados em uma coluna chamada **`Contagem`**.\n```sql\nSELECT COLUNA_PAIS_ID, COUNT(*) AS Contagem \nFROM tabela_cidade \nGROUP BY COLUNA_PAIS_ID;\n```\nResultado:\n| COLUNA_PAIS_ID | count | \n| :---:      | :---: |\n| 1          | 2     | \n| 2          | 3     | \n| 3          | 2     | \n| ...        | ...   |\n\n## USANDO RESTRIÇÕES SQL (USING SQL CONSTRAINTS)\n\nDefinir C1 e CZ como chave-primária(primary-key)\n```sql\nCREATE TABLE t(\n\tcl INT, C2 INT, C3 VARCHAR,\n\tPRIMARY KEY (cl,c2)\n);\n```\nDefina a coluna c2 como uma chave-estrangeira(foreign-key)\n```sql\nCREATE TABLE TABELA_BAIRRO(\nCl INT PRIMARY KEY,\nC2 INT,\nFOREIGN KEY (c2) REFERENCES t2(c2)\n);\n```\nTorne os valores em cl e c2 exclusivos(UNIQUE)\n```sql\nCREATE TABLE t(\ncl INT, cl INT,\nUNIQUE(c2, c3)\n);\n```\nCertifique-se de que cl \u003e 0 e valores em cl\u003e=c2\n```sql\nCREATE TABLE t(\ncl INT, c2 INT,\nCHECK(c1\u003e 0 AND cl \u003e= c2)\n);\n```\nDefinir valores na coluna c2 não é nulo (NOT NULL)\n```sql\nCREATE TABLE t(\ncl INT PRIMARY KEY,\nc2 VARCHAR NOT NULL\n);\n```\n## USANDO OPERADORES SQL (USING SQL OPERATORS)\n\nCombine Rows FROM districtwo Queries\n```sql\nSELECT cl, C2 FROM districtl\nUNION ALL\nSELECT Cl, C2 FROM district2;\n```\nReturn The Intersection Of TWO Queries\n```sql\nSELECT cl, c2 FROM districTABELA_BAIRRO\nINTERSECT\nSELECT Cl, C2 FROM district2;\n```\nSubtract A Result Set From Another Result Set\n```sql\nSELECT cl, c2 FROM districtl\nMINUS\nSELECT cl, C2 FROM district2;\n```\nQuery Rows Using Pattern Matching _\n```sql\nSELECT cl, c2 FROM districtl\nWHERE Cl [NOT] LIKE pattern;\n```\nQuery Rows In A List\n```sql\nSELECT Cl, c2 FROM district\nWHERE cl [NOT] IN value_list;\n```\nQuery Rows Between Two Values\n```sql\nSELECT cl, c2 FROM district\nWHERE cl BETWEEN low AND high;\n```\nCheck If Values In A Table IS NULL Or Not\n```sql\nSELECT cl, C2 FROM district\nWHERE cl IS [NOT] NULL;\n```\n\n## Contribuição\n\nClone este repositório para o seu ambiente local:\n\n```bash\ngit clone https://github.com/seu-usuario/sql-cheat-sheet.git\n```\n## Referência\n\n - [W3Schools - SQL Tutorial](https://www.w3schools.com/sql)\n - [SQL Basics Cheat Sheet - LearnSQL.com](https://learnsql.com/blog/sql-basics-cheat-sheet/)\n - [SQL Basics Cheat Sheet - DataCamp](https://www.datacamp.com/cheat-sheet/sql-basics-cheat-sheet)\n - [Roadmap.sh](https://roadmap.sh/sql)\n - [Documentação Oficial do PostgreSQL](https://www.postgresql.org/docs/)\n - [Documentação Oficial do MySQL](https://dev.mysql.com/doc/)\n","funding_links":[],"categories":[],"sub_categories":[],"project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fmanuseiro%2Fsql-cheat-sheet","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fmanuseiro%2Fsql-cheat-sheet","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fmanuseiro%2Fsql-cheat-sheet/lists"}