cours GQL

README.md

@@ -1,3 +1,41 @@
 # Les graphes
 
 Cours sur la [théorie des graphes](docs/graphe.md)
+
+## Les bases de données orientée graphe
+
+- [Neo4J](docs/neo4j.md)
+- [Apache AGE™](https://age.apache.org/) pour PostgreSQL
+- [Nebula Graph](https://www.nebula-graph.io/)
+- [TigerGraph](https://www.tigergraph.com/)
+- [OrientDB](https://orientdb.dev/)
+- [Memgraph](https://memgraph.com/)
+- [Amazon Neptune](https://aws.amazon.com/fr/neptune/)
+- [Ultipa Graph](https://www.ultipa.com/product/ultipa-graph)
+- [GraphDB](https://graphdb.ontotext.com/)
+- [ArangoDB](https://arango.ai/products/arangodb/)
+
+## Les langages
+
+L’essor des bases de données graphe a conduit au développement de plusieurs langages dédiés, chacun répondant au besoin d’exprimer des requêtes sur des relations complexes.
+
+**Cypher** est le premier langage à avoir réellement popularisé cette approche. Conçu en 2011 par la société **Neo4j**, il introduit une syntaxe déclarative centrée sur les motifs, permettant de représenter visuellement les relations d’un graphe à l’aide d’un format proche du dessin de nœuds et d’arêtes. En 2015, Neo4j ouvre sa technologie via l’initiative openCypher, favorisant son adoption par d’autres systèmes et renforçant sa légitimité dans la communauté.
+
+La même année, **Oracle** présente **PGQL** (Property Graph Query Language), officialisé publiquement en 2015. PGQL vise à rapprocher le monde graphe de l’écosystème SQL, notamment en s’intégrant aux bases relationnelles compatibles avec les propriétés de graphe. Il propose une syntaxe inspirée de Cypher tout en se positionnant dans l’environnement Oracle.
+
+**GSQL**, développé par **TigerGraph** et documenté dès 2017, adopte une philosophie orientée performance et analytique avancée sur les graphes massifs. Contrairement à Cypher et PGQL, son modèle inclut naturellement des capacités de calcul distribué et de programmation de requêtes plus complexes, adaptées au traitement de graphes de très grande taille.
+
+Ces trois langages ont joué un rôle structurant dans la diffusion des systèmes graphe. Toutefois, leur coexistence créait un paysage fragmenté, dépendant des fournisseurs. Ce constat a conduit la communauté et les industriels à développer un standard unifié : GQL (Graph Query Language), premier langage de requête graphe reconnu comme norme internationale (ISO/IEC 39075 :2024).
+
+GQL vise à devenir le langage de référence pour les systèmes graphe, en fédérant les bonnes pratiques issues des langages existants.
+
+- [Cypher](docs/cypher.md)
+- [Oracle PGQL](https://pgql-lang.org/)
+- [TigerGraph GSQL](https://docs.tigergraph.com/gsql-ref/4.2/intro/)
+- [GQL](docs/gql.md)
+
+### Et le SQL ?
+
+**SQL/PGQ** (« Property Graph Queries » pour SQL), désigne une norme internationale qui étend le langage SQL pour lui permettre d’interroger des graphes de propriété. Cette norme publiée en 2023 fait partie de la série SQL (ISO/IEC 9075). Son objectif est de permettre à des bases de données relationnelles (ou hybrides) de définir un graphe de propriétés à partir de tables SQL, puis d’exécuter des requêtes de type graphe (par exemple, recherche de motifs, traversées) dans le contexte SQL.
+
+Elle introduit notamment des constructions comme : CREATE PROPERTY GRAPH, VERTEX TABLES, EDGE TABLES, et l’opérateur GRAPH_TABLE pour faire correspondre des motifs graphes dans une requête SQL.

docs/gql.md

@@ -0,0 +1,48 @@
+# Graph Query Language
+
+GQL (Graph Query Language) est un langage déclaratif standardisé par l’ISO/IEC 39075:2024 conçu spécifiquement pour interroger, manipuler et gérer des bases de données graphe fondées sur le modèle Property Graph.
+
+Il permet d’exprimer des requêtes basées sur les relations entre données ainsi que sur les propriétés attachées aux nœuds et aux arêtes.
+
+GQL offre des capacités :
+
+- de lecture : recherche de motifs de graphes, exploration de chemins
+- d’écriture : insertion, mise à jour et suppression de nœuds et relations
+- de définition du schéma : labels, contraintes, types de propriétés
+- de requêtes avancées sur les chemins (traversées, contraintes de longueur, etc.)
+
+
+## Création
+
+```gql
+INSERT (p:Person {name: "John", age: 28});
+```
+
+```gql
+MATCH (a:Person {name: "Alice"}), (b:Person {name: "Bob"})
+INSERT (a)-[:KNOWS]->(b);
+```
+
+## Sélection
+
+Retourne le nom et l'âge des personnes.
+
+```gql
+MATCH (p:Person)
+RETURN p.name, p.age;
+```
+
+Avec un filtre sur l'âge
+
+```gql
+MATCH (p:Person)
+WHERE p.age > 30
+RETURN p.name;
+```
+
+Retourne les relations
+
+```gql
+MATCH (a:Person)-[:KNOWS]->(b:Person)
+RETURN a.name, b.name;
+```

docs/neo4j.md

@@ -0,0 +1,58 @@
+# Neo4J
+
+Neo4j est une base de données orientée graphes (Graph Database).
+Contrairement aux bases relationnelles (comme PostgreSQL ou MySQL), qui organisent les données en tables et relations, Neo4j stocke les informations sous forme de nœuds (nodes) et de relations (relationships) — ce qui permet de modéliser naturellement les connexions entre entités.
+
+## Noeuds
+
+Les noeuds sont les entités principales du graphe.
+
+```
+(:Person { name: "Sigourney", age: 30 })
+(:Film { title: "Alien", year: 1979 })
+```
+
+Chaque nœud peut avoir :
+- une ou plusieurs étiquettes (labels) (:Person, :Film, etc.)
+- des propriétés sous forme de paires clé/valeur.
+
+## Relations
+
+Les relations relient deux nœuds et ont elles aussi un type et des propriétés :
+
+```cypher
+(:Person {name: "Sigourney"})-[:JOUE { role: "Ellen" }]->(:Film {title: "Alien"})
+```
+
+JOUE est le type de relation.
+
+{ role: "Ellen" } est une propriété de cette relation.
+
+Les relations sont orientées : elles vont d’un nœud source vers un nœud cible `-[]->`.
+
+## Le langage Cypher
+
+Cypher est le langage de requête de Neo4j, inspiré de SQL mais adapté aux graphes.
+
+### Trouver un noeud
+
+```cypher
+MATCH (p:Person { name: "Sigourney" })
+RETURN p;
+```
+
+### Trouver des relations directes
+
+```cypher
+MATCH (a:Person)-[:KNOWS]->(b:Person)
+RETURN a.name, b.name;
+```
+
+### Trouver des chemins
+
+```cypher
+MATCH path = (a:Person {name:"Alice"})-[:KNOWS*1..3]->(b:Person)
+RETURN path;
+```
+
+[:KNOWS*1..3] cherche des chemins de 1 à 3 sauts.