Une base NoSQL: Cassandra

Le modèle de données

Présentation

Pour bien comprendre le modèle de données utilisé par Cassandra il est important de définir un certain nombre de termes utilisés par la suite. Tout d'abord le Keyspace s'apparente à un namespace c'est en général le nom donné à votre application. Ensuite, les Column Familly est ce que ressemble le plus aux tables en SQL. Une Key est une clé qui va représenter une ligne. Les Column représente une valeur, elles disposent de 3 champs: son nom, sa valeur et un timestamp représentant la date à laquelle a été inséré cette valeur. Et pour finir, les Super Column qui contiennent une liste de colonnes.

Afin de comprendre au mieux la représentation j'utiliserai dans la suite des illustrations avec des exemples concrèts d'insertion d'information en base. Pour cela je me baserai sur une implémentation en JAVA non complète mais qui permet d'avoir une bonne vision du modèle de représentation.

Les colonnes

Les données sont représentées en colonne comme le montre l'image ci-dessous. Dans une colonne on trouve 3 champs, son nom, sa valeur associée et un entier représenter la date à laquelle la donnée a été inséré dans la colonne.

Voici une simple implémentation en JAVA d'une colonne qui va nous servir pour la suite des explications. Comme vous pouvez le constater on retrouve bien les 3 champs composant une colonne.

    public class Column {

      private String name;
      private String value;
      private Long timestamp;

      public Column(String name, String value) {
      	this.name = name;
      	this.value = value;
      }
    }
    

Les super colonnes

Les super colonnes sont une liste de colonne, si on veut faire le parallèle avec une base SQL cela représente une ligne. On retrouve cette correspondance clé-valeur, la clé permet d'identifier la super colonne tandis que la valeur est la liste des colonnes qui la compose.

Pour son implémentation JAVA notre super colonne est composée d'un nom correspondant à sa clé et une Map de colonnes qui sont elle-même identifiées par une clé correspondant au nom de la colonne.

    public class SuperColumn {

    	private String name;
    	private Map<String, Column> value;

    	public void setName(String bs) {
    		this.name = bs;
    	}
    	public void setValue(String name, Column value) {
    		this.value.put(name, value);
    	}
    }
    

Pour l'insertion de donnée en utilisant ce modèle on doit tout d'abord initialiser notre super colonne et lui attribuer une clé, nous pouvons ensuite commencer à insérer des données.

    SuperColumn sc = new SuperColumn();
    sc.setName("person1");
    sc.put("firstname", new Column("firstname", "John"));
    sc.put("familyname", new Column("familyname", "Calagan"));

    sc = new SuperColumn();
    sc.setName("person2");
    sc.put("firstname", new Column("firstname", "George"));
    sc.put("familyname", new Column("familyname", "Truffe"));
    

Voila comment les données sont organisées en gardant à l'esprit la notion de clé-valeur. D'après notre exemple nous pouvons voir que nous avons crée 2 super colonnes (person1 et person2) disposant chacune de 2 colonnes qui décrivent le firstname et le familyname de chaque personne.

Les familles de colonnes

Les familles de colonnes sont ce qui ressemble le plus aux tables en SQL. A l'image des super colonnes elles disposent elles aussi d'une Map mais cette fois-ci de super colonnes et non pas de colonnes.

On retrouve le même mécanisme que les super colonnes, c'est uniquement la Map qui change pour y insérer les super colonnes.

    public class ColumnFamily {

    	private String name;
    	private Map<String, SuperColumn> value;
    	
    	public void setName(String bs) {
    		this.name = bs;
    	}
    	public void setValue(String name, SuperColumn value) {
    		this.value.put(name, value);
    	}
    }
		

Pour l'insertion de donnée en utilisant ce modèle, il faut tout d'abord instancier une famille de colonne (ColumnFamily) et lui attribuer un nom qui sera sa clé (dans cet exemple "AddressBook"). On peut ensuite créer autant de super colonne que l'on souhaite et l'ajouter à notre famille de colonne.

    ColumnFamily cf = new ColumnFamily();
    cf.setName("AddressBook");

    SuperColumn row= new SuperColumn();
    row.setName("person1");
    row.put("firstname", new Column("firstname", "John"));
    row.put("familyname", new Column("familyname", "Calagan"));
    cf.setValue("person1", row);

    row = new SuperColumn();
    row.setName("person2");
    row.put("firstname", new Column("firstname", "George"));
    row.put("familyname", new Column("familyname", "Truffe"));
    cf.setValue("person2", row);
		

Voila comment sont organisées les données une fois insérées dans la famille de colonnes.

Les super familles de colonnes

Les super familles de colonnes permettent d'ajouter un niveau d'imbrication supplémentaire. Cela permet de représenter l'ensemble d'une base de données. Dans ce cas, au lieu d'avoir une map de super colonne comme précédemment on dispose d'une map de famille de colonne.

    public class SuperColumnFamily {
    	String name;
      <Map<String, Map<String, SuperColumn>> value;
    }