%reload_ext mocodo

Mocodo 4.2.6 loaded.

from IPython import display
from pathlib import Path
import os
if Path.cwd().name != "mocodo_notebook":
    Path("mocodo_notebook").mkdir(parents=True, exist_ok=True)
    os.chdir("mocodo_notebook")

%%mocodo --colors ocean
Client: Réf. client [VARCHAR(8)], Nom [VARCHAR(255)], Prénom [VARCHAR(255)], Adresse [VARCHAR(255)]
Passer, 0N Client, 11 Commande
Commande: Num. commande [VARCHAR(8)], Date [DATE], Montant [DECIMAL(10,2)]
Inclure, 1N Commande, 0N Produit: Quantité [INTEGER]
Produit: Réf. produit [VARCHAR(8)], Libellé [VARCHAR(50)], Prix unitaire [DECIMAL(10,2)]

Path("sandbox.mcd").rename("ccp.mcd");

%mocodo --input ccp --transform mld diagram ddl --colors mondrian

CREATE TABLE Client (
  PRIMARY KEY (Ref_client),
  Ref_client VARCHAR(8) NOT NULL,
  Nom        VARCHAR(255),
  Prenom     VARCHAR(255),
  Adresse    VARCHAR(255)
);

CREATE TABLE Commande (
  PRIMARY KEY (Num_commande),
  Num_commande VARCHAR(8) NOT NULL,
  Date         DATE,
  Montant      DECIMAL(10,2),
  Ref_client   VARCHAR(8) NOT NULL
);

CREATE TABLE Inclure (
  PRIMARY KEY (Num_commande, Ref_produit),
  Num_commande VARCHAR(8) NOT NULL,
  Ref_produit  VARCHAR(8) NOT NULL,
  Quantite     INTEGER
);

CREATE TABLE Produit (
  PRIMARY KEY (Ref_produit),
  Ref_produit   VARCHAR(8) NOT NULL,
  Libelle       VARCHAR(50),
  Prix_unitaire DECIMAL(10,2)
);

ALTER TABLE Commande ADD FOREIGN KEY (Ref_client) REFERENCES Client (Ref_client);

ALTER TABLE Inclure ADD FOREIGN KEY (Ref_produit) REFERENCES Produit (Ref_produit);
ALTER TABLE Inclure ADD FOREIGN KEY (Num_commande) REFERENCES Commande (Num_commande);

%mocodo -i ccp -t data_dict

%mocodo -i ccp -t crow:mmd

mmd
erDiagram
  Client {
    VARCHAR(8) Ref_client PK
    VARCHAR(255) Nom
    VARCHAR(255) Prenom
    VARCHAR(255) Adresse
  }
  Commande {
    VARCHAR(8) Num_commande PK
    DATE Date
    DECIMAL(10-2) Montant
  }
  Inclure {
    INTEGER Quantite PK
  }
  Produit {
    VARCHAR(8) Ref_produit PK
    VARCHAR(50) Libelle
    DECIMAL(10-2) Prix_unitaire
  }
  Client ||--o{ Commande: Passer
  Inclure }|..|| Commande: DF
  Inclure }o..|| Produit: DF

%mocodo -i ccp -t crow:plantuml --defer

%mocodo -i ccp -t upper:boxes ascii:labels snake:labels --colors brewer+3

%%mocodo --colors brewer+3
CLIENT: Ref_client [VARCHAR(8)], Nom [VARCHAR(255)], Prenom [VARCHAR(255)], Adresse [VARCHAR(255)]
PASSER, 0N CLIENT, 11 COMMANDE
COMMANDE: Num_commande [VARCHAR(8)], Date [DATE], Montant [DECIMAL(10,2)]
INCLURE, 1N COMMANDE, 0N PRODUIT: Quantite [INTEGER]
PRODUIT: Ref_produit [VARCHAR(8)], Libelle [VARCHAR(50)], Prix_unitaire [DECIMAL(10,2)]

%mocodo -i ccp -t explode:weak,arity=2 arrange:wide --seed=3 --colors brewer+3

%%mocodo --seed=3 --colors brewer+3
Client: Réf. client [VARCHAR(8)], Nom [VARCHAR(255)], Prénom [VARCHAR(255)], Adresse [VARCHAR(255)]
Passer, 0N Client, 11 Commande
Commande: Num. commande [VARCHAR(8)], Date [DATE], Montant [DECIMAL(10,2)]
DF, _11 Inclure, 1N Commande
Inclure: _Quantité [INTEGER]
DF, _11 Inclure, 0N Produit
Produit: Réf. produit [VARCHAR(8)], Libellé [VARCHAR(50)], Prix unitaire [DECIMAL(10,2)]

%%mocodo
MISSION: accomplie

from mocodo.api import mocodo

messages = mocodo("-i ccp --colors mondrian")

print(messages)

Fichier de sortie « ~/Dropbox/Sites/mocodo/doc/mocodo_notebook/ccp.svg » généré avec succès.

display.SVG("ccp.svg")

from mocodo.magic import mocodo

mocodo("%mocodo -i ccp --colors ocean")

mocodo("""
%%mocodo --colors pond
Mission: accomplie
""")

%%mocodo
CLIENT: Réf. client, Nom, Prénom, Adresse
PASSER, 0N CLIENT, 11 COMMANDE
COMMANDE: Num. commande, Date, Montant
INCLURE, 1N COMMANDE, 0N PRODUIT: Quantité
PRODUIT: Réf. produit, Libellé, Prix unitaire

%%mocodo -t guess:entities
Réserver, 1N Client, 1N Chambre, 0N Date: Durée

%%mocodo 
Réserver, 1N Client, 1N Chambre, 0N Date: Durée

Chambre: id. chambre, 
Date: date
Client: id. client,

%%mocodo
CLIENT: Réf. client, Nom, Prénom, Adresse
DF, 0N CLIENT, 11 COMMANDE
COMMANDE: Num. commande, Date, Montant
INCLURE, 1N COMMANDE, 0N PRODUIT: Quantité
PRODUIT: Réf. produit, Libellé, Prix unitaire

%%mocodo
HOMME: Num. SS, Nom, Prénom
ENGENDRER, 0N HOMME, 01 HOMME

%%mocodo
GRATTE-CIEL: latitude, _longitude, nom, hauteur, année de construction

%%mocodo
Peut recevoir, 1N> Groupe sanguin, 1N< Groupe sanguin
Groupe sanguin: type de sang
Appartient, 11> Personne, 0N Groupe sanguin
Personne: Num. SS, Nom, Prénom, Sexe
Engendre, 0N< Personne, 22> Personne

%%mocodo -t guess:types --select source
CLIENT: Réf. client, Nom, Prénom, Adresse
PASSER, 0N CLIENT, 11 COMMANDE
COMMANDE: Num. commande, Date, Montant
INCLURE, 1N COMMANDE, 0N PRODUIT: Quantité
PRODUIT: Réf. produit, Libellé, Prix unitaire

%%mocodo --select source
CLIENT: Réf. client [VARCHAR(8)], Nom [VARCHAR(255)], Prénom [VARCHAR(255)], Adresse [VARCHAR(30)]
PASSER, 0N CLIENT, 11 COMMANDE
COMMANDE: Num. commande [VARCHAR(8)], Date [DATE], Montant [DECIMAL(10,2)]
INCLURE, 1N COMMANDE, 0N PRODUIT: Quantité [INTEGER]
PRODUIT: Réf. produit [VARCHAR(8)], Libellé [VARCHAR(50)], Prix unitaire [DECIMAL(10,2)]

%%mocodo
CLIENT: Réf. client, Nom, Prénom, Adresse
COMMANDE: Num. commande, Date, Montant
PRODUIT: Réf. produit, Libellé, Prix unitaire
PASSER, 0N CLIENT, 11 COMMANDE
INCLURE, 1N COMMANDE, 0N PRODUIT: Quantité

%mocodo -i sandbox --detect_overlaps

Mocodo Err.29 - Mauvaise disposition des boîtes :
  - La patte « INCLURE — COMMANDE » chevauche « PRODUIT ».
  - La patte « INCLURE — PRODUIT » chevauche « PASSER ».
  - La patte « PASSER — CLIENT » chevauche « COMMANDE ».
  - Les pattes  « PASSER — COMMANDE » et « INCLURE — COMMANDE » se chevauchent.
Pour corriger cela, réordonnez et/ou sautez des lignes dans le texte-source, soit à la
main, soit à l'aide de l'option -t arrange (tablette de chocolat sous Mocodo online).

%%mocodo
SCELERISQUE LOREM: blandit, elit, ligula
EROS, 11 SCELERISQUE LOREM, 1N PELLENTESQUE IPSUM: metus, congue

NIBH, 1N SCELERISQUE LOREM, 11 PELLENTESQUE IPSUM
PELLENTESQUE IPSUM: tincidunt, bibendum, consequat, integer

%mocodo -i sandbox --select mcd -t flip:h

%%mocodo 
Ultrices, 01 Aliquet, 0N Aliquet
Aliquet: hendrerit, metus, lacus, quis
Risus, 1N Aliquet, 0N Massa
Massa: metus, posuere
Euismod, 0N Massa, 0N Massa

Convallis, 0N Aliquet, 0N Ante: vestibulum
Tincidunt, 11 Ante, 0N Massa

Gravida: ornare
Rutrum, 0N Gravida, 0N Ante, 0N Aliquet: faucibus, curae
Ante: vitae, tempor

%%mocodo
Ultrices, 01 Aliquet, 0N Aliquet
Aliquet: hendrerit, metus, lacus, quis
Risus, 1N Aliquet, 0N Massa
Massa: metus, posuere
Euismod, 0N Massa, 0N Massa

:
:
Convallis, 0N Aliquet, 0N Ante: vestibulum
Tincidunt, 11 Ante, 0N Massa

Gravida: ornare
Rutrum, 0N Gravida, 0N Ante, 0N Aliquet: faucibus, curae
:
Ante: vitae, tempor

%mocodo -i ../examples/four_random_layouts --scale 0.8

%%mocodo
ŒUVRE: Cote œuvre, Titre, Date parution
DF, 1N ŒUVRE, _11 EXEMPLAIRE
EXEMPLAIRE: Num. exemplaire, État du livre, Date d'achat

%%mocodo 
Employé: Num. employé, Nom employé, Prénom employé
Df, _11 Conjoint, 01 Employé
Conjoint: _Nom conjoint, Prénom conjoint

%%mocodo
Employé: Num. employé, Nom employé, Prénom employé
Df, _11 Conjoint, 0N Employé
Conjoint: _Nom conjoint, Prénom conjoint

Mocodo Err.50 - L'entité faible « CONJOINT » devrait avoir un discriminateur.

%%mocodo
Personne: num SS, nom, prénom

/XT\ Personne <- Homme, Femme: sexe

Homme: 
:
Femme: nom de jeune fille

%%mocodo -t
:::
Dépôt: num dépôt, surface

:
Louer, 11 Commande, 0N Dépôt
:
Stocker, 1N Dépôt, 1N Article: quantité

Commande: num. commande, date
Composer, 1N Commande, 0N Article
:
Article: réf. article, prix

(I) ->Stocker, ..Dépôt, ..Article, --Composer, --Louer, Commande

%%mocodo --colors ocean # changement de palette pour faire apparaître un fond semi-transparent 
Date: Date
Réserver, /1N Client, 1N Chambre, 0N Date: Durée
Chambre: Num. chambre, Prix

Client: Id. client

%mocodo -i sandbox -t create:cifs arrange --seed=12 --colors ocean

%%mocodo --seed=12 --colors ocean
Date: Date
Réserver, /1N Client, 1N Chambre, 0N Date: Durée
Chambre: Num. chambre, Prix

-INVISIBLE_1, XX Client, XX Client
Client: Id. client
:

(CIF) ..Réserver, ->Client, --Chambre, --Date: INVISIBLE_1, INVISIBLE_1

%mocodo -i sandbox -t create:cifs=light arrange --seed=12 --colors ocean

%%mocodo --seed=12 --colors ocean
Date: Date
Réserver, /1N Client, 1N Chambre, 0N Date: Durée
Chambre: Num. chambre, Prix

-INVISIBLE_1, XX Client, XX Client
Client: Id. client
:

(CIF) ..Réserver, ->Client, Chambre, Date: INVISIBLE_1, INVISIBLE_1

%%mocodo -t
Client: Id. client
Réserver, 1N Client, 0N Chambre: _Date, Durée
Chambre: Num. chambre, Prix

%mocodo -i ccp -t mld

%mocodo -i ccp -t

%mocodo -i ccp --colors mondrian -t diagram

display.Code("ccp_mld.mcd", language="text")

%%mocodo
:
Client: Réf. client, Nom, Prénom, Adresse
:
Commande: Num. commande, Date, Montant, #Réf. client > Client > Réf. client
:
Inclure: #Num. commande > Commande > Num. commande, _#Réf. produit > Produit > Réf. produit, Quantité
:
Produit: Réf. produit, Libellé, Prix unitaire
:

%mocodo -i ccp -t sql

CREATE TABLE Client (
  PRIMARY KEY (Ref_client),
  Ref_client VARCHAR(8) NOT NULL,
  Nom        VARCHAR(255),
  Prenom     VARCHAR(255),
  Adresse    VARCHAR(255)
);

CREATE TABLE Commande (
  PRIMARY KEY (Num_commande),
  Num_commande VARCHAR(8) NOT NULL,
  Date         DATE,
  Montant      DECIMAL(10,2),
  Ref_client   VARCHAR(8) NOT NULL
);

CREATE TABLE Inclure (
  PRIMARY KEY (Num_commande, Ref_produit),
  Num_commande VARCHAR(8) NOT NULL,
  Ref_produit  VARCHAR(8) NOT NULL,
  Quantite     INTEGER
);

CREATE TABLE Produit (
  PRIMARY KEY (Ref_produit),
  Ref_produit   VARCHAR(8) NOT NULL,
  Libelle       VARCHAR(50),
  Prix_unitaire DECIMAL(10,2)
);

ALTER TABLE Commande ADD FOREIGN KEY (Ref_client) REFERENCES Client (Ref_client);

ALTER TABLE Inclure ADD FOREIGN KEY (Ref_produit) REFERENCES Produit (Ref_produit);
ALTER TABLE Inclure ADD FOREIGN KEY (Num_commande) REFERENCES Commande (Num_commande);

%%mocodo -t create:types --select rw
Customer: Customer ID, Last Name, First Name, Address
Make Order, 0N Customer, 11 Order
Order: Order Number, Date, Amount
INCLUDE, 1N Order, 0N Product: Quantity
Product: Product ID, Description, Unit Price

%%mocodo --select rw
Customer: Customer ID [VARCHAR(8)], Last Name [VARCHAR(255)], First Name [VARCHAR(255)], Address [VARCHAR(30)]
Make Order, 0N Customer, 11 Order
Order: Order Number [VARCHAR(8)], Date [DATE], Amount [DECIMAL(10,2)]
INCLUDE, 1N Order, 0N Product: Quantity [INTEGER]
Product: Product ID [VARCHAR(8)], Description [TEXT], Unit Price [DECIMAL(10,2)]

%%mocodo -t create:types=[] --select rw
Customer: Customer ID, Last Name, First Name, Address
Make Order, 0N Customer, 11 Order
Order: Order Number, Date, Amount
INCLUDE, 1N Order, 0N Product: Quantity
Product: Product ID, Description, Unit Price

%%mocodo --select rw
Customer: Customer ID [], Last Name [], First Name [], Address []
Make Order, 0N Customer, 11 Order
Order: Order Number [], Date [], Amount []
INCLUDE, 1N Order, 0N Product: Quantity []
Product: Product ID [], Description [], Unit Price []

%%mocodo -t mysql:b
USER: username, mail, member

CREATE DATABASE IF NOT EXISTS `MCD`
  CHARACTER SET utf8mb4
  COLLATE utf8mb4_general_ci
;
USE `MCD`;

CREATE TABLE `USER` (
  PRIMARY KEY (username),
  username VARCHAR(42) NOT NULL,
  mail     VARCHAR(42),
  `member` VARCHAR(42)
);

%mocodo -i ccp -t mld:c

%%mocodo --select all -t mld:c
Entreprise: id. entreprise, raison, activité, adresse
Envoyer, 0N Entreprise, 01 Participant
Participant: id. inscrit, nom, adresse

%%mocodo --select all -t mld:c
EMPLOYÉ: id. employé, nom employé
DIRIGER, 11 DÉPARTEMENT, 01 EMPLOYÉ
DÉPARTEMENT: id. département, nom département

%%mocodo -t mld:c
Personne: id. personne [VARCHAR(8)], nom [VARCHAR(255) NOT NULL], prénom [VARCHAR(255)], nom de jeune fille [VARCHAR(255) NULL]

%%mocodo --select all -t mld:c --shapes trebuchet # changement de police de caractères pour mieux distinguer les 1 des I
CLIENT: Réf. client, 1_Nom, 1_Prénom, Adresse, 2_Mail

%%mocodo --select all -t markdown:c sql --shapes trebuchet
FOO: foo, 1_bar, 12_biz, 2_buz, 3_qux, 123_quux

CREATE TABLE FOO (
  PRIMARY KEY (foo),
  foo  VARCHAR(42) NOT NULL,
  bar  VARCHAR(42),
  biz  VARCHAR(42),
  buz  VARCHAR(42),
  qux  VARCHAR(42),
  quux VARCHAR(42),
  UNIQUE (bar, biz, quux),
  UNIQUE (biz, buz, quux),
  UNIQUE (qux, quux)
);

%%mocodo --shapes trebuchet
Entité 1_: 1_foo, _bar, 1_biz
Entité 2_: foo, 1_bar, 1_biz
Entité 3_: foo, 01_bar, 1_biz

%%mocodo --shapes trebuchet
Entité 40: _foo, _bar, biz
Entité 50: 01_foo, _bar, 1_biz

%%mocodo -t
Appartement: num appart., nb pièces
Composer, 0N Étage, _11 Appartement
Étage: num étage, nb appartements
Appartenir, 1N Immeuble, _11 Étage
Immeuble: num immeuble, nb étages
Se situer, 0N Rue, _11 Immeuble
Rue: code rue, nom rue

%mocodo -i sandbox -t diagram --colors mondrian

%%mocodo
Pick, 0N Land, _11 Peer
Land: true, hold

Peer: foot, city
Zone, 1N Peer, _11 Land

%mocodo -i sandbox -t

Mocodo Err.17 - Cycle d'entités faibles dans "Land", "Peer".

%%mocodo --select all -t mld:c
DOCUMENT: cote, titre, auteur
    
OUVRAGE: éditeur
/T\ DOCUMENT -> OUVRAGE, THÈSE
THÈSE: discipline, université

%%mocodo --select all -t mld:c
DOCUMENT: cote, titre, auteur
    
OUVRAGE: éditeur
/T\ DOCUMENT => OUVRAGE, THÈSE
THÈSE: discipline, université

%%mocodo --select all -t mld:c sql
DOCUMENT: cote, titre, auteur

OUVRAGE: éditeur
/X\ DOCUMENT <- OUVRAGE, THÈSE: discriminateur [ENUM ('OUVRAGE', 'THÈSE')]
THÈSE: discipline, université

CREATE TABLE DOCUMENT (
  PRIMARY KEY (cote),
  cote           VARCHAR(42) NOT NULL,
  titre          VARCHAR(42),
  auteur         VARCHAR(42),
  discriminateur ENUM ('OUVRAGE', 'THÈSE') NULL,
  editeur        VARCHAR(42) NULL,
  discipline     VARCHAR(42) NULL,
  universite     VARCHAR(42) NULL
);

%%mocodo --select all -t mld:c sql
DOCUMENT: cote, titre, auteur

OUVRAGE: éditeur
/T\ DOCUMENT <= OUVRAGE, THÈSE
THÈSE: discipline, université

CREATE TABLE DOCUMENT (
  PRIMARY KEY (cote),
  cote        VARCHAR(42) NOT NULL,
  titre       VARCHAR(42),
  auteur      VARCHAR(42),
  est_ouvrage BOOLEAN NOT NULL,
  editeur     VARCHAR(42) NULL,
  est_these   BOOLEAN NOT NULL,
  discipline  VARCHAR(42) NULL,
  universite  VARCHAR(42) NULL
);

%%mocodo --select all -t mld:c
DATE: date
RÉSERVER, /1N CLIENT, 1N CHAMBRE, 0N DATE: durée
CHAMBRE: num. chambre, prix

CLIENT: id. client, nom client

%%mocodo --select all -t mld:c
Voilier: num voilier, longueur
Offrir, /11 Réservation, 0N Voilier, 0N Semaine: tarif
Semaine: num semaine, date début

Réservation: num résa, arrhes, date résa

%%mocodo --select mld mcd -t mld:e
Animateur: num. animateur, nom animateur
Intervenir, 1N Animateur, 1N Formation, 1N Date: nb heures
Formation: id. formation, durée
Aborder, 1N Thème, 1N Formation
+Thème: thème

Date: date
:

%%mocodo --select all -t mld:c
Entreprise: id. entreprise, raison, activité, adresse
Envoyer, 0N Entreprise, 01 Participant
Participant: id. inscrit, nom, adresse

%%mocodo --select all -t mld:c --colors mondrian
Entreprise: id. entreprise, raison, activité, adresse
+Envoyer, 0N Entreprise, 01 Participant
Participant: id. inscrit, nom, adresse

%%mocodo -t
Soutenir, 01 Étudiant, 0N Date: note stage
Étudiant: num. étudiant, nom, coordonnées

Date: date
Répondre de, 0N Date, 11 Étudiant, 0N Enseignant
Enseignant: num. enseignant, nom, coordonnées

%%mocodo -t mld
Soutenir, 01 Étudiant, 0N [soutenance] Date: note stage
Étudiant: num. étudiant, nom, coordonnées

Date: date
Répondre de, 0N [+ visite resp] Date, 11 Étudiant, 0N [-num. ens. resp.] Enseignant
Enseignant: num. enseignant, nom, coordonnées

%%mocodo -t
HOMME: num. SS, nom, prénom
ENGENDRER, 0N [père] HOMME, 01 [fils] HOMME

%%mocodo -t mld diagram sql --colors mondrian
USER: user id [VARCHAR(8)], name [VARCHAR(100)], pseudo [VARCHAR(100)]
DF, 11 USER, 11 AUTHENTICATION
AUTHENTICATION: email [VARCHAR(255)], password hash [BINARY(64)], salt [BINARY(16)]

CREATE TABLE AUTHENTICATION (
  PRIMARY KEY (email),
  email         VARCHAR(255) NOT NULL,
  password_hash BINARY(64),
  salt          BINARY(16)
);

CREATE TABLE USER (
  PRIMARY KEY (user_id),
  user_id VARCHAR(8) NOT NULL,
  name    VARCHAR(100),
  pseudo  VARCHAR(100),
  email   VARCHAR(255) NOT NULL,
  UNIQUE (email)
);

ALTER TABLE USER ADD FOREIGN KEY (email) REFERENCES AUTHENTICATION (email);

%%mocodo -t mld diagram sql --colors mondrian
USER: user id [VARCHAR(8)], name [VARCHAR(100)], pseudo [VARCHAR(100)]
DF, _11 AUTHENTICATION, 11 USER
AUTHENTICATION: email [VARCHAR(255)], password hash [BINARY(64)], salt [BINARY(16)]

CREATE TABLE AUTHENTICATION (
  PRIMARY KEY (user_id, email),
  user_id       VARCHAR(8) NOT NULL,
  email         VARCHAR(255) NOT NULL,
  password_hash BINARY(64),
  salt          BINARY(16)
);

CREATE TABLE USER (
  PRIMARY KEY (user_id),
  user_id VARCHAR(8) NOT NULL,
  name    VARCHAR(100),
  pseudo  VARCHAR(100)
);

ALTER TABLE AUTHENTICATION ADD FOREIGN KEY (user_id) REFERENCES USER (user_id);

%%mocodo -t mld sql --colors mondrian --select all
:
USER: user id [VARCHAR(8)], name [VARCHAR(100)], pseudo [VARCHAR(100)], #email > AUTHENTICATION > email
:
AUTHENTICATION: email [VARCHAR(255)], password hash [BINARY(64)], salt [BINARY(16)], #user id > USER > user id
:

CREATE TABLE AUTHENTICATION (
  PRIMARY KEY (email),
  email         VARCHAR(255) NOT NULL,
  password_hash BINARY(64),
  salt          BINARY(16),
  user_id       VARCHAR(42)
);

CREATE TABLE USER (
  PRIMARY KEY (user_id),
  user_id VARCHAR(8) NOT NULL,
  name    VARCHAR(100),
  pseudo  VARCHAR(100),
  email   VARCHAR(42)
);

%mocodo -i ccp -t dependencies --defer

%mocodo -i ccp -t dbml --title CCP

dbml
Table "Client" {
  "Réf. client" VARCHAR(8) [pk, NOT NULL]
  "Nom"         VARCHAR(255)
  "Prénom"      VARCHAR(255)
  "Adresse"     VARCHAR(255)
}

Table "Commande" {
  "Num. commande" VARCHAR(8) [pk, NOT NULL]
  "Date"          DATE
  "Montant"       DECIMAL(10,2)
  "Réf. client"   VARCHAR(8) [NOT NULL]
}

Table "Inclure" {
  "Num. commande" VARCHAR(8) [NOT NULL]
  "Réf. produit"  VARCHAR(8) [NOT NULL]
  "Quantité"      INTEGER
  Indexes {
    ("Num. commande", "Réf. produit") [pk]
  }
}

Table "Produit" {
  "Réf. produit"  VARCHAR(8) [pk, NOT NULL]
  "Libellé"       VARCHAR(50)
  "Prix unitaire" DECIMAL(10,2)
}

Ref:"Commande"."Réf. client" > "Client"."Réf. client"
Ref:"Inclure"."Num. commande" > "Commande"."Num. commande"
Ref:"Inclure"."Réf. produit" > "Produit"."Réf. produit"

display.SVG("../examples/dbml.svg")

%mocodo -i ccp -t d2

d2
"Client": { shape: sql_table
  "Réf. client": VARCHAR(8) {constraint: PK}
  "Nom":         VARCHAR(255) 
  "Prénom":      VARCHAR(255) 
  "Adresse":     VARCHAR(255) 
}

"Commande": { shape: sql_table
  "Num. commande": VARCHAR(8) {constraint: PK}
  "Date":          DATE 
  "Montant":       DECIMAL(10,2) 
  "Réf. client":   VARCHAR(8) {constraint: [FK; NOT NULL]}
}

"Inclure": { shape: sql_table
  "Num. commande": VARCHAR(8) {constraint: [PK; FK]}
  "Réf. produit":  VARCHAR(8) {constraint: [PK; FK]}
  "Quantité":      INTEGER 
}

"Produit": { shape: sql_table
  "Réf. produit":  VARCHAR(8) {constraint: PK}
  "Libellé":       VARCHAR(50) 
  "Prix unitaire": DECIMAL(10,2) 
}

"Commande"."Réf. client" -> "Client"."Réf. client"
"Inclure"."Num. commande" -> "Commande"."Num. commande"
"Inclure"."Réf. produit" -> "Produit"."Réf. produit"

%mocodo -i ccp -t d2 --defer

%mocodo -i ccp --title CCP -t uml:plantuml=- # '-' supprime un préambule par défaut qui ne nous intéresse pas ici

puml
@startuml "CCP"

!define Table(x) class "x" << (T,#FFFFFF) >>
!define pk(x) <b>x</b>

Table("Client") {
    {field} + pk(Réf. client) VARCHAR(8)
    {field} + Nom         VARCHAR(255)
    {field} + Prénom      VARCHAR(255)
    {field} + Adresse     VARCHAR(255)
}

"Client" "1" --- "*" "Commande": "Passer"

Table("Commande") {
    {field} + pk(Num. commande) VARCHAR(8)
    {field} + Date          DATE
    {field} + Montant       DECIMAL(10,2)
}

"Commande" "*" --- "1..*" "Produit": "Inclure"
("Commande", "Produit") .. "Inclure"
Table("Inclure") {
    {field} + Quantité INTEGER
}

Table("Produit") {
    {field} + pk(Réf. produit)  VARCHAR(8)
    {field} + Libellé       VARCHAR(50)
    {field} + Prix unitaire DECIMAL(10,2)
}

@enduml

%mocodo -i ccp -t uml --defer --colors brewer+5

%mocodo -i ccp -t chen --defer --colors ocean

%mocodo -i ccp -t chen:attrs --defer --colors ocean

%mocodo -i ccp -t crow --defer --colors brewer+3

%mocodo -i ccp -t data_dict:tsv

%mocodo -i ccp -t data_dict:**box**="Entité ou<br>association",label,`type`=`"Type de données"`

%mocodo -i ccp -t data_dict:label

%mocodo -i ccp -t share

https://www.mocodo.net/?mcd=eNptkMEKgkAQhu89xRwLJDQQwtuySgm5mEgX6bDlBgu6xrYLvZLP4Ys1ahZYt_m_Yeb_Z2glhTIBZF17W8N1UFCcSEb3JFtuV2cHWFN_ycb3e5bqrlV_OCm1eDzEjC9SjlA74DKgg4UDnge0qWuuSrGYigCYrTHFW85yhNwgCkkeoUgaZXgfNYxonJDD0nOdDTrF6lpZLXA_--wffFPdlFbipUeLc9J0LRQxy6NdlGG-qTm-4T7Kmf9BXkRV9XMT9t3xF_IJVknDpRY_gV4LRG5Z

%%mocodo
ŒUVRE1: cote, titre, date de publication
:::
ŒUVRE2: 612.NAT.34, J'apprends à lire à mes souris blanches, mai 1975
:
  
DF, 1N ŒUVRE1, _11 EXEMPLAIRE1
::
DF, XX ŒUVRE2, XX EXEMPLAIRE2
DF, XX ŒUVRE2, XX EXEMPLAIRE3
DF, XX ŒUVRE2, XX EXEMPLAIRE4

EXEMPLAIRE1: numéro d'exemplaire, état, date d'achat
::
EXEMPLAIRE2: 1, bon état, 12/6/1975
EXEMPLAIRE3: 2, bon état, 1/8/1977
EXEMPLAIRE4: 3, reliure rongée, 3/4/2005

%%mocodo -t
ŒUVRE: 612.NAT.34, J'apprends à lire à mes souris blanches, mai 1975
  
DF, -1N ŒUVRE, -_11 EXEMPLAIRE1
DF, -1N ŒUVRE, -_11 EXEMPLAIRE2
DF, -1N ŒUVRE, -_11 EXEMPLAIRE3

EXEMPLAIRE1: 1, bon état, 12/6/1975
EXEMPLAIRE2: 2, bon état, 1/8/1977
EXEMPLAIRE3: 3, reliure rongée, 3/4/2005

%%mocodo
Produit: réf. produit, libellé, prix unitaire
Inclure, 1N [Une commande inclut au moins un produit.] Commande, 0N [Un produit peut être commandé un nombre quelconque de fois.] Produit: quantité
Commande: num. commande, date, montant
DF, 0N [Un client peut passer zéro (prospect) ou plusieurs commandes.] Client, 11 [Une commande est passée par un et un seul client.] Commande
Client: réf. client, nom, adresse
Parrainer, 01 [Un client peut avoir été parrainé ou non.] Client, 0N [Un client peut parrainer d'autres clients.] Client : date parrainage

%%mocodo
Projet: num. projet, nom projet
:
Fournir, 1N Projet, 1N Pièce, 1N Société: quantité
Société: num. société, raison sociale

Requérir, 1N Projet, 0N Pièce: quantité
:
Pièce: réf. pièce, libellé pièce

(I) [Toute pièce fournie doit avoir été requise.] ..Pièce, ->Requérir, --Fournir, Projet

%%mocodo --colors ocean
      Parrainer, 01 Client, 0N Client : date parrainage
Produit: Réf. produit, Libellé, Prix unitaire
  Inclure, 1N Commande, 0N Produit: Quantité
 
    Client: Réf. client, Nom, Prénom, Adresse
    DF, 0N Client, 11 Commande
  Commande: Num. commande, Date, Montant

%%mocodo
FOO: foo
  BAR: bar

%%mocodo
FOO: foo
  BAR: bar

%%mocodo --uid_suffix 1
FOO: foo
  BAR: bar

%%mocodo --uid_suffix 2
FOO: foo
  BAR: bar

%mocodo -i ccp -t markdown:e

%%mocodo
CLIENT: _Réf. client, Nom, Prénom, Adresse
PASSER, 0N CLIENT, 11 COMMANDE
COMMANDE: _Num. commande, Date, Montant
INCLURE, 1N COMMANDE, 0N PRODUIT: Quantité
PRODUIT: _Réf. produit, Libellé, Prix unitaire

%%mocodo
CLIENT: Réf. client, Nom, Prénom, Adresse
PASSER, XX CLIENT, XX COMMANDE
COMMANDE: Num. commande, Date, Montant
INCLURE, -1N COMMANDE, -0N PRODUIT: Quantité
PRODUIT: Réf. produit, Libellé, Prix unitaire

%%mocodo
CLIENT: Réf. client,,, 
PASSER, XX CLIENT, XX COMMANDE
COMMANDE: , Date, Montant
INCLURE, 1N COMMANDE, 0N PRODUIT: Quantité,,,,
PRODUIT: Réf. produit, Libellé, Prix unitaire

%mocodo -i ccp --colors=blank

%mocodo -i ccp -t empty # équivalent de "delete:types,notes,attrs,cards"

%%mocodo 
Client:  ,  ,  ,  
Passer, XX Client, XX Commande
Commande:  ,  ,  
Inclure, XX Commande, XX Produit:  
Produit:  ,  ,

%mocodo -i ccp --seed=1 --select mcd -t obfuscate  # raccourci pour "obfuscate:labels"

%mocodo -i ccp -t obfuscate:labels=../../README.md --seed=1 --select mcd

%mocodo -i ccp -t grow:n=4 arrange --seed=1 --select mcd

%mocodo --seed=2 --mld -t grow:from_scratch,arity_3=1,_11-*N=1 obfuscate create:roles lower:roles arrange

%mocodo -i ccp -t share --defer

path = Path("def_weak-974e.mcd")
path.unlink(missing_ok=True)
path.is_file()

False

%mocodo -i def_weak-974e.mcd

path.is_file()

True

%mocodo -i ../examples/landing --select mcd --seed=2 -t arrange

%mocodo -i ../examples/landing --select mcd --seed=2 -t arrange:current

%mocodo -i ../examples/landing --select mcd --seed=2 -t arrange:wide=8 --scale 0.8

%mocodo -i ../examples/landing --select mcd --seed=1 -t arrange:balanced=1

%%mocodo
DIGNISSIM: nec sem, nunc, vulputate
IMPERDIET: a praesent, nibh, semper
TINCIDUNT: faucibus, orci, cursus

RHONCUS, 1N DIGNISSIM, 1N IMPERDIET, 1N TINCIDUNT
SODALES, 1N DIGNISSIM, 1N IMPERDIET, 1N TINCIDUNT
QUIS ENIM, 1N DIGNISSIM, 1N IMPERDIET, 1N TINCIDUNT

%mocodo -i sandbox --seed=1 -t arrange:balanced

Mocodo Err.9 - Impossible de calculer un plongement planaire satisfaisant la contrainte
donnée.

%mocodo -i sandbox --seed=1 -t arrange

Mocodo Err.41 - Impossible de calculer un plongement planaire.

%mocodo -i sandbox --seed=1 -t arrange:algo=ga

%%mocodo --seed=1
DIGNISSIM: nec sem, nunc, vulputate
RHONCUS, 1N DIGNISSIM, 1N IMPERDIET, 1N TINCIDUNT
IMPERDIET: a praesent, nibh, semper

SODALES, 1N DIGNISSIM, 1N IMPERDIET, 1N TINCIDUNT
TINCIDUNT: faucibus, orci, cursus
QUIS ENIM, 1N DIGNISSIM, 1N IMPERDIET, 1N TINCIDUNT

%%mocodo
RHONCUS, 1N DIGNISSIM, 1N IMPERDIET, 1N TINCIDUNT

DIGNISSIM: nec sem, nunc, vulputate
:::
IMPERDIET: a praesent, nibh, semper

SODALES, 1N DIGNISSIM, 1N IMPERDIET, 1N TINCIDUNT
:::
QUIS ENIM, 1N DIGNISSIM, 1N IMPERDIET, 1N TINCIDUNT

TINCIDUNT: faucibus, orci, cursus

%%mocodo -t
Étudiant: id. étudiant, nom étudiant
:
:
SHR, 0N Période3, 0N Salle, 0N Étudiant
Période3: heure

:
CSG, 0N Niveau, 1N Cours, 1N Étudiant
Niveau: niveau
:

CHS, 0N Période2, 0N Cours, 0N Étudiant
Cours: id. cours, nom cours
CHR, 0N Période4, 0N Salle, 0N Cours
Salle: id. salle, nom salle

Période2: heure
CT, 11 Cours, 1N Professeur
Période4: heure
:
:

:
Professeur: id. professeur, nom professeur
:
THR, 0N Période1, 0N Salle, 0N Professeur
Période1: heure

%%mocodo -t
CSG, 1N Cours, 1N Étudiant: _niveau
:
Cours: id. cours, nom cours
CT, 11 Cours, 1N Professeur

:
CHS, 0N Cours, 0N Étudiant: _heure
CHR, 0N Salle, 0N Cours: _heure
Professeur: id. professeur, nom professeur
    
Étudiant: id. étudiant, nom étudiant
SHR, 0N Salle, 0N Étudiant: _heure
Salle: id. salle, nom salle
THR, 0N Salle, 0N Professeur: _heure

%mocodo -i sandbox --no_assoc_ids

Mocodo Err.52 - L'association « CSG » ne peut pas avoir d'identifiant.

%%mocodo  --card_format=({min_card}/{max_card}) --strengthen_card=(1/1)(R)
ŒUVRE: Cote œuvre, Titre, Date parution
DF, 1N ŒUVRE, _11 EXEMPLAIRE
EXEMPLAIRE: Num. exemplaire, État du livre, Date d'achat

%mocodo -i ccp -t diagram --fk_format={label}

%%mocodo --df CIF
CLIENT: Réf. client, Nom, Prénom, Adresse
CIF, 0N CLIENT, 11 COMMANDE
COMMANDE: Num. commande, Date, Montant
INCLURE, 1N COMMANDE, 0N PRODUIT: Quantité
PRODUIT: Réf. produit, Libellé, Prix unitaire

%%mocodo
:::
Dépôt: num dépôt, surface

:
Louer, 11 Commande, 0N Dépôt
:
Stocker, 1N Dépôt, 1N Article: quantité

Commande: num. commande, date
Composer, 1N Commande, 0N Article
:
Article: réf. article, prix

(I) ->Stocker, ..Dépôt, ..Article, --Composer, --Louer, Commande, Stocker

%%mocodo
:::
Dépôt: num dépôt, surface

:
Louer, 11 Commande, 0N Dépôt
Z, XX Commande, XX Article, XX Dépôt
Stocker, 1N Dépôt, 1N Article: quantité

Commande: num. commande, date
Composer, 1N Commande, 0N Article
:
Article: réf. article, prix

(I) ->Stocker, ..Dépôt, ..Article, --Composer, --Louer: Z, Z

%%mocodo
:::
Dépôt: num dépôt, surface

:
Louer, 11 Commande, 0N Dépôt
-Z, XX Commande, XX Article, XX Dépôt
Stocker, 1N Dépôt, 1N Article: quantité

Commande: num. commande, date
Composer, 1N Commande, 0N Article
:
Article: réf. article, prix

(I) ->Stocker, ..Dépôt, ..Article, --Composer, --Louer: Z, Z

%%mocodo --gutters ids:visibility=off
CLIENT: Réf. client, 1_Nom, 1_Prénom, Adresse, 2_Mail

%%mocodo --gutters ids:visibility=on
CLIENT: Réf. client, Nom, Prénom, Adresse, Mail

%%mocodo --gutters ids:strong=➤,alts=❶❷❸❹
CLIENT: Réf. client, 1_Nom, 1_Prénom, Adresse, 2_Mail

%%mocodo -t
Personne: num SS, nom, prénom

/XT\ Personne => Homme, Femme: sexe

Homme: 
:
Femme: nom de jeune fille

%%mocodo -t
Personne: num SS, nom, prénom

/XT\ Personne ==> Homme, Femme: sexe

Homme: 
:
Femme: nom de jeune fille

%%mocodo --colors brewer+1
VELIT, 1N> BLANDIT, 11 NONUMMY: sollicitudin

BLANDIT: consequat, ligula, nibh, consequat
:::
NONUMMY: consequat, ligula
  
VIVAMUS, 0N NONUMMY, 0N BLANDIT: eleifend, iaculis

display.Code("sandbox_geo.json")

{
  "width": 444,
  "height": 242,
  "cx": [
    [ "VELIT", 214 ],
    [ "BLANDIT", 58 ],
    [ "NONUMMY", 378 ],
    [ "VIVAMUS", 214 ]
  ],
  "cy": [
    [ "VELIT", 38 ],
    [ "BLANDIT", 117 ],
    [ "NONUMMY", 117 ],
    [ "VIVAMUS", 196 ]
  ],
  "shift": [
    [ "VELIT,BLANDIT,0", 0 ],
    [ "VELIT,NONUMMY,0", 0 ],
    [ "VIVAMUS,NONUMMY,0", 0 ],
    [ "VIVAMUS,BLANDIT,0", 0 ]
  ],
  "ratio": [
    [ "VELIT,BLANDIT,0", 1.0 ]
  ]
}

%%file sandbox_geo.json
{
  "width": 444,
  "height": 182,
  "cx": [
    [ "VELIT", 214 ],
    [ "BLANDIT", 58 ],
    [ "NONUMMY", 378 ],
    [ "VIVAMUS", 214 ]
  ],
  "cy": [
    [ "VELIT", 38 ],
    [ "BLANDIT", 87 ],
    [ "NONUMMY", 87 ],
    [ "VIVAMUS", 136 ]
  ],
  "shift": [
    [ "VELIT,BLANDIT,0", -30 ],
    [ "VELIT,NONUMMY,0", -30 ],
    [ "VIVAMUS,NONUMMY,0", 0 ],
    [ "VIVAMUS,BLANDIT,0", 0 ]
  ],
  "ratio": [
    [ "VELIT,BLANDIT,0", 0.5 ]
  ]
}

Overwriting sandbox_geo.json

%mocodo -i sandbox --colors brewer+1 --reuse_geo

%mocodo -i ccp --svg_to png pdf --select

display.IFrame("mocodo_notebook/ccp.pdf", width="100%", height="100%")

display.Image("ccp.png")

display.Image("../examples/svg2roughjs.png")

%%mocodo 
ENTITÉ 1_: at 1 1, at 1 2, at 1 3
DF, ?1 ENTITÉ 1_, XX ENTITÉ 2_
ENTITÉ 2_: at 2 1, at 2 2, at 2 3

%%mocodo -t
Entreprise: nom entreprise, adresse, téléphone
Proposer, 0N Entreprise, 11 Stage: date proposition
Stage: num. stage, sujet
Attribuer, 11 Étudiant, 01 Stage: date signature
Étudiant: num étudiant, nom
Soutenir, 01 Étudiant, 0N Date: note stage
Date: date

%mocodo -i sandbox --mld -t drain

%%mocodo -t
Bataille: nom bataille, lieu, date
Récolter, 0N Villageois, 0N Bataille, 11 Trophée
Villageois: nom villageois, adresse, fonction

Trophée: numéro, type, état

%mocodo -i sandbox --seed=3 --mld -t split arrange:wide

%%mocodo -t
Film: id. film, titre, durée
Projeter, 1N Salle, 1N Créneau, 1N Film: tarif
Salle: num. salle, capacité

Créneau: num. créneau, date, heure début

%mocodo -i sandbox --seed=8 --mld -t explode arrange:balanced

%%mocodo -t
Film: id. film, titre, durée
Concerner, 11 Projection, 1N Film
Projection: id. projection, tarif
Avoir lieu dans, 11 Projection, 1N Salle
Salle: num. salle, capacité

Avoir lieu pendant, 11 Projection, 1N Créneau

Créneau: num. créneau, date, heure début

%%mocodo -t
COMMANDE: num. commande, date, montant
LIGNE COM., 1N COMMANDE, 0N PRODUIT: quantité
PRODUIT: réf. produit, libellé, prix unitaire
DISPONIBILITÉ, 1N PRODUIT, 0N PAYS
PAYS: code pays, nom pays

%mocodo -i=sandbox --seed=1 --scale=0.9 --mld -t explode:arity=2 arrange:wide=9

%mocodo -i=sandbox --mld -t explode:arity=2.5 arrange:wide --seed=1

%mocodo -i=sandbox --mld -t explode:arity=2.5,weak arrange:wide --seed=1

%%mocodo -t --colors ocean
Chambre: num. chambre, tarif
Réservation, /1N Client, 1N Chambre, 0N Date: durée
Client: réf. client, nom client

Date: date

%mocodo -i sandbox --mld -t explode:weak arrange:wide=5 --seed 21

%%mocodo -t
Chambre: num. chambre, tarif
DF, _11 Réservation, 1N Chambre
Réservation: date, durée
DF, 11 Réservation, 1N Client
Client: réf. client, nom client

%%mocodo
Employé: employé
Travailler, 11 Département, 1N Employé
Département: département

%mocodo -i sandbox -t chen:layout=circo --defer

%%mocodo
Mer: mer
Recevoir, 01 Rivière, 1N Mer
Rivière: rivière

%mocodo -i sandbox -t chen:layout=circo --defer

%%mocodo
PROJET: projet
REQUÉRIR, 1N PROJET, 0N PIÈCE
PIÈCE: pièce
COMPOSER, 0N PIÈCE, 0N PIÈCE

%mocodo -i sandbox -t chen:layout=circo --defer

%%mocodo
Œuvre: œuvre
DF, 0N Œuvre, _11 Exemplaire
Exemplaire: exemplaire

%mocodo -i sandbox -t chen:layout=circo --defer

%%mocodo
Produit: produit
DF, _11 Ligne de commande, 0N Produit
Ligne de commande: _quantité
DF, _11 Ligne de commande, 1N Commande
Commande: commande

%mocodo -i sandbox -t chen:layout=circo,mindist=2,scale=0.6 --defer

%%mocodo -t
Employé: employé
Appliquer, 0N Employé, 1N Projet, 1N Compétence
Projet: projet

Compétence: compétence

%mocodo -i sandbox -t chen:layout=circo,mindist=1,scale=0.4 --defer

%%mocodo -t chen:layout=circo,mindist=1,scale=0.45 --defer
Ingénieur: ingénieur
Gérer, /1N Responsable, 1N Ingénieur, 1N Projet
Projet: projet

Responsable: responsable

%mocodo -i sandbox --mld --colors pond

%mocodo -i sandbox --mld -t create:cifs=light arrange:balanced --seed=3

%mocodo -i sandbox --mld -t explode:weak,arity=2 arrange:balanced --seed=14

%%mocodo -t chen:layout=circo,mindist=1,scale=0.45 --defer
Projet: projet
Affecter, /1N Site, /1N Projet, 0N Employé
Site: site

Employé: employé

%mocodo -i sandbox --select all -t mld:c --colors pond

%mocodo -i sandbox --select mcd mld -t mld:c create:cifs=light arrange:balanced --seed=3

%mocodo -i sandbox -t sql

CREATE TABLE Affecter (
  PRIMARY KEY (projet, employe),
  projet  VARCHAR(42) NOT NULL,
  employe VARCHAR(42) NOT NULL,
  site    VARCHAR(42) NOT NULL,
  UNIQUE (employe, site)
);

%%mocodo -t chen:layout=circo,mindist=1,scale=0.45 --defer
Technicien: technicien
Utiliser, /1N Technicien, /1N Carnet, /1N Projet
Projet: projet

Carnet: carnet

%mocodo -i sandbox --select all -t mld:c --colors pond

%mocodo -i sandbox --select mcd mld -t mld:c create:cifs=light arrange:balanced flip:d,v --seed=12

%mocodo -i sandbox -t sql

CREATE TABLE Utiliser (
  PRIMARY KEY (carnet, projet),
  carnet     VARCHAR(42) NOT NULL,
  projet     VARCHAR(42) NOT NULL,
  technicien VARCHAR(42) NOT NULL,
  UNIQUE (carnet, technicien),
  UNIQUE (projet, technicien)
);

%mocodo --help

usage: mocodo [--language CODE] [--params_path PATH] [--input PATH] [--help]
              [--version] [--restore] [--lib [URL]] [--output_dir PATH]
              [--encodings [STR ...]] [--svg_to {png,pdf} [{png,pdf} ...]]
              [--print_params] [--reuse_geo] [--uid_suffix INT]
              [--select [{all,mcd,rw,source,text,code,mocodo,cv,mld,ddl,sql} ...]]
              [--defer [STR ...]] [--mld] [--transform [STR ...]]
              [--seed [FLOAT]] [--title STR] [--df STR] [--card_format [STR]]
              [--fk_format [STR]] [--strengthen_card [STR]] [--flex FLOAT]
              [--colors STEM_OR_PATH] [--shapes STEM_OR_PATH] [--scale RATE]
              [--adjust_width RATE] [--detect_overlaps] [--no_assoc_ids]
              [--gutters STR [STR ...]]

NOM :
Mocodo - Un générateur de diagrammes entité-association.

DESCRIPTION :
Mocodo est un outil libre destiné à l'enseignement des bases de données relationnelles.
Il prend en entrée une description textuelle des entités et associations d'un diagramme
entité-association (MCD). Il produit en sortie un dessin vectoriel en SVG et un schéma
relationnel dans divers formats (SQL, LaTeX, Markdown, etc.).

NOTE :
Chacune des valeurs suivantes est :
- spécifiée explicitement par l'utilisateur comme option de ligne de commande ;
- sinon, récupérée depuis un fichier de chemin --params_path ;
- sinon, récupérée depuis un fichier nommé « params.json » dans le répertoire d'entrée ;
- sinon, calculée à partir d'une valeur par défaut, éventuellement dépendante de votre système.
    

OPTIONS SUR MOCODO LUI-MÊME :
  --language CODE       force la localisation des messages avec le code de
                        langue donné (par exemple, « fr », « en », ...)
                        (default: fr)
  --help                affiche ce message d'aide, puis termine
  --version             affiche le numéro de version, puis termine
  --restore             recrée une version vierge des fichiers « sandbox.mcd »
                        et « params.json » dans le répertoire d'entrée, puis
                        termine (default: False)

ENTRÉE/SORTIE :
  --params_path PATH    le chemin du fichier de paramètres. S'il est omis,
                        utilise « params.json » dans le répertoire d'entrée.
                        S'il n'existe pas, utilise les paramètres par défaut.
                        (default: params.json)
  --input PATH, -i PATH
                        le chemin du fichier d'entrée. Par défaut, les
                        fichiers de sortie seront générés dans le même
                        répertoire (default: /Users/aristide/Dropbox/Sites/moc
                        odo/doc/mocodo_notebook/sandbox.mcd)
  --lib [URL]           remote directory to use as fallback when the input
                        file is not found locally (default:
                        https://mocodo.net/web/lib)
  --output_dir PATH     le répertoire des fichiers de sortie (default:
                        mocodo_notebook)
  --encodings [STR ...]
                        un ou plusieurs encodages à essayer successivement
                        lors de la lecture du fichier d'entrée (default:
                        ['utf8', 'macroman'])
  --svg_to {png,pdf} [{png,pdf} ...]
                        génère une version PNG ou PDF de la sortie SVG
                        (requiert CairoSVG) (default: [])
  --print_params        affiche le contenu du fichier de paramètres, puis
                        termine (default: False)
  --reuse_geo           réutilise le fichier de géométrie de l'exécution
                        précédente (default: False)
  --uid_suffix INT      ajoute un discriminateur à un SVG interactif (default:
                        0)
  --select [{all,mcd,rw,source,text,code,mocodo,cv,mld,ddl,sql} ...]
                        sous Jupyter Notebook, spécifie explicitement les
                        catégories de résultats à afficher
  --defer [STR ...]     utilise un service web externe pour convertir les
                        résultats de la conversion dans les formats graphiques
                        donnés
  --mld                 alias de compatibilité ascendante pour « -t » (sans
                        arguments). Équivalent à « -t markdown » mais, sous
                        Jupyter Notebook, n'empêche pas le rendu du diagramme
                        conceptuel dans la sortie de la cellule (default:
                        False)
  --transform [STR ...], -t [STR ...]
                        crée une nouvelle version du MCD en appliquant
                        séquentiellement les opérations de réécriture données,
                        et/ou le convertit dans les formats ou langages
                        donnés. Sous Jupyter Notebook, « -T » remplace
                        respectivement la cellule courante par le résultat
                        textuel, ou le copie dans le presse-papier (pip3
                        install pyperclip)
  --seed [FLOAT]        valeur initiale pour le générateur de nombres
                        aléatoires (default: None)
  --title STR           nom du modèle, utilisé à divers endroits (système de
                        fichiers, base de données, etc.) (default: MCD)

ASPECT DE LA SORTIE GRAPHIQUE :
  --df STR              l'acronyme à entourer dans une dépendance
                        fonctionnelle (default: DF)
  --card_format [STR]   chaîne de formatage pour les cardinalités minimales et
                        maximales (default: {min_card},{max_card})
  --fk_format [STR]     chaîne de formatage pour les clés étrangères dans le
                        diagramme relationnel (default: #{label})
  --strengthen_card [STR]
                        chaîne pour les cardinalités relatives (default:
                        _1,1_)
  --flex FLOAT          incurve les pattes rectilignes dont les cardinalités
                        peuvent se chevaucher (default: 0.75)
  --colors STEM_OR_PATH
                        la palette de couleurs à utiliser lors de la
                        génération du dessin. Nom (sans extension) d'un
                        fichier situé dans le répertoire « colors », ou chemin
                        vers un fichier personnel (default: bw)
  --shapes STEM_OR_PATH
                        spécification des polices, dimensions, etc. Nom (sans
                        extension) d'un fichier situé dans le répertoire
                        « shapes », ou chemin vers un fichier personnel
                        (default: copperplate)
  --scale RATE          applique au diagramme le facteur de mise à l'échelle
                        donné (default: 1)
  --adjust_width RATE   applique à tous les textes calculés le facteur de mise
                        à l'échelle donné (default: 1)
  --detect_overlaps     lève une erreur quand des pattes horizontales ou
                        verticales se chevauchent (default: False)
  --no_assoc_ids        interdit l'utilisation d'identifiants dans les
                        associations (conformément au standard Merise)
                        (default: False)
  --gutters STR [STR ...]
                        définit la visibilité et le contenu des gouttières
                        latérales

VOIR AUSSI :
  Version en ligne      https://mocodo.net
  Code source           https://github.com/laowantong/mocodo
  Documentation         https://rawgit.com/laowantong/mocodo/master/doc/fr_refman.html
  Aide-mémoire pour -t  https://github.com/laowantong/mocodo/blob/master/doc/fr_cheat_sheet.md

LICENCE :               MIT

CONTACT :
  Auteur                Aristide Grange
  Adresse               Université de Lorraine
                        Laboratoire LCOMS - UFR MIM
                        3 rue Augustin Fresnel
                        57070 METZ Technopôle
                        France
  Courriel              <prénom.nom>@univ-lorraine.fr

# You may edit and run the following lines
import json, pathlib
params = """\
{
  "adjust_width": 1,
  "card_format": "{min_card},{max_card}",
  "colors": "bw",
  "detect_overlaps": false,
  "df": "DF",
  "encodings": [ "utf8", "macroman" ],
  "fk_format": "#{label}",
  "flex": 0.75,
  "language": "fr",
  "lib": "https://mocodo.net/web/lib",
  "mld": false,
  "no_assoc_ids": false,
  "output_dir": ".",
  "restore": false,
  "scale": 1,
  "seed": null,
  "shapes": "copperplate",
  "strengthen_card": "_1,1_",
  "svg_to": [],
  "title": "MCD",
  "uid_suffix": 0
}"""
try:
    json.loads(params)
except:
    raise RuntimeError("Invalid JSON. Check your syntax on https://jsonlint.com.")
pathlib.Path("./params.json").write_text(params, encoding="utf8");

display.Markdown("../fr_cheat_sheet.md")

{
      "order": 400,
      "comment": "Move all foreign keys constraints at the end of the document",
      "search": "(?sm)(CREATE TABLE ([^\n]+) \\(\n(?:[^\n]+\n)*)  (FOREIGN KEY[^\n]+),\n(.*)",
      "replace": "\\1\\4\nALTER TABLE \\2 ADD \\3;",
      "iterated": true
    },

display.SVG("../../mocodo/resources/relation_templates/_graph.svg")

display.Code("../../mocodo/resources/relation_templates/tex.yaml")

parent: 'latex'

display.Code("../../mocodo/resources/relation_templates/latex.yaml")

help_en: 'convert the conceptual model into a relational schema in LaTeX format'
help_fr: 'convertit le modèle conceptuel en un schéma relationnel au format LaTeX'
help_zh: '将概念模型转换为 LaTeX 格式的关系模式'
fr_examples:
  - order: 1
    example: 'latex'
    explanation: 'version de base'
  - order: 2
    example: 'latex:b'
    explanation: 'avec _boilerplate_'
  - order: 3
    example: 'latex:c'
    explanation: 'avec contraintes d''unicité et d''optionalité'
  - order: 4
    example: 'latex:e'
    explanation: 'avec explications'
  - order: 5
    example: 'latex:bce'
    explanation: 'avec _boilerplate_, contraintes et explications'
parent: 'latex-c'
add_unicity_constraints:
add_optionality_constraints:

display.Code("../../mocodo/resources/relation_templates/latex-c.yaml")

parent: 'html-c'
extension: 'tex'
highlight: 'latex'
column_separator: ', '
compose_relation: '  \item \relat{{{this_relation_name}}} ({columns})'
compose_relational_schema: '% Generated by Mocodo {version}\n\n\begin{{itemize}}\n{relations}\n\end{{itemize}}\n'
transform_relation:
  - order: 1000
    comment: 'Compose normal attributes'
    search: '<span class=''normal''>(.+?)</span>'
    replace: '\\attr{\1}'
  - order: 1100
    comment: 'Compose primary keys'
    search: '<span class=''primary''>(.+?)</span>'
    replace: '\\prim{\1}'
  - order: 1200
    comment: 'Compose foreign primary keys'
    search: '<span class=''foreign primary''>#(.+?)</span>'
    replace: '\\foreign{\\prim{\1}}'
  - order: 1300
    comment: 'Compose foreign attributes'
    search: '<span class=''foreign''>#(.+?)</span>'
    replace: '\\foreign{\1}'
  - order: 1400
    comment: 'Exponents'
    search: '(<sup>.*u)(\d)(.*</sup>)'
    replace: '\1_\2\3'
    iterated: true
  - order: 1500
    comment: 'Exponents'
    search: ' <sup>(.+?)</sup>'
    replace: '$^{\1}$'
  - order: 1600
    comment: 'Escape underlines'
    search: '_'
    replace: '\_'

%%mocodo -t sql
PERSONNE: id. personne [VARCHAR(8)], nom [VARCHAR(255)]

CREATE TABLE PERSONNE (
  PRIMARY KEY (id_personne),
  id_personne VARCHAR(8) NOT NULL,
  nom         VARCHAR(255)
);

%%file new_sql.yaml
parent: 'sql'
compose_primary_key: '{label} {datatype}\nPRIMARY KEY ({label})'
compose_primary_foreign_key: '{label} {datatype}\nPRIMARY KEY ({label})\nFOREIGN KEY ({label}) REFERENCES {outer_source} ({non_disambiguated_label})'

Overwriting new_sql.yaml

%mocodo -i sandbox -t relation:new_sql.yaml

CREATE TABLE PERSONNE (
  PRIMARY KEY (id_personne),
  id_personne VARCHAR(8),
  nom         VARCHAR(255)
);

%%file new_sql.yaml
parent: 'sql'
transform_relation:
  - order: 50
    comment: 'Suppress PK NN redundancy.'
    search: ' NOT NULL\nPRIMARY KEY'
    replace: '\nPRIMARY KEY'

Overwriting new_sql.yaml

%mocodo -i sandbox -t relation:new_sql.yaml

CREATE TABLE PERSONNE (
  PRIMARY KEY (id_personne),
  id_personne VARCHAR(8),
  nom         VARCHAR(255)
);

Totalité	Exclusion	Symboles	Exemple de population	Toute personne est :
oui	oui	`/XT\`	♂♂♂♂♂♂♂ ♀♀♀♀♀♀♀♀♀♀	- soit un homme - soit une femme
non	oui	`/X\`	♂♂♂♂♂♂♂♂ ♀♀♀♀♀♀ ○○○○	- soit un homme - soit une femme - soit aucun des deux
oui	non	`/T\`	♂♂♂♂♂♂ ♀♀♀♀♀♀♀♀ ⚥⚥⚥⚥	- soit un homme - soit une femme - soit les deux à la fois
non	non	`/\`	♂♂♂♂♂ ♀♀♀♀♀♀ ○○○○ ⚥⚥⚥⚥	- soit un homme - soit une femme - soit aucun des deux - soit les deux à la fois

Contrainte	niveau logique	niveau physique
non-optionalité	attribut!	`NOT NULL`
optionalité	attribut?	`NULL`
unicité	attribut $^{u1\ u2...}$	`UNIQUE`

	1	2	3	4	5	6	7	8	9	10	11	12	13
1	1	2	3
2		4	5, 6
3			7, 8, 9	10, 11, 12	13, 14, 15
4				16	17, 18, 19, 20	21, 22, 23, 24	26, 27, 28
5					25	29, 30	31, 32, 33, 34, 35	37, 38, 39, 40	43, 44, 45
6						36	41, 42	46, 47, 48	50, 51, 52, 53, 54	57, 58, 59, 60	65, 66
7							49	55, 56	61, 62, 63	67, 68, 69, 70	73, 74, 75, 76, 77	82, 83, 84	91
8								64	71, 72	78, 79, 80	85, 86, 87, 88	92, 93, 94, 95, 96
9									81	89, 90	97, 98, 99
10										100

Cardinalités	MCD Merise	ERD Chen
minimale	LH	LH
maximale	LH	LA

Sous-option	Description	Exemples	Explications
ast	crée l'arbre de syntaxe abstraite du texte source (pour le débogage)
chen	convertit le modèle conceptuel dans la notation de Chen	`chen`	sans attributs
		`chen:attrs`	avec attributs
		`chen:attrs --defer`	calcule le rendu graphique via un service web
		`chen:layout=circo,mindist=2,scale=0.6`	ajoute des options arbitraires pour Graphviz
crow	convertit le modèle conceptuel dans la notation crow's foot	`crow`	format Graphviz
		`crow --defer`	calcule le rendu graphique via un service web
		`crow:mmd`	format Mermaid
		`crow:mermaid`	idem
d2	convertit le modèle conceptuel en un schéma relationnel au format D2
data_dict	extrait tous les attributs du MCD dans une table	`data_dict`	tableau Markdown, trois colonnes
		`data_dict:label`	liste Markdown, une colonne
		`data_dict:label,type='Description'`	deux colonnes, un libellé personnalisé
		`data_dict:label='Attribut',type='Description'`	deux colonnes, deux libellés personnalisés
		data_dict:box='Entité ou<br>association',label,`type`=`'Type de données'`	mise en forme de certains libellés
		`data_dict:tsv`	tableau TSV, trois colonnes
		`data_dict:tsv,label`	liste des attributs séparés par des retours à la ligne
dbml	convertit le modèle conceptuel en un schéma relationnel au format DBML	`dbml`	version de base
		`dbml:b`	avec boilerplate
debug	liste des informations internes relatives à la conversion en schéma relationnel
dependencies	convertit le modèle conceptuel en un graphe de dépendances
diagram	convertit le modèle conceptuel en un diagramme relationnel au format Mocodo	`diagram`	version de base
		`diagram:c`	avec contraintes d'unicité et d'optionalité
html	convertit le modèle conceptuel en un schéma relationnel au format HTML	`html`	version de base
		`html:b`	avec boilerplate
		`html:c`	avec contraintes d'unicité et d'optionalité
		`html:e`	avec explications
		`html:bce`	avec boilerplate, contraintes et explications
latex	convertit le modèle conceptuel en un schéma relationnel au format LaTeX	`latex`	version de base
		`latex:b`	avec boilerplate
		`latex:c`	avec contraintes d'unicité et d'optionalité
		`latex:e`	avec explications
		`latex:bce`	avec boilerplate, contraintes et explications
markdown	convertit le modèle conceptuel en un schéma relationnel au format Markdown	`markdown`	version de base
		`markdown:c`	avec contraintes d'unicité et d'optionalité
		`markdown:e`	avec explications
		`markdown:ce`	avec contraintes et explications
mssql	convertit le modèle conceptuel en un modèle physique pour Microsoft SQL Server	`mssql`	version de base
		`mssql:b`	avec boilerplate
mysql	convertit le modèle conceptuel en un modèle physique pour MySQL	`mysql`	version de base
		`mysql:b`	avec boilerplate
oracle	convertit le modèle conceptuel en un modèle physique pour Oracle DB	`oracle`	version de base
		`oracle:b`	avec boilerplate
postgresql	convertit le modèle conceptuel en un modèle physique pour PostgreSQL	`postgresql`	version de base
		`postgresql:b`	avec boilerplate
relation	convertit le modèle conceptuel en schéma relationnel avec le gabarit donné	`relation:path/to/my_template.yaml`	chemin relatif, extension obligatoire
share	encode le MCD dans une URL pour Mocodo online	`qr --defer`	génère un QR code via un service web
sql	convertit le modèle conceptuel en un modèle physique pour SQL
sqlite	convertit le modèle conceptuel en un modèle physique pour SQLite	`sqlite`	version de base
		`sqlite:b`	avec boilerplate
text	convertit le modèle conceptuel en un schéma relationnel au format texte	`text`	version de base
		`text:c`	avec contraintes d'unicité et d'optionalité
		`html:e`	avec explications
		`html:ce`	avec contraintes et explications
uml	convertit le modèle conceptuel en diagramme de classes UML	`uml`	format PlantUML
		`uml:plantuml`	idem
		`uml --defer`	calcule le rendu graphique via un service web
		`uml:plantuml=-`	supprime les styles par défaut
		`uml:plantuml='skinparam backgroundColor yellow\nskinparam classAttributeFontName Arial\n'`	ajoute des styles personnalisés

Entité ou association	Libellé de l'attribut	Type
Client	Adresse	VARCHAR(255)
"	Nom	VARCHAR(255)
"	Prénom	VARCHAR(255)
"	Réf. client	VARCHAR(8)
Commande	Date	DATE
"	Montant	DECIMAL(10,2)
"	Num. commande	VARCHAR(8)
Inclure	Quantité	INTEGER
Produit	Libellé	VARCHAR(50)
"	Prix unitaire	DECIMAL(10,2)
"	Réf. produit	VARCHAR(8)

Sous-option	Description	Exemples	Explications
arrange	réarrange la disposition, soit par Branch & Bound, soit avec un algorithme génétique	`arrange`	B&B sans contraintes
		`arrange:timeout=60`	B&B limité à une minute
		`arrange:wide`	B&B privilégiant la largeur
		`arrange:current`	B&B sur la grille courante
		`arrange:balanced=0`	B&B sur la plus petite grille équilibrée
		`arrange:balanced=1`	B&B sur la seconde plus petite grille équilibrée
		`arrange:algo=ga`	algorithme génétique
ascii	réécrit les éléments donnés en ASCII	`ascii:roles,labels`	rôles, libellés des boîtes et des attributs en ASCII
camel	réécrit les éléments donnés en camelCase
capitalize	réécrit les éléments donnés en capitalisant la première lettre de chaque mot
casefold	réécrit les éléments donnés en minuscules, mais plus agressivement que « lower »
create	essaie d'inférer les types, entités, CIFs ou flèches de DF à partir des éléments existants	`guess:types`	deviner les types manquants
		`create:types=`	remplacer les types manquants par `[]`
		`create:types=TODO`	remplacer les types manquants par `[TODO]`
		`make:entities`	réparer l'oubli d'entités référencées dans des associations
		`create:dfs`	mettre des DF partout où c'est possible
		`add:df_arrows`	ajouter des flèches aux DF 11
		`add:cifs`	ajouter les CIF correspondant aux agrégats
		`add:cifs=light`	même chose en visualisation allégée
		`add:roles`	mettre comme rôles le nom des associations partout où c'est utile
delete	supprime les éléments donnés quand c'est possible	`empty`	ne garde que la structure et le nom des boîtes
		`delete:types,notes,attrs,cards`	idem
		`delete:cards`	remplace les cardinalités par `XX`
		`delete:card_prefixes`	supprime les marqueurs d'entités faibles et d'agrégats
		`delete:dfs`	supprime les entités indépendantes dont tous les attributs sont identifiants (et les DF qui les relient)
drain	déplace tout attribut d'association (1,1) vers l'entité appropriée
drown	remplace tous les noms d'éléments par un libellé générique numéroté
echo	réécrit le texte source tel quel
explode	décompose toute association n-aire (*,N) en n associations binaires	`explode arrange`	décomposer les non-DF ternaires et plus, puis réarranger
		`explode:arity=3 arrange`	idem
		`explode:weak arrange`	idem, avec création d'entités faibles
		`explode:arity=2.5 arrange`	étendre aux non-DF binaires porteuses d'attributs
		`explode:arity=2 arrange`	étendre à toutes les non-DF binaires
fix	essaie de corriger les erreurs courantes dans les éléments donnés	`fix:cards`	normaliser les cardinalités en 01, 11, 0N et 1N
flip	applique au diagramme une symétrie verticale, horizontale ou diagonale	`flip:v`	symétrie verticale
		`flip:h`	symétrie horizontale
		`flip:d`	symétrie selon la seconde diagonale
		`flip:vhd`	symétrie selon la première diagonale
		`flip:dhv`	idem (ordre indifférent)
grow	ajoute des entités et associations aléatoires (par défaut : 10 nouvelles associations)	`grow arrange`	ajouter des éléments avec les paramètres par défaut, puis réarranger
		`grow:n=10`	nombre total d'associations à ajouter (défaut)
		`grow:arity_1=2`	nombre d'associations réflexives (défaut)
		`grow:arity_3=2`	nombre d'associations ternaires (défaut)
		`grow:arity_4=0`	nombre d'associations quaternaires (défaut)
		`grow:doubles=1`	nombre d'associations liant deux mêmes entités (défaut)
		`grow:composite_ids=1`	nombre d'identifiants composites (défaut)
		`grow:ent_attrs=4`	nombre maximal d'attributs par entité (défaut)
		`grow:assoc_attrs=2`	nombre maximal d'attributs par association (défaut)
		`grow:'1-N'=3`	nombre d'associations `1-N` (défaut)
		`grow:'01-11'=1`	nombre d'associations `01-11` (défaut)
		`grow:'_11-*N'=1`	une entité faible (zéro par défaut)
		`grow:'/1N-*N'=1`	un agrégat (zéro par défaut)
		`grow:from_scratch arrange`	à partir d'un MCD vide
		`grow:grow:n=9,from_scratch,ent_attrs=3 obfuscate:labels=en4 create:roles lower:roles arrange`	créer un MCD d'entraînement à la conversion en relationnel
lower	réécrit les éléments donnés en minuscules	`lower:attrs,roles`	attributs et rôles en minuscules
pascal	rewrite the given elements in PascalCase
prefix	préfixe les éléments donnés avec la chaîne donnée	`prefix:roles='-'`	force les rôles à remplacer le nom des clés étrangères lors du passage au relationnel
randomize	garde la structure, mais randomise les éléments donnés quand c'est possible	`obfuscate`	libellés remplacés par du Lorem Ipsum
		`obfuscate:labels=lorem`	idem
		`obfuscate:labels=disparition`	idem, lexique du roman de Perec
		`obfuscate:labels=en4`	idem, mots anglais de 4 lettres (SFW)
		`obfuscate:attrs=fr,boxes=fr5`	idem, mots français de longueur quelconque pour les attributs, de 5 lettres pour les boîtes
		`randomize:types`	types randomisés avec les fréquences de `default_datatypes_fr.tsv`.
replace	réécrit les éléments donnés en appliquant le motif « recherche/remplacement » donné	`replace:boxes='DIRIGER/RÉPONDRE DE'`	renomme une boîte
		`replace:texts='personel/personnel'`	corrige une faute d'orthographe
		`replace:replace:texts='_/ '`	remplace les tirets bas par des espaces
		`replace:types='VARCHAR/VARCHAR2'`	modifie un nom de type
		`replace:cards=0N/1N`	remplace toutes les cardinalités 0N par 1N
		`replace:cards=1N//1N`	crée des agrégats un peu partout
		`replace:cards='0/X' replace:cards='11/X1' replace:cards='1N/XN'`	masque les cardinalités minimales
		`delete:card_prefixes replace:cards=11/_11`	ajoute des marqueurs d'entités faibles
slice	réécrit les éléments donnés en n'en gardant qu'une tranche donnée	`slice:boxes=5:10`	de l'indice 5 (inclus) à l'indice 10 (exclu)
		`slice:boxes=5:`	supprime les 5 premiers caractères
		`slice:boxes=:5`	ne garde que les 5 premiers caractères
		`slice:boxes=:-5`	supprime les 5 derniers caractères
		`slice:boxes=:`	équivalent de `echo`
		`slice:boxes=`	idem
		`slice:boxes`	idem
snake	réécrit les éléments donnés en snake_case
split	décompose toute association n-aire (*,1) en n-1 associations binaires	`split arrange`	décomposer, puis réarranger
suffix	suffixe les éléments donnés avec la chaîne donnée	`suffix:boxes=1`	Ajoute un suffixe numérique au nom des boîtes en vue de mettre un MCD et sa copie sur le même diagramme.
swapcase	réécrit les éléments donnés en inversant la casse de chaque lettre
title	réécrit les éléments donnés en mettant la première lettre de chaque mot en majuscule
truncate	tronque les éléments donnés à la longueur donnée (par défaut : 64)	`truncate:boxes=10`	tronque les noms des boîtes à 10 caractères
upper	réécrit les éléments donnés en majuscules	`upper:boxes`	noms des boîtes en majuscules

commande	tracé du MCD	résultat des réécritures	résultats des conversions
`mocodo`	initial	-	-
`mocodo -t` ou `mocodo --mld`	initial	-	MLD en Markdown
`mocodo -t rw1 rw2 ...`	final	final	-
`mocodo -t cv1 cv2 ...`	-	-	tous
`mocodo -t rw1 rw2 ... cv1 cv2 ...`	final	-	tous

enfant	parent	résultat
oui	non	insertion
oui	oui	si les clés sont parmi {`"order"`, `"comment"`} : suppression s'il y a plusieurs clés : mise à jour
non	oui	conservation

Mocodo

Introduction¶

Tracé du modèle conceptuel¶

Opérations de conversion¶

Opérations de réécriture¶

Installation et lancement du programme¶

Installation minimale¶

Installation complète (recommandé)¶

Utilisation par importation¶

Syntaxe de description d'un MCD¶

Notions élémentaires¶

Entités, associations, attributs, identifiants, cardinalités¶

Dépendances fonctionnelles entre entités¶

Associations réflexives¶

Identifiants composites¶

Flèches sur les pattes¶

Types de données¶

Tracé d'un MCD : principes¶

Le pont aux ânes du langage Mocodo¶

MCD sur plusieurs lignes¶

Mise en miroir¶

Insertion d'espacements¶

Réarrangement automatique¶

Extensions du modèle¶

Entité faible (ou identification relative)¶

Héritage (généralisation / spécialisation)¶

Contrainte inter-associations¶

Agrégat (ou pseudo-entité)¶

CIF à unicité complète¶

Identifiants explicites dans les associations¶

Conversion d'un MCD¶

Passage au relationnel¶

Niveau logique¶

Schéma relationnel¶

Diagramme relationnel¶

Niveau physique : DDL¶

SQL¶

Inférence de type¶

Dialectes de SQL¶

Notes sur les règles de passage¶

Génération de contraintes d'optionalité et d'unicité¶

Ajout manuel de contraintes d'optionalité et d'unicité¶

Gestion des entités faibles (identification relative)¶

Gestion de l'héritage¶

Gestion de l'agrégation¶

Ajustement des règles de passage¶

Supprimer ou maintenir une table facultative¶

Forcer une table pour éviter un champ optionnel¶

Préciser le rôle d'une clé étrangère¶

Orienter la migration dans les DF à double sens¶

Autres sorties relationnelles¶

Graphe des dépendances¶

Diagramme relationnel / DDL BDML¶

Diagramme relationnel D2¶

Autres conversions¶

Diagramme de classes UML¶

ERD avec la convention Look across¶

Notation de Chen¶

Notation crow's foot¶

Dictionnaire des données¶

URL de partage¶

Mocodo pour la pédagogie¶

Vue en extension¶

MCD interactif¶

Afficher des explications au survol¶

Dévoiler un MCD par étapes¶

Explications du passage au relationnel¶

MCD à compléter¶

Supprimer le marquage d'un identifiant¶

Masquer un couple de cardinalités¶

Masquer un attribut¶

Ne faire apparaître que le squelette du schéma conceptuel¶

Obfuscation d'un MCD donné¶

Croissance stochastique¶

Génération d'un QR code¶

Bibliothèque de MCD en ligne¶

Accès sous Mocodo online¶

Accès sous terminal ou Jupyter Notebook¶

Compléments sur l'aspect visuel¶

Styles¶

Annexe B : La commande `mocodo`¶

`mocodo --help`¶

L'option `--transform` et ses arguments¶