I liked very much the Moose ideas and API and wanted to use it, that’s why I wrote Coat: a basic rewrite of Moose goodness in pure Perl 5.

Later on, the Moose team decided to write its own rewrite of Moose in pure Perl 5, it’s called Mouse (I was a bit surprised at first they didn’t contact me, but I realized later than it was merely a question of communication, I clearly suck at marketing ;)

Anyways, I also used Coat to write Coat::Persistent, a tiny ORM inspired by Ruby’s ActiveRecord API. So even if Mouse kind of replace Coat, it still has a reason to live.

More recently, I gave a couple of talks for a client about modern Perl programming (and more precisely the Coat::Persistent ORM) and there was a very good feedback.

A couple of feature requests were made, and I reported them as issues on my GitHub project pages.

Some of them are already closed in the GitHub repo. This will certainly lead to a new release of Coat very soon. Yeepee.

Related posts:

1. Migrating homebrew Rails blog-entries to WordPress with Perl I was facing a challenge recently at work: migrating a...
2. Perl Dancer meeting #1 As explained on the mailing list, we had the idea...

Voila une bonne chose de faîte, c’est en quelque sorte une manière de boucler la présentation des Journées Perl 2009 et le problème technique qui s’était posé.

Cette version propose les changements suivants :

• Mention de la licence “perl” dans Makefile.PL (bug #46912)
• Ajout d’un fichier CHANGES (bug #46913)
• Support de l’option store_as pour les attributs persistants
• Module Coat::Persistent::Types::MySQL qui fournit les types et les coercitions correspondantes pour les types de données MySQL Date et DateTime

Voici un petit exemple de code qui montre les possibilités de cette nouvelle version :

Reprenons notre chameau utilisé pour illustrer la présentation, nous allons lui ajouter une date de création, que l’on souhaitera manipuler sous forme de timestamp dans le code de l’application, et stocker sous forme de MySQL DateTime dans la base.

package Camel;
use Coat;
use Coat::Persistent;
use Coat::Persistent::Types::MySQL;

has_p name => (isa => 'Str');
has_p age => (age => 'Int');

has_p created_at => (
  is => 'rw',
  isa => 'Int',
  store_as => 'MySQL:DateTime',
);

Jouons maintenant avec cette classe et observons le comportement de l’accesseur created_at :

Perl> use Camel
Perl> my $c = Camel->find(3)
$Camel1 = Camel=HASH(0x9967028);

Perl> $c->created_at(time)
1245413521

Perl> $c->save
3

Maintenant regardons le contenu de la base de données pour le camel d’id 3

sqlite> select created_at from camel where id = 3;
2009-06-19 14:12:01

Au passage, on notera un effet de bord assez apréciable de cette double coercition entre type réel et type de stockage : on peut très bien assigner une valeur formattée à created_at au lieu d’un timestamp. La coercition interviendra dans l’autre sens, et notre objet aura toujours un timestamp :

Perl> $c->created_at('1979-11-20 20:20:00')
311973600

Mission complete j’ai envie de dire ;)

Update: Suite à la remarque de oz dans les commentaires, j’ai publié la version 0.210 qui propose un module Coat::Persistent::Types afin de définir tout plein de types de Date et les coercitions qui vont bien

Related posts:

1. De la bonne façon de manipuler le temps avec Coat::Persistent Soit la situation suivante : vous avez une classe qui...
2. Coat Persistent La famille de Coat s’agrandit, voici un premier essai de...
3. Nouvelle version de Coat::Persistent : 0.104 En travaillant sur mes slides pour FPW 2009, je me...

Comment faire pour pouvoir utiliser côté Perl, un timestamp et stocker en base une date formatée pour la base de données ?

C’est le problème que je me suis posé récemment avec Coat::Persistent. Plus exactement, ce problème s’est posé presque de lui-même pendant ma présentation aux Journées Perl 2009, suite à une question du public.

En fait, je n’avais que la moitié de la solution, et depuis, je me suis pris d’un défi pour résoudre correctement ce problème avec Coat::Persistent.

Je vous propose de voir ensemble comment faire.

Objectifs

• Utiliser le champ date comme un entier dans le code Perl
• Ne pas avoir a se soucier de son format de stockage

Dans sa version actuelle, Coat::Persistent ne fait pas de différence entre la valeur assignée a un attribut d’un objet et celle stockée en base. Il nous est donc impossible de réaliser notre objectif de manière élégante sans modifier Coat::Persistent.

La bonne façon de permettre cette fonctionnalité serait donc de dire qu’un attribut peut avoir un type propre (isa) et un type de stockage. On aurait donc quelquechose comme ça :

has_p created_at => (
    is => 'rw',
    isa => 'Int',
    store_as => 'DateTime',
);

Un attribut ainsi déclaré serait donc conscient que sa valeur mémoire (celle de l’objet instancié) est différente de celle stockée en base. Toute la logique de conversion qu’elle soit dans un sens ou dans l’autre serait donc gérée par Coat::Persistent, et non pas par l’utilisateur.

Tout cela est réalisable en utilisant une coercition bi-directionnelle. Derrière ce mot barbare se cache un principe finalement assez simple : une valeur x doit être convertible d’un type A vers un type B, et reciproquement.

Coat permet de définir des coeriction via le mécanisme de types utilisateurs. La subtilité est donc de :

• Avoir une coercition de définie pour pouvoir convertir une valeur du type de l’attribut vers une valeur du type de stockage (qui interviendra avant un save)
• Avoir une coercition de définie pour pouvoir convertir une valeur du type de stockage vers une valeur du type de l’attribut (qui interviendra après un find)

Voyons maintenant comment écrire ces types et leur règle de coercition respectives pour le coupe Int,DateTime

Nous allons commencer par définir le type DateTime que nous voulons utiliser pour représenter le format de stockage des date dans une table MySQL (YYYY-MM-DD HH:MM:SS).

subtype 'DateTime'
    => as 'Str'
    => where { /^\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d$/ };

Un attribut de type DateTime est donc un attribut de type Str et dont la valeur respecte la regexp fournie.
Maintenant il nous faut écire la règle de conversion d’une valeur Int vers une valeur DateTime :

coerce 'DateTime'
    => from 'Int'
    => via {
        my ($sec, $min, $hour, $day, $mon, $year) =
            localtime($_);
        $year += 1900;
        $mon++;
        $day = sprintf('%02d', $day);
        $mon = sprintf('%02d', $mon);
        $hour = sprintf('%02d', $hour);
        $min = sprintf('%02d', $min);
        $sec = sprintf('%02d', $sec);
        return "$year-$mon-$day $hour:$min:$sec";
    };

Le type Int est un type standard, nous n’avons donc pas besoin de le définir. Nous avons seulement besoin de mettre en place une coercition depuis le type DateTime vers le type Int :

coerce 'Int'
    => from 'DateTime'
    => via {
        my ($year, $mon, $day, $hour, $min, $sec) =
             /^(\d{4})-(\d\d)-(\d\d) (\d\d):(\d\d):(\d\d)$/;
        $year -= 1900;
        $mon--;
        return mktime(
            int($sec), int($min), int($hour),
            $day, $mon, $year);
    };

Bien, tout ce code est intéressant, mais est-ce réellement à l’utilisateur de l’ORM de le définir ? Je ne crois pas, sa place serait idéale dans un jeu de types prédéfinis.

Pourquoi pas proposer une module Coat::Persistent::Types avec tous les types nécessaires ? Cela me semble bien plus élégant.

Imaginons donc que les types et coercitions définis ci-dessus seraient présents dans, Coat::Persistent::Types::MySQL. Le type pourrait même se nommer 'MySQL:DateTime' au lieu de 'DateTime'.

L’utilisateur pourrait donc faire tout simplement :

package Stuff;
use Coat;
use Coat::Persistent;
use Coat::Persistent::Types::MySQL;

has_p created_at => (
    isa => 'Int',
    store_as => 'MySQL:DateTime',
);

Et le tour serait joué !

Il ne resterait alors qu’une seule chose à faire : patcher la mécanique de sauvegarde de Coat::Persistent pour que les valeurs utilisées dans le SQL puissent être converties si nécessaire.

Cela peut se faire très simplement en introduisant la notion de valeur de stockage. Cette valeur serait égale à celle de l’attribut si aucun store_as n’est défini, elle serait égale à la coercition adéquate sinon.

Bien, maintenant que ce problème est résolu, il ne me reste plus qu’à patcher Coat::Persistent et à publier une nouvelle version avec toutes ces bonnes calories intellectuelles…

Related posts:

1. Publication de Coat::Persistent 0.200 Je viens d’uploader Coat::Persistent sur CPAN. Voila une bonne chose...
2. Coat Persistent La famille de Coat s’agrandit, voici un premier essai de...
3. Nouvelle fonctionnalité pour Coat::Persistent : cache Une nouvelle fonctionnalité va faire son apparition d’ici peu de...

A noter au passage que d’après ce que m’a dit Sébastien Déseille – vice-président des Mongueurs et organisateur de l’événement – ces salles sont grâcieusement prétées à l’association, ce qui a permi de rendre cette conférence entièrement gratuite. Une belle initiative qui méritait d’être salluée.

J’ai d’abord assisté à la présentation de Philippe « BooK » Bruhat sur les opérateurs secrets de Perl : il s’agit d’un cocktail explosif de Perl, d’ASCII Art, de Star Wars et d’humour – avec un zeste de Goatse.

Finalement, BooK nous a montré comment on peut combiner différents opérateurs entre eux et avec les jeux de précédence, obtenir de nouveaux opérateurs, ou même des constantes.

L’immagination semble être la seule limite à cette véritable chasse au trésor. Quelques exemples pris sur le vif :

• Bang Bang : !! $anyvalue : retourne l’expression booléenne de $anyvalue
• Inch Worm : ~~ @anylist : retourne l’expression scalaire de @anylist
• Goatse : $count =()= $regexp : Retounre le nombre de match dans la $regexp sur $_

Je vous renvoie aux slides de BooK Pour plus de détails (et surtout pour les illustrations croustillantes).

Après la pause déjeuner, c’était au tour de Coat d’être présenté par SébastienDéseille.

Pour sa présentation, Sébastien s’est donné comme défi de reprendre la série d’articles publiée sur ce blog et dédiée à l’apprentissage de Moose afin de l’adapter avec Coat. On a ainsi pu découvrir comment faire de l’objet avec Coat et avoir les bases nécessaires à l’apprentissage de Coat::Persistent.

J’ai donc ensuite présenté le petit frère Coat::Persistent dont voici les slides :

La vidéo de la présentation sera probablement en ligne prochainement, certainement par ici.

Dans l’ensemble la présentation s’est bien déroulée (du moins je l’espère :-).

J’aurais juste dû choisir un autre exemple pour la coercition car le mien ne correspondait pas à quelquechose de convenable en pratique. Lorsqu’on s’en rend compte en pleine présentation suite à une question du public ce n’est pas très agréable.

Du côté des bonnes surprises, Philippe Bruhat m’a parlé de son module Test::Database qui m’à tout l’air d’être le module manquant du jeu de test de Coat::Persistent : il permet de d’obtenir un pool de $dbh disponibles sur la machine courante, pour une série de drivers. C’est tout simplement l’outil révé pour écrire le jeu de tests unitaires de Coat::Persistent (pour l’instant je suis contraint à faire tourner les tests uniquement avec le driver CSV). A suivre donc.

Related posts:

1. Coat Persistent La famille de Coat s’agrandit, voici un premier essai de...
2. Publication de Coat::Persistent 0.200 Je viens d’uploader Coat::Persistent sur CPAN. Voila une bonne chose...
3. Nouvelle fonctionnalité pour Coat::Persistent : cache Une nouvelle fonctionnalité va faire son apparition d’ici peu de...

Du coup, j’en ai profité pour modifier subtilement la gestion des drivers DBI. En effet, comme me l’avait fait remarquer Sébastien Déseille dans un échange de mails (Sébastien présentera le module Coat), uniquement les drivers MySQL et CSV étaient supportés alors qu’un simple patch d’une ligne permettait de faire fonctionner C::P avec SQLite.

Il est vrai qu’intrinsèquement, rien n’interdit d’autres drivers : le SQL généré est standard puisque produit par SQL::Abstract, et les séquences sont gérées par DBIx::Sequence et ne reposent donc pas sur le SGBD.

La seule difficulté était donc de maintenir une liste de drivers de la bonne façon. J’ai opté pour un compromis :

• D’une part, plutôt que de lister en dur dans le code de C::P la liste de tous les drivers DBI potentiellement compatibles, j’ai préféré ne lister par défaut que ceux pour lesquels je sais que tout fonctionne bien
• D’autre part, le module propose une interface pour laisser le programme appelant modifier ce registre de drivers, il peut ainsi – sans patcher C::P – modifier ou ajouter les drivers connus

La documentation a été mise à jour et montre l’usage des nouvelles méthodes drivers(), get_driver() et add_driver().

Related posts:

1. Nouvelle version de Coat : 0.333 disponible sur le CPAN J’ai publié une nouvelle version de Coat – la meta-classe...
2. Nouvelle fonctionnalité pour Coat::Persistent : cache Une nouvelle fonctionnalité va faire son apparition d’ici peu de...
3. Coat::Persistent aux Journées Perl 2009 Je reviens à l’instant des Journées Perl 2009. La conférence...

Rached me l’a fournie en fin de journée au boulot : il a mis le doigt sur une brêche dans les perfs de Coat lorsque l’on utilise la coercition (coerce dans Coat). La chute de perfs était due à une utilisation de Carp::confess, catchée par un bloc eval, ce qui est très mal, car à chaque fois que Perl utilise confess, il va chercher toutes les infos de la pile d’appel, ce qui est couteux.

Le mécanisme de coercition de Coat utilise désormais une méthode silencieuse qui retourne un booléen au lieu de faire un confess, on évite ainsi de ruiner les performances.

Outre ce correctif important, la version 0.334 apporte le support de BUILDARGS qui vous permet de construire vos arguments lors de l’instanciation d’objets.

Je viens d’uploader le package sur CPAN, donc d’ici quelques heures ça devrait être dispo ici.

EDIT : 25 Nov. 2008, 10:07

Après quelques retours sur ce billet je m’aperçois que je parle trop vite et que certains ont eu la curiosité éveillée, je m’empresse de préciser donc :

Qu’est-ce que la coercition

La coercition est un mécanisme qui permet de transformer à la volée une valeur d’un champ dans un format particulier. La coercition est utilisée pour modifier une valeur qui ne valide pas le type d’un attribut mais qui valide un type défini dans une coercition.

Un exemple simple : j’ai une classe qui possède un attribut “mysql_date” qui est valdie le format : YYYY-MM-DD. Je peux définir une coercition sur cet attribut pour toute valeur qui validerait le type ‘Timestamp’ par exemple.

Ainsi je pourrai faire

$mon_objet->mysql_date( time() );

La coercition entrera donc en jeu et convertira l’entier retourné par time() en une date formatée selon la règle définie par l’utilisateur.

Quel était le problème avec confess/eval ? Est-ce mal d’utiliser confess ?

La chute de performance n’était pas due directement à confess, mais plutôt à l’utilisation que le mécanisme de coercition en faisait. Lorsqu’une valeur ne validait pas le type premier d’un attribut et qu’une coercition était définie, Coat bouclait sur toutes les coercitions définies afin de voir si la valeur validait le type source de la coercition. Or cette validation était faite avec le mécanisme standard de Coat qui déclenche une exception avec confess si la valeur n’est pas valide. Coat utilisait donc un bloc de code dans eval pour savoir si oui ou non la valeur est acceptée.
C’est ici que le problème réside : on ne veut pas d’exception, on veut une réponse booléene, inutile donc de faire appel à confess (et donc de lire la pile d’appel), il nous faut une méthode de validation silencieuse, qui retourne 1 ou 0 selon la validité du champ.

On peut donc résumer en disant que confess ne pose aucun problème tant qu’il est utilisé uniquement pour interrompre l’exécution du programme, et surtout pas pour être catché afin d’avoir une réponse à une question booléene.

Pour les gens intéressés, le diff est dispo ici, on constate également que la construction du message en cas d’exception était également couteuse, puisqu’elle fait appel a un bloc de code (les messages d’erreur de coercition sont des blocs de code, afin de pouvoir expander $_).

Qu’est-ce que BUILDARGS

Cette fonctionnalité vous permet de définir une méthode BUILDARGS dans votre classe. Lorsqu’un objet de cette classe est instancié, la méthode est appelée avec les arguments donnés à l’instanciation. Elle peut à loisir modifier les arguments et la valeur qu’elle retourne sera la structure de données finale reçue par l’instanciation.

On peut dire qu’il s’agit un pre-processing des arguments d’instanciation. Combiné avec une méthode BUILD ça peut être très combo-magique :-)

Voilà, j’éspère que ces précisions sont claires (je n’en suis pas sûr: c’est le matin et je n’ai pas bu mon café). Les commentaires sont là si vous avez des questions.

Related posts:

1. De la bonne façon de manipuler le temps avec Coat::Persistent Soit la situation suivante : vous avez une classe qui...
2. Publication de Coat::Persistent 0.200 Je viens d’uploader Coat::Persistent sur CPAN. Voila une bonne chose...
3. Coat::Persistent aux Journées Perl 2009 Je reviens à l’instant des Journées Perl 2009. La conférence...

Cette version corrige 3 bugs importants, pour les détails de cette version, voir le blog anglophone.

Related posts:

1. Nouvelle version de Coat::Persistent : 0.104 En travaillant sur mes slides pour FPW 2009, je me...
2. Nouvelle fonctionnalité pour Coat::Persistent : cache Une nouvelle fonctionnalité va faire son apparition d’ici peu de...
3. Publication de Coat::Persistent 0.200 Je viens d’uploader Coat::Persistent sur CPAN. Voila une bonne chose...

Le cache est géré par l’excellent Cache::FastMmap. Coat::Persistent proposera une interface simple pour activer le cache :

Coat::Persistent->enable_cache(
    expire_time => '1h',
    cache_size  => '50m',
    share_file  => '/var/cache/apache/sites/www.monsite.cache',
);

Comme chaque option de configuration fournie par Coat::Persistent, le cache peut être activé ou non pour une classe donnée ou pour toutes les classes (ce qui veut dire qu’on peut même immaginer avoir des caches différents par classe).

Du coup, c’est Libellaris.fr qui a pris un speed.

A suivre sur le CPAN donc (c’est déjà dans le SVN).

Related posts:

1. Coat Persistent La famille de Coat s’agrandit, voici un premier essai de...
2. Nouvelle version de Coat::Persistent : 0.104 En travaillant sur mes slides pour FPW 2009, je me...
3. De la bonne façon de manipuler le temps avec Coat::Persistent Soit la situation suivante : vous avez une classe qui...

No related posts.

Related posts:

1. Nouvelle fonctionnalité pour Coat::Persistent : cache Une nouvelle fonctionnalité va faire son apparition d’ici peu de...
2. De la bonne façon de manipuler le temps avec Coat::Persistent Soit la situation suivante : vous avez une classe qui...
3. Publication de Coat::Persistent 0.200 Je viens d’uploader Coat::Persistent sur CPAN. Voila une bonne chose...