<!--
  canonical-url: https://www.avonture.be/fr/blog/drawdb-app
  published:     2024-11-11
  This is a static plain-Markdown mirror generated at build time.
  Visit the canonical URL above for the fully rendered page, with images and interactive components.
-->

# Drawdb-app - Rendez votre modèle de base de données en png, markdown, mermaid, ...

> Visualisez et documentez facilement votre modèle de base de données avec DrawDB-app. Importez des fichiers SQL, générez des diagrammes et exportez en PNG, Markdown, Mermaid et plus encore.

---
![Drawdb-app - Rendez votre modèle de base de données](/img/v2/diagrams.webp)

**TL;DR**

Cet article présente drawdb-app, un outil gratuit qui génère un diagramme ER visuel à partir d'un fichier `.sql` importé (ou construit de zéro) et l'exporte en PNG, JSON, Mermaid ou en documentation Markdown générée automatiquement (tables, colonnes, relations) — également auto-hébergeable via Docker (`xinsodev/drawdb`).

Dans mon flux RSS récemment, je suis tombé sur une autre excellente application qui permet de créer un modèle de base de données de zéro, c'est-à-dire de créer les tables une par une et d'établir les liens entre elles.

Mais il y a une autre option que je trouve vraiment sympa : vous pouvez obtenir en quelques secondes une vue des tables et des relations de n'importe quelle application existante à partir d'un fichier .sql que vous importez dans drawdb-app. *Récupérer ce dump `.sql` depuis un container qui tourne se fait en un clic avec [Adminer, pgadmin ou phpmyadmin](/blog/docker-adminer-pgadmin-phpmyadmin).*

Voyons rapidement comment cela fonctionne.

En ouvrant le site <https://www.drawdb.app/editor>, la première chose qu'on vous demande est de choisir le format de base de données cible. Par exemple, choisissons PostgreSQL (Situation : *je développe une application Laravel qui utilise PostgreSQL et je veux voir les relations de ma DB dans une jolie image*).

Je pense que l'usage le plus courant que je pourrais personnellement en faire est de charger un fichier SQL. Pour cela, cliquez simplement sur le menu `File`, choisissez `Import from SQL` et, enfin, récupérez un fichier .sql créé précédemment sur votre disque dur.

## Créer et importer un fichier sql de test {#create-and-import-a-dummy-sql-file}

Si vous n'avez pas un tel fichier, je vous suggère d'en copier un depuis <https://www.sqltutorial.org/sql-sample-database/>. Ci-dessous, vous trouverez le contenu PostgreSQL pris sur ce site ([lien direct](https://www.sqltutorial.org/wp-content/uploads/2020/04/postgresql.txt)) — ou vous pouvez prendre n'importe quel fichier `.sql` valide trouvé sur Internet.

**create\_db.sql**

```sql
CREATE TABLE regions (
  region_id SERIAL PRIMARY KEY,
  region_name CHARACTER VARYING (25)
);

CREATE TABLE countries (
  country_id CHARACTER (2) PRIMARY KEY,
  country_name CHARACTER VARYING (40),
  region_id INTEGER NOT NULL,
  FOREIGN KEY (region_id) REFERENCES regions (region_id) ON UPDATE CASCADE ON DELETE CASCADE
);

CREATE TABLE locations (
  location_id SERIAL PRIMARY KEY,
  street_address CHARACTER VARYING (40),
  postal_code CHARACTER VARYING (12),
  city CHARACTER VARYING (30) NOT NULL,
  state_province CHARACTER VARYING (25),
  country_id CHARACTER (2) NOT NULL,
  FOREIGN KEY (country_id) REFERENCES countries (country_id) ON UPDATE CASCADE ON DELETE CASCADE
);

CREATE TABLE departments (
  department_id SERIAL PRIMARY KEY,
  department_name CHARACTER VARYING (30) NOT NULL,
  location_id INTEGER,
  FOREIGN KEY (location_id) REFERENCES locations (location_id) ON UPDATE CASCADE ON DELETE CASCADE
);

CREATE TABLE jobs (
  job_id SERIAL PRIMARY KEY,
  job_title CHARACTER VARYING (35) NOT NULL,
  min_salary NUMERIC (8, 2),
  max_salary NUMERIC (8, 2)
);

CREATE TABLE employees (
  employee_id SERIAL PRIMARY KEY,
  first_name CHARACTER VARYING (20),
  last_name CHARACTER VARYING (25) NOT NULL,
  email CHARACTER VARYING (100) NOT NULL,
  phone_number CHARACTER VARYING (20),
  hire_date DATE NOT NULL,
  job_id INTEGER NOT NULL,
  salary NUMERIC (8, 2) NOT NULL,
  manager_id INTEGER,
  department_id INTEGER,
  FOREIGN KEY (job_id) REFERENCES jobs (job_id) ON UPDATE CASCADE ON DELETE CASCADE,
  FOREIGN KEY (department_id) REFERENCES departments (department_id) ON UPDATE CASCADE ON DELETE CASCADE,
  FOREIGN KEY (manager_id) REFERENCES employees (employee_id) ON UPDATE CASCADE ON DELETE CASCADE
);

CREATE TABLE dependents (
  dependent_id SERIAL PRIMARY KEY,
  first_name CHARACTER VARYING (50) NOT NULL,
  last_name CHARACTER VARYING (50) NOT NULL,
  relationship CHARACTER VARYING (25) NOT NULL,
  employee_id INTEGER NOT NULL,
  FOREIGN KEY (employee_id) REFERENCES employees (employee_id) ON DELETE CASCADE ON UPDATE CASCADE
);
```

Copiez/collez donc ce SQL dans Notepad, sauvegardez-le sur votre disque et retournez sur <https://www.drawdb.app/editor> ; `File` -> `Import from SQL`.

Et laissez la magie se produire :

![Le modèle](./images/model.webp)

> **L'image ci-dessus a été réalisée avec la fonctionnalité `File` -> `Export as`.:**

### Vous pouvez auto-héberger l'application grâce à Docker si vous le souhaitez {#you-can-self-host-the-application-thanks-to-docker-if-you-want}

En visitant <https://hub.docker.com/search?q=drawdb-io>, vous trouverez quelques images Docker pour drawdb-app. Par exemple <https://hub.docker.com/r/xinsodev/drawdb>.

Pour la lancer, exécutez simplement `docker run --name some-drawdb -p 81:80 -d xinsodev/drawdb` et accédez à l'interface sur `http://localhost:81`.

## Jouons avec la fonctionnalité d'exportation {#playing-with-exportation-feature}

Maintenant, prenez le temps de regarder les fonctionnalités d'export ; cliquez à nouveau sur le menu `File` puis sur `Export as`.

![Export](./images/export.webp)

C'est vraiment cool de pouvoir exporter aussi facilement un fichier SQL en JSON, mais c'est encore plus cool de l'exporter en markdown. *Cet export Mermaid s'intègre directement dans le pipeline décrit dans [Documentation as Code - Transform Your Infrastructure into Beautiful Diagrams with Python and Mermaid](/blog/docker-python-mermaid), et drawDB rejoint la liste des outils de [Docker - Diagrams as code](/blog/docker-diagram-as-code).*

## Sous le capot (passez cette section si vous voulez juste l'utiliser) {#under-the-hood-skip-this-if-you-just-want-to-use-it}

> **Contenu généré automatiquement ci-dessous:**
>
> Le reste de cet article a été généré par drawDB.app ; un outil vraiment utile pour aider les développeurs à documenter leur base de données ! Vous trouverez ci-dessous deux tables représentatives — `employees` (la plus chargée, avec trois clés étrangères) et `regions` (la plus simple) — parmi les sept produites par l'export complet, ainsi que les relations entre toutes.

### Structure des tables {#table-structure}

#### employees {#employees}

| Nom                | Type         | Paramètres      | Références                    | Note |
| ------------------ | ------------ | --------------- | ----------------------------- | ---- |
| **employee\_id**   | SERIAL       | 🔑 PK, not null |                               |      |
| **first\_name**    | BLOB         | not null        |                               |      |
| **last\_name**     | BLOB         | not null        |                               |      |
| **email**          | BLOB         | not null        |                               |      |
| **phone\_number**  | BLOB         | not null        |                               |      |
| **hire\_date**     | DATE         | not null        |                               |      |
| **job\_id**        | INTEGER      | not null        | employees\_job\_id\_fk        |      |
| **salary**         | NUMERIC(8,2) | not null        |                               |      |
| **manager\_id**    | INTEGER      | not null        |                               |      |
| **department\_id** | INTEGER      | not null        | employees\_department\_id\_fk |      |

#### regions {#regions}

| Nom              | Type   | Paramètres      | Références | Note |
| ---------------- | ------ | --------------- | ---------- | ---- |
| **region\_id**   | SERIAL | 🔑 PK, not null |            |      |
| **region\_name** | BLOB   | not null        |            |      |

### Relations {#relationships}

* **countries vers regions** : many\_to\_one
* **locations vers countries** : many\_to\_one
* **departments vers locations** : many\_to\_one
* **employees vers jobs** : many\_to\_one
* **employees vers departments** : many\_to\_one
* **dependents vers employees** : many\_to\_one

## Conclusion {#conclusion}

Importez un fichier `.sql`, récupérez un diagramme ER rendu en quelques secondes, et exportez-le en PNG, JSON, Mermaid ou en documentation Markdown prête à l'emploi — le tout sans rien installer, ou en auto-hébergé via l'image Docker `xinsodev/drawdb` si vous préférez garder ça en interne. L'export Mermaid s'insère directement dans [Documentation as Code - Transform Your Infrastructure into Beautiful Diagrams with Python and Mermaid](/blog/docker-python-mermaid), et drawDB est lui-même une entrée de plus dans la boîte à outils de [Docker - Diagrams as code](/blog/docker-diagram-as-code).
