6 |
7 | # Sobre o Repositório
8 |
9 | Guia para iniciantes na área de desenvolvimento entenderem SQL no nível de um juninho, linguagem padrão para trabalhar com bancos de dados relacionais.
10 |
11 | # Road Map
12 |
13 | 1. Introdução ao Repo
14 | * [Introdução](contents/Introducao/Introducao.md)
15 | * [Diferença entre BDs relacionais e não relacionais](contents/Introducao/Diferenca.md)
16 | * [Sintaxe](contents/Introducao/Sintaxe.md)
17 | * [Sub Conjuntos](contents/Introducao/Conjuntos.md)
18 | 2. Configurando Ambiente
19 | * [Instalando SQL (MYSQL)](contents/configuracao/Instalacao.md)
20 | * [Aplicativos](contents/configuracao/Aplicativos.md)
21 | 3. Comandos
22 | * [Iniciais](contents/comandos/Iniciais.md)
23 | * [Tipos de Dados](contents/comandos/Tipos.md)
24 | * [Básicos](contents/comandos/Basicos.md)
25 | * [Condicionais](contents/comandos/Condicionais.md)
26 | * [Primary Key e Foreign Key](contents/comandos/Keys.md)
27 | * [Joins](contents/comandos/Joins.md)
28 | * [Views](contents/comandos/Views.md)
29 | - Extras:
30 | * [MYSQL no terminal](contents/extra/comandos.md)
31 |
32 | # Como Contribuir
33 |
34 | Contribuições fazem com que a comunidade open source seja um lugar incrível para aprender, inspirar e criar. Todas
35 | contribuições são **extremamente apreciadas**!
36 |
37 | 1. Realize um Fork do projeto
38 | 2. Crie um branch com a nova feature (`git checkout -b feature/contribuicao`)
39 | 3. Realize o Commit (`git commit -m 'feature/contribuicao'`)
40 | 4. Realize o Push no Branch (`git push origin feature/contribuicao`)
41 | 5. Abra um Pull Request
42 |
43 | # Autor
44 |
45 | - **Luis Eduardo Teixeira (nadachi)** - _Back End Developer (php/laravel), He4rt's moderator and He4rt Live's moderator_
46 | - [Twitter](https://twitter.com/Luis_Nadachi) [LinkedIn](https://www.linkedin.com/in/luis-eduardo-ribeiro-teixeira-384b9819a/)
47 |
48 | # Colaboradores
--------------------------------------------------------------------------------
/assets/SubConjuntos.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Luisnadachi/SQL4Noobs/697c4892a2dec2a5c1585b5ff0218faf0df3f4fe/assets/SubConjuntos.png
--------------------------------------------------------------------------------
/assets/footer_4noobs.svg:
--------------------------------------------------------------------------------
1 |
2 |
265 |
--------------------------------------------------------------------------------
/assets/header_4noobs.svg:
--------------------------------------------------------------------------------
1 |
2 |
222 |
--------------------------------------------------------------------------------
/assets/id_4noobs_compact.svg:
--------------------------------------------------------------------------------
1 |
2 |
140 |
--------------------------------------------------------------------------------
/assets/id_4noobs_expanded.svg:
--------------------------------------------------------------------------------
1 |
2 |
142 |
--------------------------------------------------------------------------------
/assets/id_4noobs_line.svg:
--------------------------------------------------------------------------------
1 |
2 |
140 |
--------------------------------------------------------------------------------
/contents/Introducao/Conjuntos.md:
--------------------------------------------------------------------------------
1 | # **Sub Conjuntos**
2 |
3 | Dentro da linguagem de SQL os comandos eles podem ser dividos em sub conjuntos para categorizar os mesmos, cada um focando em um tipo de instrução.
4 |
5 | 
6 |
7 | > Imagem ilustrativa sobre os sub conjuntos.
8 |
9 | Esses grupos como na imagem acima são dividos em:
10 |
11 | - DQL
12 | - DML
13 | - DDL
14 | - DCL
15 | - DTL
16 |
17 | A seguir vamos explicar um pouco deles.
18 |
19 | ## **DDL**
20 |
21 | Pelo seu nome completo de **Data Definition Language**, são os comandos que utilizamos para interagir com o banco em si, desde criar até excluir uma tabela específica. Esses comandos são
22 |
23 | - CREATE
24 | - ALTER
25 | - DROP
26 | - TRUNCATE
27 | - COMMENT
28 | - RENAME
29 |
30 | ## **DQL**
31 |
32 | Pelo seu nome completo de **Data Query Language**, é o subconjunto responsável pelo comando de consulta nas tabelas do banco, que seria ele:
33 |
34 | - SELECT
35 |
36 | ## **DML**
37 |
38 | Pelo seu nome completo de **Data Manipulation Language**, é o subconjunto responsável pelos comandos que manipulam os dados nas tabelas, são eles:
39 |
40 | - INSERT
41 | - UPDATE
42 | - DELETE
43 |
44 | ## **DCL**
45 |
46 | Pelo seu nome completo de **Data Control Language**, é o subconjunto responsável pelos comandos que envolvem a segurança do banco de dados, são eles:
47 |
48 | - GRANT
49 | - REVOKE
50 |
51 | ## **DTL**
52 |
53 | Pelo seu nome completo de **Data Transaction Language**, é o subconjunto responsável pelos comandos que gerenciam e controlam transações de dados.
54 |
55 | - BEGIN/SET TRANSACTION
56 | - COMMIT
57 | - ROLLBACK
58 | - SAVEPOINT
59 |
60 | Por agora não expliquei sobre os comandos porque eles vão ser trazidos no Capitulo 3 onde irei falar expecificamente sobre eles.
61 |
62 | [Sintaxe](./Sintaxe.md) | [Inicio](../../README.md) | [Instalando SQL (MYSQL)](../configuracao/Instalacao.md)
--------------------------------------------------------------------------------
/contents/Introducao/Diferenca.md:
--------------------------------------------------------------------------------
1 | # **Banco de Dados Relacionais e Não Relacionais**
2 |
3 | ## **Relacionais**
4 |
5 | Um banco de dados relacional em resumo seria um tipo de banco que armazena dados que conseguem se ralacionar entre si com eles sendo organizados em conjuntos de tabelas e linhas. Lá na frente vamos ver mais sobre como funciona isso na prática, mas na teória: cada tabela contém uma coluna que armazena o valor de um atributo e as linhas que representam os valores com unico identificador chamada de chave principal ou conhecida por muitos como Primary Key. Já em linhas que se encontram em várias tabelas podemos fazer a associação com as chaves estrangeiras ou Foreign Key.
6 |
7 | Caso você queira ver mais sobre bancos relacionais tem esses dois artigos que podem ser úteis:
8 |
9 | - [Oracle](https://www.oracle.com/br/database/what-is-a-relational-database/)
10 | - [Amazon](https://aws.amazon.com/pt/relational-database/)
11 |
12 | ## **Não Relacionais**
13 |
14 | Um banco de dados não relacional em resumo é um tipo de banco de dados que não utiliza do esquema de tabela de linhas e colunas como utilizado nos bancos relacionais. Utilizam de modelos para requisitos específicos que podem ser como por exemplo pares chave/valor simples como existe em documentos JSON.
15 |
16 | ## **Considerações**
17 |
18 | Lendo cada um podemos ver a diferença entre os dois, mas o principal é, cada um tem sua vantagem principalmente para o seu objetivo, um exemplo que posso citar é para os **não relacionais** onde geralmente utilizamos em aplicativos da web em tempo real ou em big datas.
19 |
20 | [Introdução](./Introducao.md) | [Inicio](../../README.md) | [Sintaxe](./Sintaxe.md)
--------------------------------------------------------------------------------
/contents/Introducao/Introducao.md:
--------------------------------------------------------------------------------
1 | # **Introdução**
2 |
3 | ## **Banco de dados**
4 |
5 | Você vai num restaurante, o garçom anota seu pedido em um bloco de papel, você ja parou para pensar que algo na programação pode ter a mesma função?
6 | Qualquer que seja sua resposta, sim, existe, e conhecemos como Banco de Dados ou pela abreviação BD, que numa forma bem simplificada seria onde é armazenado um conjunto de dados, só que para criar um BD ou manipular dados dentro de um, utilizamos uma linguagem chamada SQL (Structured Query Language).
7 |
8 | ## **O que é SQL?**
9 |
10 | SQL abreviação para Structured Query Language foi uma linguagem criada pela IBM no inicio dos anos 70 com o objetivo demonstrar a viabilidade da implementação do modelo relacional, no qual vamos falar na próxima página sobre. No geral SQL não precisa de profundos conhecimetnos de programação para que alguém possa utilizar, tantos que até outros setores além de desenvolvimento utiliza a mesma. No mercado podemos utilizar os principais BDs relacionais utilizando SQL: Oracle, MySQL, Maria DB, Microsoft SQL Server e PostgreSQL.
11 |
12 | [Inicio](../../README.md) | [Diferença entre BDs relacionais e não relacionais](./Diferenca.md)
13 |
--------------------------------------------------------------------------------
/contents/Introducao/Sintaxe.md:
--------------------------------------------------------------------------------
1 | # **Sintaxe**
2 |
3 | A sintaxe de SQL é bem simples, por padrão colocamos os comandos em Caps Lock (letra maiuscula) e os dados em minusculo, geralmente seguindo assim:
4 |
5 | ```
6 | COMANDO dados COMANDO dados;
7 | ```
8 |
9 | Um exemplo na prática temos um comando que vamos aprender lá na frente que seria:
10 |
11 | ```
12 | SELECT * FROM Clientes;
13 | ```
14 |
15 | Aqui temos o comando SELECT utilizando todos os dados que é representado por *, em seguida o comando FROM para finalizar com a tabela chamada Clientes.
16 |
17 | Um detalhe para se atentar também na sintaxe do SQL, lembrando que próximos tópicos veremos diferentes comandos então não se importe se não entender isso agora mas lembre-se de voltar aqui no final para entender novamente, mas existe uma ordem para se escrever os comandos por conta da ordem de exececução do SQL:
18 |
19 | **Ordem de Escrita SQL**
20 |
21 | - SELECT
22 | - FROM
23 | - WHERE
24 | - GROUP BY
25 | - HAVING
26 | - ORDER BY
27 |
28 | **Ordem de Execução SQL**
29 |
30 | - FROM
31 | - WHERE
32 | - GROUP BY
33 | - HAVING
34 | - SELECT
35 | - ORDER BY
36 |
37 | [Diferença entre BDs relacionais e não relacionais](./Diferenca.md) | [Inicio](../../README.md) | [Sub Conjuntos](./Conjuntos.md)
--------------------------------------------------------------------------------
/contents/comandos/Basicos.md:
--------------------------------------------------------------------------------
1 | # **Comandos Básicos**
2 |
3 | Os comandos que irei explicar nesse tópico vão ser com mais foco em interagir com as tabelas e as colunas.
4 |
5 | ## **INSERT**
6 |
7 | Esse comando tem como objetivo inserir dados em uma tabela.
8 |
9 | ``` SQL
10 | INSERT INTO 4noobs (autor, lang)
11 | VALUES ('nadachi', 'html')
12 | ```
13 |
14 | ou
15 |
16 | ``` SQL
17 | INSERT INTO 4noobs
18 | VALUES ('nadachi', 'html')
19 | ```
20 |
21 | ## **SELECT**
22 |
23 | Com esse comando podemos trazer os dados de colunas especificas ou de todas colunas de uma tabela.
24 |
25 | ``` SQL
26 | SELECT lang, autor
27 | FROM 4noobs;
28 | ```
29 |
30 | ou
31 |
32 | ``` SQL
33 | SELECT * FROM 4noobs;
34 | ```
35 |
36 | **Obs:** o * signfica trazer tudo.
37 |
38 | ## **UPDATE**
39 |
40 | Utilizado para atualizar algum dado dentro da tabela.
41 |
42 | ``` SQL
43 | UPDATE 4noobs
44 | SET lang = 'php', autor = 'danielhe4rt'
45 | WHERE lang = 'html';
46 | ```
47 |
48 | **Obs:** Irei explicar melhor sobre o WHERE no tópico de **Condicionais** mas sempre que for rodar um UPDATE, lembre-se de utilizar ele por conta de não acabar causando o famoso erro de atualizar a tabela toda.
49 |
50 | ## **DELETE**
51 |
52 | Utilizado para deletar alguma linha na tabela.
53 |
54 | ``` SQL
55 | DELETE FROM 4noobs WHERE lang = 'PHP';
56 | ```
57 |
58 | **Obs:** O que falei no Obs do UPDATE vale para o DELETE principalmente.
59 |
60 | [Tipos de Dados](./Tipos.md) | [Inicio](../../README.md) | [Condicionais](./Condicionais.md)
--------------------------------------------------------------------------------
/contents/comandos/Condicionais.md:
--------------------------------------------------------------------------------
1 | # **Condicionais**
2 |
3 | Até mesmo em SQL podemos utilizar condições em determinados comandos, podemos ver isso no tópico anterior de comandos básicos quando utilizamos SELECT, UPDATE e o DELETE.
4 |
5 | ## **WHERE**
6 |
7 | O WHERE já conhecemos do capítulo anterior, traduzido significa "ONDE", com ele especicamos uma condição expecifica.
8 |
9 | ``` SQL
10 | SELECT * FROM 4noobs
11 | WHERE lang = 'PHP';
12 | ```
13 |
14 | Nesse exemplo selecionamos todas as linhas na tabela do 4noobs que contém a coluna lang igual a PHP.
15 |
16 | ## **IN**
17 |
18 | O operador IN serve para conseguimos especificar vários valores dentro da condição do WHERE.
19 |
20 | ``` SQL
21 | SELECT * FROM 4noobs
22 | WHERE lang IN ('PHP','JS');
23 | ```
24 |
25 | E temos também forma negativa.
26 |
27 | ``` SQL
28 | SELECT * FROM 4noobs
29 | WHERE lang NOT IN ('PHP','JS');
30 | ```
31 |
32 | ## **AND, OR e NOT**
33 |
34 | Para citar alguns exemplos e reforçar, podemos utilizar operadores como "E", "OU" e "NÃO", eles são usados para complementar condições como o WHERE, alguns exemplos.
35 |
36 | ``` SQL
37 | SELECT lang, autor
38 | FROM 4noobs
39 | WHERE lang = 'php' AND autor = 'danielhe4rt';
40 | ```
41 |
42 | ou
43 |
44 | ``` SQL
45 | SELECT lang
46 | FROM 4noobs
47 | WHERE lang = 'php' OR lang = 'html';
48 | ```
49 |
50 | ou
51 |
52 | ``` SQL
53 | SELECT lang
54 | FROM 4noobs
55 | WHERE NOT lang = 'php';
56 | ```
57 |
58 | ## **ORDER BY**
59 |
60 | O operador ORDER BY server para quando usarmos o SELECT trazer os dados tanto em ordem crescente ou descrecente, por padrão o ORDER BY tras em ordem crescente mas podemos especificar usando ASC (crescente) e DESC (descrescente).
61 |
62 | ``` SQL
63 | SELECT * FROM 4noobs
64 | ORDER BY lang;
65 | ```
66 |
67 | ou
68 |
69 | ``` SQL
70 | SELECT * FROM 4noobs
71 | ORDER BY lang ASC;
72 | ```
73 |
74 | ou
75 |
76 | ``` SQL
77 | SELECT * FROM 4noobs
78 | ORDER BY lang DESC
79 | ```
80 |
81 | **Obs:** Existem outros comandos para condições só que esses aqui citados são os mais utilizados principalmente para você que está começando ou juninho.
82 |
83 | [Básicos](./Basicos.md) | [Inicio](../../README.md) | [Primary Key e Foreign Key](./Keys.md)
--------------------------------------------------------------------------------
/contents/comandos/Iniciais.md:
--------------------------------------------------------------------------------
1 | # **Comandos Iniciais**
2 |
3 | Apartir desse capítulo irei explicar mais sobre os comandos que existem dentro do SQL que seja necessário para um junior saber ou pelo menos ser um grande passo para avançar nos estudos com SQL.
4 |
5 | ## **CREATE**
6 |
7 | O primeiro comando a se conhecer é o CREATE, ele é responsável por criar seu banco de dados ou uma tabela de banco com suas colunas.
8 |
9 | ``` SQL
10 | CREATE DATABASE he4rt;
11 | ```
12 |
13 | ou
14 |
15 | ``` SQL
16 | CREATE TABLE 4noobs(
17 | lang VARCHAR(255),
18 | autor VARCHAR(255),
19 | );
20 | ```
21 |
22 | ## **ALTER**
23 |
24 | O comando ALTER é utilizado quando precisamos fazer alguma modificação dentro do banco de dados que corresponda a adicionar uma tabela nova, modificar o datatype dela ou deletar uma coluna.
25 |
26 | ``` SQL
27 | ALTER TABLE 4noobs
28 | ADD data DATE;
29 | ```
30 |
31 | ou
32 |
33 | ``` SQL
34 | ALTER TABLE 4noobs
35 | ALTER COLUMN data DATETIME;
36 | ```
37 |
38 | ou
39 |
40 | ``` SQL
41 | ALTER TABLE 4noobs
42 | DROP COLUMN data;
43 | ```
44 |
45 | ## **DROP**
46 |
47 | O DROP é bom vocês conhecerem para nunca testar sem querer, ele é responsável por deletar o banco de dados ou uma tabela.
48 |
49 | ``` SQL
50 | DROP DATABASE he4rt;
51 | ```
52 |
53 | ou
54 |
55 | ``` SQL
56 | DROP TABLE 4noobs;
57 | ```
58 |
59 | [Aplicativos](./Aplicativos.md) | [Inicio](../../README.md) |[Tipos de Dados](./Tipos.md)
--------------------------------------------------------------------------------
/contents/comandos/Joins.md:
--------------------------------------------------------------------------------
1 | ## **Joins**
2 |
3 | Os "Joins" tem o intuito de combinarmos durante o SELECT duas ou mais tabelas para realizar uma exibição, e temos vários tipos de "Joins" só que dentro deles temos também outros tipos só que bem mais complexos, então irei explicar os iniciais e caso você deseje se aprofundar mais, saiba que para o que você deseja fazer possivelmente existe um "Join" para isso.
4 |
5 | - (INNER) Join
6 | - LEFT (OUTER) JOIN
7 | - RIGHT (OUTER) JOIN
8 | - FULL (OUTER) JOIN
9 |
10 | **Obs:** INNER são dados em comum entre a tabela e OUTER são os dados que não são em comum.
11 |
12 | **Obs2:** Caso você queira treinar na prática, rode esses comandos para ter duas tabelas para testar.
13 |
14 | ``` SQL
15 |
16 | CREATE TABLE 4noobs (
17 | id4noobs INT NOT NULL AUTO_INCREMENT,
18 | lang VARCHAR(255),
19 | alunos VARCHAR(255),
20 | PRIMARY KEY (id4noobs)
21 | );
22 |
23 | create table cursos (
24 | idcurso INT NOT NULL AUTO_INCREMENT,
25 | lang VARCHAR(255),
26 | alunos VARCHAR(255),
27 | PRIMARY KEY (idcurso)
28 | );
29 |
30 | INSERT INTO 4noobs (lang, alunos)
31 | VALUES ('php', 'daniel');
32 | INSERT INTO 4noobs (lang, alunos)
33 | VALUES ('sql', 'nadachi');
34 | INSERT INTO 4noobs (lang, alunos)
35 | VALUES ('UI', 'neex');
36 | INSERT INTO 4noobs (lang, alunos)
37 | VALUES ('UX', '7k');
38 | INSERT INTO cursos (lang, alunos)
39 | VALUES ('php', 'daniel');
40 | INSERT INTO cursos (lang, alunos)
41 | VALUES ('UI', 'neex');
42 | INSERT INTO cursos (lang, alunos)
43 | VALUES ('testes', 'joaozinho');
44 | INSERT INTO cursos (lang, alunos)
45 | VALUES ('java', 'joaozinho2');
46 |
47 | ```
48 |
49 | ## **INNER JOIN**
50 |
51 | Como explicado no obs acima, vai nos trazer os dados em comum entre as tabelas.
52 |
53 | ``` SQL
54 | SELECT *
55 | FROM 4noobs
56 | INNER JOIN cursos ON 4noobs.lang = cursos.lang;
57 | ```
58 |
59 | ## **LEFT JOIN**
60 |
61 | Vai retornar todos os dados da primeira tabela chamada junto com os dados que são em comum com a segunda tabela chamada.
62 |
63 | ``` SQL
64 | SELECT *
65 | FROM 4noobs
66 | LEFT JOIN cursos
67 | ON 4noobs.lang = cursos.lang;
68 | ```
69 |
70 | ## **RIGHT JOIN**
71 |
72 | Vai retornar todos os dados da segunda tabela chamada junto com os dados que são em comum com os dados da primeira tabela chamada.
73 |
74 | ``` SQL
75 | SELECT *
76 | FROM 4noobs
77 | RIGHT JOIN cursos
78 | ON 4noobs.lang = cursos.lang;
79 | ```
80 |
81 | ## **FULL OUTER JOIN**
82 |
83 | Retorna todos os dados que são iguais entre as duas tabelas.
84 |
85 | ``` SQL
86 | SELECT 4noobs.lang, cursos.idcurso
87 | FROM 4noobs
88 | FULL OUTER JOIN cursos
89 | ON 4noobs.id4noobs = cursos.idcurso
90 | ORDER BY 4noobs.id4noobs;
91 | ```
92 |
93 | Obs: Full outer join não funciona no MySQL.
94 |
95 | [Primary Key e Foreign Key](./Keys.md) | [Inicio](../../README.md) | [Views](./Views.md)
--------------------------------------------------------------------------------
/contents/comandos/Keys.md:
--------------------------------------------------------------------------------
1 | # **Primary Key e Foreign Key**
2 |
3 | Nesse tópico iremos apresentar sobre as chaves primárias e as chaves estrangeiras dentro do SQL, antes disso, aconselho a procurar um pouco sobre "relacionamentos em banco de dados" que pode ser um assunto que vai auxiliar a entender mais para o que server as Keys no SQL.
4 |
5 | ## **Primary Key**
6 |
7 | Só pode haver uma chave primária (Primary Key) em uma tabela, porque o intuito dela é nunca receber vazio (NULL) e ser auto incrementada (1,2,3,4,..) para ser utilizada como identificador de uma linha da tabela, como se fosse um código ou um ID, além de auxiliar na otimização da DB.
8 |
9 | Ex:
10 |
11 | ``` SQL
12 | CREATE TABLE 4noobs(
13 | ID int NOT NULL AUTO_INCREMENT,
14 | lang varchar (255),
15 | autor varchar (255),
16 | PRIMARY KEY (ID)
17 | );
18 | ```
19 |
20 | ## **Foreign Key**
21 |
22 | O intuito da chave estrangeira (Foreign Key) é servir de referencia para uma chave primária de outra tabela, se você entender um pouco sobre POO (programação orientada a objeto) pode ver isso como igual funciona relação de pai para filho.
23 |
24 | Ex:
25 |
26 | ``` SQL
27 | CREATE TABLE Languages (
28 | langID int NOT NULL AUTO_INCREMENT,
29 | name varchar(255) NOT NULL,
30 | PRIMARY KEY (langID)
31 | );
32 |
33 | CREATE TABLE 4noobs(
34 | conteudoID int NOT NULL AUTO_INCREMENT,
35 | autor varchar(255),
36 | PRIMARY KEY (conteudoID),
37 | FOREIGN KEY (langID) REFERENCES Languages(langID)
38 | );
39 | ```
40 |
41 | [Condicionais](./Condicionais.md) | [Inicio](../../README.md) | [Joins](./Joins.md)
42 |
--------------------------------------------------------------------------------
/contents/comandos/Tipos.md:
--------------------------------------------------------------------------------
1 | # **Tipos de Dados**
2 |
3 | Quando criamos as colunas das tabelas, precisamos dizer qual tipo de dados irá receber que nem acontece em algumas liguagens com as variáveis.
4 |
5 | **Obs:** Existem muitos tipos de tipos de dados, só colocarei aqui os principais, se quiser ver mais sobre tem o site do [w3schools](https://www.w3schools.com/sql/sql_datatypes.asp) que é da onde estou utilizando como base para as informações mais precisas.
6 |
7 | ## **Tipos de String**
8 |
9 | **Obs:** Size = quantidade/tamanho que a variável vai receber.
10 |
11 | - CHAR(size): tamanho fixado para uma string (pode ser letras, números ou caracteres especiais), pode ir de 0 a 255.
12 | - VARCHAR(size): tamanho de string variável (letras, números ou caracteres especiais), pode ser de 0 a 65535.
13 | - BINARY(size): funciona igual ao CHAR
14 | - BLOB(size): é o Binary Large Object que aguentam até 65,535 bytes, utilizado geralmente para armazenar imagens ou arquivos.
15 | - ENUM(valor1, valor2, valor3, ...): um objeto string que pode ter apensas um valor, escolhido em uma lista de valores possíveis, com tamanho máximo de até 65535 valores.
16 | - LONGTEXT: para string com o tamanho máximo de 4.294.967.295 bytes.
17 |
18 | ## **Tipos de Númerico**
19 |
20 | - BOOL: zero é considerado falso e valores não zero considerado verdadeiros.
21 | - BOOLEAN: igual ao BOOL.
22 | - INT(size): são para números tanto negativo e positivo, com tamanho de -2147483648 até 2147483647 ou 0 até 4294967295.
23 | - INTEGER(size): igual ao INT.
24 | - FLOAT: são os números de pontos fluantes.
25 | - DOUBLE(size, d): são os números de pontos fluantes normais, os números decimais depois da virgula são definidos pelo parâmetro d com o máximo de 30.
26 | - DECIMAL(size, d): são os números de pontos fluantes exatos, os números decimais depois da virgula são definidos pelo parâmetro d com o máximo de 30.
27 | ## **Tipos de Datas**
28 |
29 | - DATE: suporta datas com o formato 'YYYY-MM-DD'.
30 | - DATETIME(fsp): suporta datas com o formato de 'YYYY-MM-DD hh:mm:ss' e tem o tamanho de '1000-01-01 00:00:00' até '9999-12-31 23:59:59'.
31 | - TIMESTRAMP(fsp): são geralmente utilizados para registrar a data atual, tem o mesmo tamanho do DATETIME.
32 | - YEAR: suporta somente ano com 4 dígitos 1901 até 2155, e 0000.
33 |
34 | [Iniciais](./Iniciais.md) | [Inicio](../../README.md) | [Básicos](./Basicos.md)
--------------------------------------------------------------------------------
/contents/comandos/Views.md:
--------------------------------------------------------------------------------
1 | # **Views**
2 |
3 | Uma coisa que eu achei bem importante que aprendi no meu antigo trabalho foi sobre Views em SQL, funcionam como uma tabela virtual com dados vindo de uma ou mais tabelas definidas por uma query, com isso podemos trazer filtrado os dados, agrupados e protegidos.
4 | Um detalhe a se colocar, o diferencial principal da View é que diferente das chamadas em SELECT que fazemos, as Views continuam de pé e não ocupam espaço no banco. No geral, pontos da View:
5 |
6 | - **Reuso**: As views são permanentes, então não precisamos chamar toda hora ela e vários usuários podem ler ao mesmo tempo.
7 | - **Segurança**: Podemos ocultar algumas determinadas coluna se quisermos.
8 | - **Simplificação**: Código limpo mas ao mesmo tempo com um SELECT complexo.
9 |
10 | Agora vamos ver na prática como montar uma View.
11 |
12 | Ex:
13 |
14 | ``` SQL
15 | CREATE VIEW vw4noobs AS
16 | SELECT lang, alunos
17 | FROM 4noobs
18 | ORDER BY lang;
19 |
20 | SELECT * FROM vw4noobs;
21 | ```
22 |
23 | Explicando um pouco a estrutura, primeiramente usamos o **CREATE VIEW** acompanhado do nome da view, geralmente colocamos um "vw" para indentificar, em seguida um **AS** acompanhado do nosso select com as nossas condicionais. A outra linha de **SELECT** que utilizei em seguida é so para vocês visualizarem os resultados da View.
24 |
25 | [Joins](./Joins.md) | [Inicio](../../README.md)
--------------------------------------------------------------------------------
/contents/configuracao/Aplicativos.md:
--------------------------------------------------------------------------------
1 | # **Aplicativos**
2 |
3 | Nesse tópico irie apresentar alguns aplicativos que podem auxiliar seu desenvolvimento e trabalho com o SQL, eles não são necessários mas em vários casos vão ser muito úteis.
4 |
5 | ## **DBeaver**
6 |
7 | O [DBeaver](https://dbeaver.io/download/) é uma ferramenta gratuita e open source para gestão de banco de dados que o objetivo dele é deixar mais simples desde a criação até a gestao de banco de dados. Ele suporta um grande número de banco de dados como:
8 |
9 | - MySQL
10 | - PostgreSQL
11 | - SQLite
12 | - Oracle
13 | - Entre vários outros
14 |
15 | Pessoalmente falando eu aconselho muito a usar ele porque deixa muito mais fácil a visualização do banco de dados no geral e você pode optar criar tudo usando código SQL ou utilizando as opções do próprio DBeaver que foram feitas para facilitar isso.
16 |
17 | [Instalando SQL (MYSQL)](./Instalacao.md) | [Inicio](../../README.md) | [Iniciais](../comandos/Iniciais.md)
--------------------------------------------------------------------------------
/contents/configuracao/Instalacao.md:
--------------------------------------------------------------------------------
1 | # **Instalando SQL (MySQL)**
2 |
3 | ## **Observações**
4 | Nesse repositório para explicar sobre SQL vamos está instalando o MySQL com o intuito de com ele mostrar o SQL, caso você queira se aprofundar mais em MySQL temos no 4noobs um [repositório](https://github.com/paulorievrs/mysql4noobs) feito pelo [Paulo Rivers](https://github.com/paulorievrs) falando sobre. Com a permissão dele algumas partes aqui da instalação eu tirei do repositório dele por conta de eu já ter instalado em meu windows o MySQL.
5 |
6 | ## **Windows**
7 |
8 | Caso você esteja utilizando o windows, só seguir os seguintes passos:
9 |
10 | 1. Acesse o site oficial do [MySQL](https://www.mysql.com)
11 | 2. Vá em Downloads
12 | 3. Procure o link para baixar MySQL Community
13 | 4. Clique em "MySQL Installer for Windows"
14 | 5. Escolha a opção "Windows (x86, 32-bit), MSI Installer"
15 | 6. Continue o Download sem criar conta
16 | 7. Execute o instalador, aceite os termos e avançe
17 | 8. Escolha o padrão desenvolvedor
18 | 9. Vai ocorrer uma verificação para baixar as dependências, clique em executar para instalar os pacotes necessários
19 | 10. Em seguida execute a instalação dos pacotes
20 | 11. Na próxima tela deixe em "Standalone MySQL Server / Classic MySQL Replication"
21 | 12. Próxima tela vai ser as configurações padrões, pode avançar
22 | 13. Tela seguinte vai ser de autenticação, só seguir
23 | 14. Nessa tela, escolhe uma senha para o seu MySQL e guarde ela, avançe
24 | 15. Nessa tela mostra como ira ocorrer o gerenciamento, pode avançar
25 | 16. Execute o que foi definido e após isso em finish
26 | 17. Avance para outra tela
27 | 18. Deixe tudo padrão e finalize
28 | 19. Avance para outra tela
29 | 20. Essa tela será para testar a configuração, onde o usuário vai ser o root e a senha a que você escolheu, se funcionou, avance para outra tela
30 | 21. Execute e avançe
31 | 22. Desmarque a opção de executar shell e MySQL Workbench.
32 |
33 | Obs: Não iremos executar o Workbench porque usaremos outro aplicativo para demonstrar sobre o SQL.
34 |
35 | ## **Linux**
36 |
37 | No Linux, vamos instalar via terminal, seguindo pelos comando
38 |
39 | ```
40 | $ sudo apt update
41 | ```
42 | ```
43 | $ sudo apt install mysql-server
44 | ```
45 | ```
46 | $sudo mysql_secure_installantion
47 |
48 | Aqui pode dar 'N' para tudo por conta que vai ser somente um ambiente de desenvolvimento e onde você colocara sua senha.
49 | ```
50 | ```
51 | $ mysql -u root -p
52 | ```
53 | [Sub Conjuntos](../Introducao/Conjuntos.md) | [Inicio](../../README.md) | [Aplicativos](./Aplicativos.md)
--------------------------------------------------------------------------------
/contents/extra/comandos.md:
--------------------------------------------------------------------------------
1 | # Comandos básicos do MYSQL no terminal
2 |
3 | Além do MYSQL poder ser acessado por programas como o Workbench, Datagrip, DBeaver e outros ele também pode ser acessado e manipulado pelo terminal o que é útil para trabalhar quando é necessário acessar o Banco por SSH em algum servidor ou até mesmo para manipulação por esse meio quando necessário que isso seja feito de forma simples e rápido.
4 |
5 | > Caso esteja usando Windows é recomendável usar o **cmder** que emula um ambiente UNIX, caso esteja usando MAC ou Linux basta usar o terminal padrão de seu Sistema Operacional / Distribuição.
6 |
7 | ## Conectar ao MYSQL
8 |
9 | O primeiro passo é conectar ao MYSQL que está rodando em sua máquina, isso é bastante simples e pode ser feito com o comando:
10 | ```
11 | $ mysql -u -p
12 | ```
13 | Exemplo: Caso queira acessar com o usuário ROOT basta:
14 | ```
15 | $ mysql -u root -p
16 | ```
17 | E então entrar com a senha do usuário.
18 |
19 | O comando tem os seguintes parâmetros:
20 | - **-u** (que também pode ser usado como **--user**): Serve para indicar o nome do usuário que será usado para se conectar.
21 | - **-p** (que também pode ser usado como **--password**): É a senha usada para se conectar ao servidor. Se usado na forma reduzida **-p** o MySQL vai mostrar um prompt perguntando qual a senha do usuário.
22 |
23 | > Caso o usuário que você configurou na instalação não possua senha, você pode omitir o parâmetro **-p**, porém não é recomendado que você tenha usuários sem senha por motivos de segurança do seu banco.
24 |
25 | ## Listar os Banco de Dados
26 |
27 | Com o prompt ativo, agora podemos listar as databases que temos em nossa instância do MySQL, para isso use o comando:
28 | ```
29 | mysql> show databases;
30 | ```
31 |
32 | E você vai receber uma resposta formatada que se parece com essa:
33 | ```
34 | +--------------------+
35 | | Database |
36 | +--------------------+
37 | | classicmodels |
38 | | information_schema |
39 | | mysql |
40 | | performance_schema |
41 | | sys |
42 | | test |
43 | +--------------------+
44 | ```
45 | Onde temos uma tabela em cada linha é uma das databases que temos em nossa instância.
46 |
47 | ## Listar as Tabelas
48 |
49 | Com o prompt ativo, use o comando SQL que já aprendemos `use` para acessar o Banco de Dados que você deseja usar e então use o comando a seguir para listar as tabelas presentes nele:
50 | ```
51 | mysql> show tables;
52 | ```
53 | E vamos ter um resultado formatado parecido com:
54 | ```
55 | +-------------------------+
56 | | Tables_in_classicmodels |
57 | +-------------------------+
58 | | customers |
59 | | employees |
60 | | offices |
61 | | orderdetails |
62 | | orders |
63 | | payments |
64 | | productlines |
65 | | products |
66 | +-------------------------+
67 | ```
68 | Onde temos uma tabela em que cada linha é uma tabela em nosso Banco de Dados **classicmodels**.
69 |
70 | ## Ver a estrutura de uma tabela
71 |
72 | Caso queira ver a estrutura de uma tabela pode usar o comando a seguir:
73 | ```
74 | mysql> describe customers;
75 | ```
76 | E vamos ter um retorno formatado como:
77 | ```
78 | +--------------------+---------------+------+-----+---------+----------------+
79 | | Field | Type | Null | Key | Default | Extra |
80 | +--------------------+---------------+------+-----+---------+----------------+
81 | | id | int(11) | NO | PRI | NULL | auto_increment |
82 | | name | varchar(100) | NO | | NULL | |
83 | | date_of_birth | date | NO | | NULL | |
84 | +--------------------+---------------+------+-----+---------+----------------+
85 | ```
86 | Em que vamos ter uma tabela com linhas e colunas nos indicando o nome do campo, o tipo, se ele aceita valores nulos, se ele é uma chave, qual o valor default e outras propriedades que ele possa ter como `auto_increment`.
87 |
88 | ## Dump do Banco de Dados
89 |
90 | Para fazer uma cópia de uma base de dados que você tenha você pode usar o comando a seguir:
91 | ```
92 | $ mysqldump -u root -p > .sql;
93 | ```
94 | Por exemplo, para exportar o banco **classicmodels** usamos:
95 | ```
96 | $ mysqldump -u root -p classicmodels > classicmodels.sql;
97 | ```
98 |
99 | Isso vai nos gerar um arquivo **classicmodels.sql** na pasta em que nosso terminal está e que poderá ser usado para importar nosso banco com todas as tabelas e informações em qualquer outro computador que tenha o MySQL instalado pelo terminal ou por qualquer programa que importe arquivos .sql
100 |
101 | ## Importar o Banco de Dados
102 |
103 | Para importar o arquivo .sql que foi exportado por você ou algum outro usuário você pode usar o comando a sequir, na pasta do terminal em que o arquivo .sql está:
104 | ```
105 | mysql -u root -p < .sql;
106 | ```
107 | Por exemplo, para importar o arquivo classicmodels.sql que exportamos o comando seria:
108 | ```
109 | mysql -u root -p classicmodels < classicmodels.sql;
110 | ```
111 |
112 | > O processo de importação pode demorar dependendo do tamanho de seu Banco de Dados. Quanto maior for, mais demorará. Por exemplo, um banco que tem 300.000 registro pode levar dezenas de minutos até concluir e liberar o terminal.
113 |
114 | ## Comandos SQL no terminal
115 |
116 | Qualquer comando SQL que aprendemos no tutorial SQL4Noobs pode ser usada no terminal, seja `DROP`, `SELECT` ou qualquer outro. Após logar no terminal, entrar em Banco de Dados você pode executar por exemplo o comando `DROP` para apagar um Banco de Dados:
117 | ```
118 | mysql> drop database products;
119 | ```
120 | E pronto.
121 |
122 | Caso queira usar um comando para manipular alguma tabela ou similar em um banco de dados primeiro você precisa primeiro usar o comando `use` para acessá-la e então executar qualquer comando por exemplo `SELECT`:
123 | ```
124 | mysql> SELECT * FROM customers;
125 | ```
126 | E isso vai nos dar um retorno formatado com o resultado dessa Query.
127 |
128 | ## Dicas
129 | - Você pode usar o comando `CTRL+L` para limpar o terminal caso necessário.
130 | - É necessário ter o mesmo cuidado ao usar comandos no Terminal quanto quando está os executando por interface gráfica, caso rode um comando que cause perda de dados isso vai ser um problema tão grave quanto seria por qualquer outro programa, mas o terminal não vai tentar te alertar sobre isso. Tenha cuidado.
131 |
132 | [Inicio](../../README.md)
--------------------------------------------------------------------------------
4 |
5 |