Avancé – Engine et son point d’accès le Cache

Depuis le temps que vous utilisez Engine, vous devez être impatient de voir comment il fonctionne. Alors allons y.

Engine

Le moteur de Generic System est représenté par Engine. Ce moteur peut être exécuté selon 2 modes :

persistant : exécute le système en enregistrant physiquement l’information.
embarqué : exécute le système en mémoire sans aucun mécanisme de persistance.

Pour démarrer le moteur en mode persistant, vous devez préciser le nom du moteur et le répertoire où seront stockées et récupérées les archives de Generic System.

// Create an engine named myDataBase and which is persistent
Engine engine = new Engine("myDataBase", System.getenv("HOME") + "/my_directory_path");

1 2	// Create an engine named myDataBase and which is persistent Engine engine = new Engine("myDataBase", System.getenv("HOME") + "/my_directory_path");

En mode embarqué, le moteur se démarre tout simplement ainsi :

// Create an engine which is in memory
Engine engine = new Engine();

1 2	// Create an engine which is in memory Engine engine = new Engine();

Dans la suite de cette article, nous considérerons une exécution sans mécanisme de persistance.
Mais vous ne pouvez pas utiliser Engine directement, vous devez passer par l’intermédiaire d’un Cache.

Cache

Utiliser un cache

Pourquoi ne pas travailler directement avec Engine ?

Tout d’abord, faisons un bref résumé du fonctionnement des bases de données relationnelles. En réalité, quand vous utilisez du SQL, vous ne faites pas vos requêtes directement mais vous passez par des transactions. Plus précisément, vous procédez ainsi :

vous démarrez une nouvelle transaction
puis vous exécutez vos différentes requêtes SQL
et finalement, il y a une étape de validation :
- s’il n’y a pas d’erreurs, la transaction est validée par le SGBD qui effectue un commit
- sinon, la transaction est annulée par le SGBD qui effectue un rollback

Ici, avec Generic System, c’est pratiquement la même chose :

vous démarrez un nouveau cache
puis vous exécutez vos différentes opérations
enfin, vous validez les modifications effectuées sur le cache en effectuant un flush (synchronisation) :
- s’il n’y a pas d’erreurs, les modifications sont validées et prises en compte
- sinon, les modifications effectuées sur le cache sont annulées

Vous devez être impatients de passer à la pratique alors allons-y.

// Create an in memory engine
Engine engine = new Engine();
// A cache is automatically created

// Create a type Vehicle
Generic vehicle = engine.addInstance("Vehicle");
// Add an attribute Power on Vehicle
Generic power = vehicle.addAttribute("Power");

// Create an instance of Vehicle
Generic myVehicle = vehicle.addInstance("myVehicle");
// Add a value for Power to myVehicle
myVehicle.addHolder(power, 213);

// Persist changes
engine.getCurrentCache().flush();

// Create an in memory engine

Engine engine = new Engine();

// A cache is automatically created

// Create a type Vehicle

Generic vehicle = engine.addInstance("Vehicle");

// Add an attribute Power on Vehicle

Generic power = vehicle.addAttribute("Power");

// Create an instance of Vehicle

Generic myVehicle = vehicle.addInstance("myVehicle");

// Add a value for Power to myVehicle

myVehicle.addHolder(power, 213);

// Persist changes

engine.getCurrentCache().flush();

Un point à noter : un cache est par utilisateur, chaque utilisateur a son propre cache pour travailler avec Engine.

Monter un cache sur un cache

Pour monter un cache sur un cache, il suffit d’appeler la méthode mountCache() sur le cache de votre choix.
Quel intérêt me direz-vous ? L’intérêt est de limiter les informations perdues en cas d’échec d’une opération. Seules les opérations réalisées sur le super cache seront abandonnées, celles du sous cache seront au contraire préservées. Mais voyons cela en exemple.

// Create an in memory engine
Engine engine = new Engine();
// A cache is automatically created

// Create a type Vehicle
Generic vehicle = engine.addInstance("Vehicle");

// Add a property Power on Vehicle
Generic power = vehicle.addAttribute("Power").enablePropertyConstraint();

// Mount a cache on the current cache
engine.getCurrentCache().mount();

// Create an instance of Vehicle
Generic myVehicle = vehicle.addInstance("myVehicle");

// Add a value for Power to myVehicle
myVehicle.addHolder(power, 213);
// myVehicle has one Power : 213

try {
	// Add another value for Power to myVehicle
	myVehicle.addHolder(power, 220);
} catch (RollbackException e) {
	assert e.getCause() instanceof PropertyConstraintViolationException;
	// A rollback is performed by Generic System
	// The value for Power and the instance of Vehicle are lost
	// but thanks to the cache we mount, the type Vehicle and the property Power are NOT lost
}

// Create an in memory engine

Engine engine = new Engine();

// A cache is automatically created

// Create a type Vehicle

Generic vehicle = engine.addInstance("Vehicle");

// Add a property Power on Vehicle

Generic power = vehicle.addAttribute("Power").enablePropertyConstraint();

// Mount a cache on the current cache

engine.getCurrentCache().mount();

// Create an instance of Vehicle

Generic myVehicle = vehicle.addInstance("myVehicle");

// Add a value for Power to myVehicle

myVehicle.addHolder(power, 213);

// myVehicle has one Power : 213

try {

// Add another value for Power to myVehicle

myVehicle.addHolder(power, 220);

} catch (RollbackException e) {

assert e.getCause() instanceof PropertyConstraintViolationException;

// A rollback is performed by Generic System

// The value for Power and the instance of Vehicle are lost

// but thanks to the cache we mount, the type Vehicle and the property Power are NOT lost

}

A noter que vous pouvez monter un cache sur un cache sans limitation.

En résumé

Engine représente le moteur de Generic System. Celui-ci peut être démarré en mode persistant ou en mode embarqué.
Un Cache est nécessaire pour travailler avec Generic System. C’est via ce cache que vous effectuerez toutes vos requêtes. Chaque utilisateur a son cache.
Vous pouvez montez un cache sur un autre et ce sans limitation.

Voyons ensemble dans le prochain article comment utiliser les contraintes de Generic System.

Articles qui pourraient vous intéresser :

Cache, Create, Engine, mount