#SQL na unha: banco de dados e primeiros comandos
Tags: database, sql, mysql, postgres
Published: 2022-01-25 13:07:54

Atualmente, para quem é desenvolvedor, há inúmeras bibliotecas, sejam elas *QueryBuilders* ou *ORMs* que nos auxiliam na manipulação de um banco de dados, livrando-nos de criar consultas na "mão".

E se por um lado ganhamos com a facilidade em manipular os dados, por outro perdemos por não saber como algumas coisas funcionam. Sendo assim, este artigo servirá para que possamos aprender a manipular um banco, e de certa forma, entender o funcionamento por trás das ferramentas ditas anteriormente.

## Resumão sobre banco de dados
Acho que definir o que é e para que serve um banco de dados é subestimar o conhecimento de vocês, mas alguns detalhes que acho importante, precisam ser explicados.

É importante saber que existem diferentes bancos, diferentes formas de manuseio, de como os dados são salvos, etc. Para fins de estudo, e por questão de aprendizado, utilizaremos um banco relacional.

Um banco relacional se caracteriza por seus dados estarem armazenados em tabelas, nas quais essas tabelas podem se relacionar entre si.

Além disso, precisamos de alguma ferramenta para gerenciar um banco, desde controlar o acesso até propriamente manipular os dados. E é aí que entra um ***SBGD***, ou ***Sistema de Gerenciamento de Banco de Dados***, na qual como o próprio informa: gerencia um ou mais bancos de dados.

Tendo um SGBD, precisamos informar que queremos executar determinados comandos, e esses comandos são escritos por meio da ***Structured Query Language ou Linguagem de Consulta Estruturada***.

Com o rápido conhecimento informado acima, e com base nas minhas experiências, o SGBD escolhido foi o **MySQL**. Ele é bem fácil de ser manuseado, poderoso, além de ser muito utilizado no mercado.

## Docker e o MySQL
Existem muitas formas de instalar o *MySQL* em nossa máquina, escolhi via **Docker** por ser bem prático e para termos uma padronização, caso não tenha o **Docker** em sua máquina, [siga esses passos](https://docs.docker.com/engine/install/).

Após realizar a instalação, iremos **baixar uma imagem que contenha o _MySQL_**, neste caso baixaremos a última versão do SGBD, e **subiremos um _container_** baseado nessa imagem:
```bash
docker run --name mysql-dev -e MYSQL_ROOT_PASSWORD=suasenha mysql
```
*Onde "mysql-dev" é o nome do container*.
*Onde "suasenha" é a senha de acesso ao banco*.

Agora precisamos **acessar o _container_**, execute o comando abaixo:
```bash
docker exec -it mysql-dev bash
```

Para **sair do _container_**, basta executar o seguinte comando:
```bash
exit
```

Para **parar ou iniciar determinado _container_** posteriormente, utilize os comandos abaixo:
```bash
docker stop mysql-dev # para um container específico

docker start mysql-dev # inicia um container específico
```

## Acessando o MySQL
Cada SGBD disponibiliza seu próprio comando de acesso. O do *MySQL* é bem simples, digite o seguinte comando:
```bash
mysql -u root -p
```
*Será necessário informar a senha que definimos no primeiro comando docker, e pronto, estamos dentro do nosso SGBD*.

***Importante informar que o "root" do comando acima, é o usuário padrão do MySQL, é possível manipular os usuários e as permissões desses usuários, mas eu não abordarei esse assunto***.

Podemos economizar comandos para chegar ao SGBD, ao invés de acessar o *container* e depois fazer a chamada de acesso, faremos com que a chamada ao *container* já execute o comando de acesso ao SGBD:
```bash
docker exec -it mysql-dev mysql -u root -p
```
*Basta inserir a senha*.

## Detalhes
Antes de começarmos a executar alguns comandos, é necessário passar algumas informações muito importantes:
* Um *database* (banco) é o nosso local de trabalho;
* O ; é obrigatório ao final de cada instrução;
* As palavras dos comandos que faremos, podem ser utilizadas tanto em minúsculo como em maiúsculo, fica a seu critério;
* Cada SGBD contém uma série de [palavras reservadas](https://dev.mysql.com/doc/refman/8.0/en/keywords.html), que não devemos utilizar para identificar algo.

## Realizando primeiros comandos
Primeiro vamos saber com qual **versão do SGBD estamos lidando**:
```sql
select version(); -- a versão exibida no momento em que faço este artigo é a 8.0.27
```
*Comentários são feitos por meio do --*.

Agora **veremos os _databases_ criados** e que o nosso usuário tem acesso:
```sql
show databases; -- será exibido todos os bancos que o nosso usuário tem acesso, nesse caso alguns são criados pelo próprio SGBD
```

Para **criarmos um banco**, basta executar o comando abaixo informando o nome do banco:
```sql
create database dev_article;
```
*Se nós executarmos o comando de listagem novamente, o banco que criamos será exibido também*.

Para **excluir esse _database_** basta executar o comando abaixo informando o nome do banco:
```sql
drop database dev_article;
```

Para evitar colisão entre nomes de tabelas, podemos adicionar uma **verificação antes de criar uma tabela**:
```sql
create database if not exists dev_article; -- um banco só será criado se não existir um banco com o mesmo nome
```

Para **selecionar um banco para manipularmos**, rode o seguinte:
```sql
use dev_article;
```

Para **sair do _MySQL_**, rode o comando abaixo:
```sql
exit;
```

## Importante
Existem diferentes comportamentos e implementações que diferem um SGBD do outro. Por exemplo, se pegarmos o **MySQL** e compararmos com o **PostgreSQL**, podemos verificar inúmeras diferenças, nesse caso a primeira que podemos notar é organização do banco.

A imagem abaixo mostra claramente a organização desses bancos. Enquanto no *MySQL* criamos um ou mais bancos, e dentro definimos nossas tabelas, no *PostgreSQL*, criamos um ou mais bancos, porém organizamos nossas tabelas em *schemes*, a grosso modo, é como se dentro do banco tivessem várias pastas, e dentro delas nossas tabelas.

![Comparação de organização entre MySQL e PostgreSQL](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/dbdpms1jnxiow80n381x.png)

## Encerramento
Existem muitos outros comandos que iremos executar, porém isso fica para a próxima parte, te vejo por lá.