Visualização automática de esquemas de databases do Sqlite
Tags: sql, tutorial, beginners, braziliandevs
Published: 2024-04-21 15:54:41

Neste post usamos ferramentas open source para visualização de esquemas de base de dados (databases). Mostramos um passo a passo para criação de bases com SQL. Em seguida, construímos um esquema para uma base simplificada de um campeonato de futebol e geramos seu diagrama. Diferentemente de ferramentas como o [draw.io](https://app.diagrams.net), em que precisamos preencher e configurar cada bloco, veremos como gerar o diagrama do esquema completo de forma automática.

<small>_"Um banco de dados devidamente normalizado pode acabar em muitas pequenas tabelas conectadas por uma rede complexa de referências de chave estrangeira. Como uma cidade do mundo real, é muito fácil se orientar quando você estiver familiarizado, mas quando você chega, realmente ajuda ter um mapa."_ (tradução de https://github.com/ncruces/sqlite-schema-diagram) 🗃️ 🗺️ </small>

![Etapas do tutorial](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/9m8o27z2nylzzrp5gqeo.gif "Rodando todas etapas")

---

## Instalação dos pré-requisitos

Para gerar o [diagrama relacional](https://dev.to/documatic/diagramming-and-database-design-42ff), de forma automática, usamos o [`sqlite-schema-diagram`](https://github.com/ncruces/sqlite-schema-diagram). Seus pré-requisitos são o [Graphviz](https://www.graphviz.org/) e o [Sqlite (v.3)](https://sqlite.org).

### 1. Graphviz

O Graphviz é um programa muito utilizado para visualização de diferentes tipos de grafos, redes, diagramas, etc.

![graphviz-gallery](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/82wrm6mneynjevqe4xaw.png "Algumas opções de visualização com o Graphviz. Fonte: <a href="https://www.graphviz.org/gallery")

Para instalar o Graphviz acessamos a [seção de download](https://www.graphviz.org/download/) do seu site. Após baixá-lo, realizamos a instalação através do passo a passo que eles indicam.

**Sobre as instalações:** Para quem estiver num computador com Linux, bastará rodar pelo terminal os códigos de instalação que serão mostrados. Já para outros sistemas operacionais, não entraremos nos detalhes da instalação, mas deixamos as linhas gerais para que isso seja feito. Os programas aqui usados possuem instalações usuais como de a de qualquer outro programa.

Para quem utiliza Linux, é possível instalar o Graphviz pelo terminal com:

```shell
sudo apt install graphviz
```

Para testar se o Graphviz foi instalado corretamente, podemos tentar checar sua versão (`-V`):

```shell
dot -V
```
Se der erro quando rodarmos o comando acima, precisamos rever a instalação do Graphviz.

### 2. SQLite

O banco de dados usado neste post é o Sqlite. Assim como alguns outros databases, o Sqlite não necessita de um servidor a parte para funcionar. Outra característica interessante é sua capacidade de manipular e armazenar <a href="https://sqlite.org/datatype3.html">vários tipos de arquivo</a>: `NULL` (nulo), `INTEGER` (0, 1, 2, ...), `REAL` (floats como 3.14159 ou 2.718281), `TEXT` (strings) e `BLOB` (armazenado exatamente como o valor do input).

Ele é bastante versátil, pois pode ser guardado em disco como um arquivo (por ex., com extensão `.db`) que roda em diferentes plataformas (Linux, Android, etc). É possível enviarmos e compartilharmos seus databases assim como, usualmente, se faz com qualquer outro arquivo. Seus databases `.db` podem ir até 281 terabytes (TB). Detalhes dessas e outras informações sobre suas capacidades podem ser encontradas em sua <a href="https://www.sqlite.org/whentouse.html">página oficial</a>.

**Nota:** Na [documentação do Sqlite](https://sqlite.org/datatype3.html#date_and_time_datatype), explicam que tipos como datas (`datetime`) podem ser armazenados como um desses dos tipos de dados padrão do Sqlite. Por ex., podem ser armazenadas como `TEXT` se o valor estiver na forma `YYYY-MM-DD HH:MM:SS.SSS`, sendo `Y` = _year_ (ano), `M` = _month_ (mês), `D` = _day_ (dia), `H` = _hour_ (hora), `M` = _minute_ (minuto) e `S` = _seconds_ (segundos).

Para instalar o Sqlite, seguimos os passos de instalação de sua página oficial. Clique [aqui](https://sqlite.org/download.html) para acessá-la.

Para quem usar Linux, basta digitar:

```shell
sudo apt install sqlite3
```

Após a instalação do Sqlite, verifique se tudo ocorreu ok, digitando o seguinte comando:

```shell
sqlite3
```
A saída esperada é exibida na imagem abaixo:

![sqlite3-terminal](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/6awx2ehatcjt93wkg4cw.png "Imagem da execução do Sqlite no terminal")

### 3.`sqlite-schema-diagram`

Por fim, devemos baixar o arquivo `sqlite-schema-diagram.sql` e a licença `COPYING` do seguinte repositório no Github: [https://github.com/ncruces/sqlite-schema-diagram](https://github.com/ncruces/sqlite-schema-diagram).

Com isso finalizamos a configuração dos pré-requisitos necessários. 🎬

Estrutura dos arquivos num diretório local (`pasta-local`) após as etapas acima:

```shell
pasta-local/
│
├── COPYING
│
└── sqlite-schema-diagram.sql
```

---

## Breve introdução ao SQLite CLI

Para iniciar a CLI (_command line interface_) do Sqlite digitamos `sqlite3` num terminal. Após isso, é esperado que apareça um `sqlite>` no terminal. Caso utilize o `Crtl+C` e `Crtl+V`, facilita se copiar apenas os comando que vierem após o `sqlite>`.

Para rodar um comando no Sqlite basta entrar no Sqlite e digitá-lo. Por ex., o `.help` é executado com:

```sql
sqlite> .help
```

**Atenção:** O `sqlite>` exibido nos códigos indicam que estamos com o Sqlite em execução. Se rodarmos o `.help` diretamente num terminal, é esperado que ocorra um erro.

Uma lista dos comandos do Sqlite (os _dot commands_, comandos com pontos `.`) está disponível neste <a href="https://www.sqlite.org/cli.html#special_commands_to_sqlite3_dot_commands_">link</a>.

**Criação de tabelas no database:** Para criar uma tabela com a CLI do Sqlite, usamos os [comandos usuais do SQL](https://www.w3schools.com/sql/default.asp), por exemplo:

```sql
sqlite>
  CREATE TABLE pessoas (    
    nome TEXT,
    ano_nascimento INT,
    email TEXT
  );
```

Esse comando cria uma tabela chamada `pessoas` com colunas `nome`, `data_nascimento` e `email`.

Após rodar o comando acima no Sqlite, podemos checar, com o comando `.tables`, se a tabela `pessoas` foi criada:

```sql
sqlite> .tables
```
Essa checagem é exibida a seguir:

![sqlite3-table](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/bcxcsfzfshb1f2emusgs.png "Imagem do resultado do comando .tables")

**Inserção de uma linha na tabela `pessoas`**: Inserimos uma linha, correspondente a um novo registro, na tabela `pessoas` com o comando SQL <a href="https://www.w3schools.com/sql/sql_insert.asp">`INSERT INTO`</a>. Por exemplo:

```sql
sqlite>
  INSERT INTO pessoas VALUES(
    'Chico Bento', 1963, 'email_chico_bento@turmadamonica.com.br'
  );
```

É possível checar se o registro de exemplo foi inserido corretamente com o comando <a href="https://www.w3schools.com/sql/sql_select.asp">`SELECT`</a>:

```sql
sqlite>
  SELECT * FROM pessoas;
```

**Nota:** Não estaremos populando a base de dados que criaremos, pois o foco deste post é exibir de forma automática um diagrama que permita facilitar no entendimento de como as tabelas do database se relacionam.

**Salvando o database como um arquivo:** Para salvar o database usamos o `.save`:

```sql
sqlite> .save database_teste.db
```

Após salvar a base de dados, podemos sair do Sqlite:

```sql
sqlite> .quit
```

Versão atualizada dos arquivos locais até o momento:
```shell
pasta-local/
│
├── COPYING
│
├── database_teste.db
│
└── sqlite-schema-diagram.sql
```

**Documentação da CLI:**  Uma lista completa com exemplos de uso dos comandos da CLI do Sqlite está disponível em: [https://www.sqlite.org/cli.html](https://www.sqlite.org/cli.html).

---

## Visualizando um database de futebol

Agora iremos criar um database que tenha relação com um [campeonato de futebol de salão (futsal)](https://www.cnfsfutsal.com.br/regraseregimentos.php) amador. Nessa modalidade, o time é formado por 5 jogadores, um goleiro e mais quatro na linha.

Primeiramente, iniciamos o Sqlite com o comando `sqlite3`. Após isso, usamos os seguintes <a href="https://www.w3schools.com/sql/">comandos SQL</a> para criar o database, que chamaremos de `database_fut.db`:

```sql
-- schema_fut.sql
CREATE TABLE times (
  time_id INTEGER NOT NULL AUTO_INCREMENT,
  nome_time TEXT NOT NULL,
  pais TEXT,
  jogador_0_id NOT NULL REFERENCES jogadores(jogador_id),
  jogador_1_id NOT NULL REFERENCES jogadores(jogador_id),
  jogador_2_id NOT NULL REFERENCES jogadores(jogador_id),
  jogador_3_id NOT NULL REFERENCES jogadores(jogador_id),
  jogador_4_id NOT NULL REFERENCES jogadores(jogador_id),
  jogador_5_id NOT NULL REFERENCES jogadores(jogador_id),
  jogador_6_id NOT NULL REFERENCES jogadores(jogador_id),
  jogador_7_id NOT NULL REFERENCES jogadores(jogador_id),
  site TEXT,
  data DATETIME NOT NULL,
  PRIMARY KEY (time_id)
);

CREATE TABLE jogadores (
    jogador_id INTEGER NOT NULL,
    time_atual_id INTEGER,
    nome_jogador TEXT NOT NULL,
    posicao_campo TEXT,
    PRIMARY KEY (jogador_id)
);

CREATE TABLE jogos (
    jogo_id INTEGER NOT NULL,
    time_casa_id TEXT NOT NULL REFERENCES times(time_id),    
    time_visitante_id TEXT NOT NULL REFERENCES times(time_id),
    rodada_id INTEGER NOT NULL REFERENCES rodadas(rodada_id),
    placar TEXT NOT NULL,
    nome_campeonato TEXT,
    data DATETIME NOT NULL,
    PRIMARY KEY (jogo_id)
);

CREATE TABLE rodadas (
    rodada_id INTEGER NOT NULL,
    classificacao_id TEXT NOT NULL REFERENCES classificacoes,
    nome_campeonato TEXT NOT NULL,
    data DATETIME NOT NULL,
    PRIMARY KEY (rodada_id)
);

CREATE TABLE classificacoes (    
    classificacao_id TEXT NOT NULL,
    rodada_id INTEGER NOT NULL,
    classificacao_atual TEXT NOT NULL,
    data DATETIME NOT NULL,
    PRIMARY KEY (classificacao_id)
);
```
**Lembrando:** Após rodar os comandos que criam a tabela devemos salvar a tabela com `.save <nome-do-database.db> e sair do Sqlite com o <.quit>`:
```shell
sqlite3> 
  .save database_fut.db
  .quit
```

**Gerando o diagrama automaticamente:** Agora vamos gerar a visualização do esquema do `database_fut.db` criado. Para isso, primeiramente criamos um `.DOT` do Graphviz com o seguinte comando:

```shell
sqlite3 database_fut.db -init sqlite-schema-diagram.sql "" > schema_fut.dot
```

Em seguida, exportamos o `schema_fut.dot` para o formato `.PNG` com:

```shell
dot -Tpng schema_fut.dot > schema_fut.png
```

![schema-fut](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/k6ks6tsm3xhqwhqtlksq.png "Imagem de schema_fut.png")

Após o último passo mencionado os arquivos locais ficam da seguinte forma:

```shell
pasta-local/
│
├── COPYING
│
├── database_fut.db
│
├── database_teste.db
│
├── schema_fut.dot
│
├── schema_fut.png
│
└── sqlite-schema-diagram.sql
```

---

## Próximos passos

Com isso finalizamos nosso post. Para incrementar o que vimos neste post, poderíamos pegar um esquema de database mais complexo ou reformular nosso exemplo do campeonato de futebol para ficar mais realista. A visualização das relações entre as tabelas do database podem ajudar bastante no seu entendimento.

***<center>Agradecemos a leitura!<center>*** </center>

<center>☕ 💻 🗄️ 🎃</center>