J’ai découvert, il y a peu, que Microsoft avait publié une version preview de son moteur de graphe : Graph Engine autrefois connu sous le nom de Trinity.

Ayant déjà effectué quelques recherches sur les bases orientées graphe comme Neo4j, j’ai été intéressé de voir les solutions proposées par Microsoft dans ce domaine.

Qu’est ce que c’est ?

La première chose qui m’a marqué sur GraphEngine c’est qu’il ne fonctionne que sur des données stockées en RAM. En effet, toutes les données sont d’abord chargées sur un cluster de machines sous la forme de clé/valeur afin d’avoir un accès et un temps de réponse optimisé. GraphEngine a été développé afin d’avoir des temps de réponses très bons même sur une très grande quantité de données.

Autre chose à savoir sur GE, c’est qu’il utilise le langage TSL (Trinity Specification Language) afin de décrire les données à charger, de modéliser le protocole d’échanges de messages client/serveur et de définir les règles de calcul du moteur. Le site officiel donne des exemples d’utilisation de langage ici.

Quand utiliser une base orientée graphe ?

Une base de données orientée graphe permet de traiter un grand nombre d’objets liés entre eux avec plusieurs jointures de manière facile et efficace. Alors qu’avec une base de données relationnelle il aurait fallu créer un modèle avec des tables de jointures et des indexes afin d’accélérer la lecture, ici on ne créé pas de modèle juste des entités et des liens entre celles-ci.

Prenons l’exemple d’un réseau social. Si l’on souhaite connaître les personnes en lien avec une autre, il suffit de partir du nœud représentant la personne source et de parcourir tous les liens de type “en lien avec” à partir de ce nœud. Si l’on souhaite créer un nouveau type de lien, il suffit de rajouter les nœuds voulus.

Là où une base orientée graphe n’est pas performante quand on souhaite remonter tous les nœuds de type T, la base relationnelle, de par sa nature, est, quant à elle, très performante.

Je pense qu’il faut donc choisir ce type de base de données dans le cas où notre modèle peut contenir de nombreux liens avec beaucoup de données et que l’on souhaite avoir les données en temps réel et non passer par des tables pré- calculées.

Petit exemple

Avant de commencer, voici les pré-requis à l’utilisation de GraphEngine:

• Windows Server 2008 R2, Windows Server 2012, Windows 7, or Windows 8
• Visual Studio 2012 ou 2013
• PowerShell 3.0 (ou plus)
• L’extension pour Visual Studio dispo à cette adresse : https://visualstudiogallery.msdn.microsoft.com/12835dd2-2d0e-4b8e-9e7e-9f505bb909b8

Création du projet

Grâce à l’extension installée, un nouveau type de projet vient d’apparaître :

Description des données

La première chose à faire lorsque l’on souhaite importer des données dans GE, c’est de décrire les données qui seront manipulées. C’est là que nous allons utiliser le langage TSL. Prenons l’exemple d’une table contenant les données suivantes :

Nous allons donc maintenant décrire ces données dans un fichier Person.tsl. dans lequel nous allons y mettre le code suivant :

cell struct Player
{
    string Name;
    int Age;
    long Nationality;
}

cell struct Nationality
{
    string Name;
}

Le mot clé “cell” permet de définir s’il s’agit d’une donnée avec laquelle on souhaite interagir (charger, modifier, sauvegarder…). Chaque cell contient une propriété cellId permettant d’identifier, de manière unique, un noeud.
Le mot clé “struct” sert, quant à lui, à définir un regroupement de propriétés comme on le ferait en C/C++ ou C#. Pas de complexité donc de ce côté-là.

Manipulation des données

Pour maintenant manipuler les données, nous allons ajouter un nouveau projet de type Application à notre solution :

Il faut référencer le projet précédent afin d’accéder à la description de nos données.

Ajoutons une classe PersonEngine et mettons-y le code permettant d’instancier nos objets et faisons une requête Linq afin de rechercher dans les données:

using Trinity;
using Trinity.Storage;
using Trinity.Extension;
using System;
using System.Linq;

namespace PlayersEngine
{
    class PlayersEngine
    {
        public static void Main(string[] args)
        {
            TrinityConfig.CurrentRunningMode = RunningMode.Embedded;

            var France = new Nationality("France");

            var Italie = new Nationality("Italie");

            var Totti = new Player(Name: "Totti", Age: 54, Nationality: Italie.CellID);

            var Durant = new Player(Name: "Durant", Age: 23, Nationality: France.CellID);

            var Dupond = new Player(Name: "Dupond", Age: 32, Nationality: France.CellID);

            Global.LocalStorage.SaveNationality(France);
            Global.LocalStorage.SaveNationality(Italie);
            Global.LocalStorage.SavePlayer(Totti);
            Global.LocalStorage.SavePlayer(Durant);
            Global.LocalStorage.SavePlayer(Dupond);

            var query = (from player in Global.LocalStorage.Player_Accessor_Selector()
                    where player.Nationality.Equals(Italie.CellID)
                    select new { player.Name } );

            foreach (var p in query.ToList())
            {
                Console.WriteLine(p.Name);
            }

            Console.WriteLine("Fin");
            Console.ReadKey();
        }
    }
}

Comme on peut le voir, je créé ici les données de manière statique. Il s’agit bien évidemment d’une solution simpliste. Je présenterai, dans un prochain article, un exemple plus complet où l’import des données sera traité de manière plus approfondie.

On peut aussi remarquer que le lien entre les objets se fait grâce à une propriété CellId dont la valeur est définie lors de l’instanciation de chaque objet.

Résultat :

Pour la partie requêtage, GraphEngine permet d’utiliser Linq afin de manipuler les données. On ne perd donc pas ses habitude contrairement à d’autres bases orientées graphe qui utilisent un langage spécifique.

Malheureusement, je n’ai pas trouvé dans l’API une manière de requêter le graphe comme on le fait avec Cypher sur une base du type Neo4j. J’ai donc l’impression qu’il s’agit, pour l’instant, uniquement d’une base type clé/valeur sans la couche graphe, ce qui est un peu dommage au vu du nom de la techno. Bien sûr, il ne s’agit que d’une version Preview, on peut donc imaginer que l’API va s’enrichir avec le temps et avec les prochaines versions.

Conclusion

Dans cet article, on a pu voir les bases de ce moteur. Il reste encore beaucoup de choses à découvrir, je vais continuer à m’y intéresser de plus près et ferai de nouveaux articles plus approfondis afin de voir de quoi est capable GraphEngine. Pour les impatients, je vous conseille d’aller sur le site officiel : graphengine.io