Modèles¶

Association des types de données par Base de données¶

Chaque RDMS (Relational Database Management System, en français SGBD : Système de gestion de bases de données relationnelles) définit les types de données de manières un peu différentes. Avec une classe « datasource » pour chaque système de base de données, CakePHP associe ces types à quelque chose qu’il reconnaît et crée une interface unifiée, peu importe le système de base de données sur lequel vous lancerez votre application.

Cette section décrit comment chacun d’eux est associé.

Titres¶

Un objet, au sens physique du terme, a souvent un nom ou un titre par le biais duquel on peut y faire référence. Une personne a un nom comme John ou Michel ou Gaston. Un billet de blog a un titre. Une catégorie a un nom.

En spécifiant un champ title ou name, CakePHP utilisera automatiquement cet intitulé dans plusieurs circonstances :

• Maquettage rapide (Scaffolding) — titres de page, étiquettes des balises fieldset

• Listes — normalement utilisé pour les menus déroulants <select>

• TreeBehavior — mise en ordre, vues arborescentes

Si vous avez un champ « title » et un champ « name » dans votre table, le champ « title » sera utilisé.

Si vous voulez utiliser autre chose que la convention, définissez var $displayField = 'un_champ';. Un seul champ peut être défini ici.

« created » et « modified » (ou « updated »)¶

Ces deux champs sont automatiquement gérés lors des appels à la méthode save() du modèle CakePHP. A la création d’une nouvelle ligne, son champ created sera automatiquement rempli et son champ modified est mis à jour chaque fois que des changements sont faits. Notez qu’un champ nommé updated aura le même comportement que le champ modified.

Ces deux champs spéciaux doivent être de type DATETIME avec NULL comme valeur par défaut.

Utiliser les UUIDs comme Clés primaires¶

Les clés primaires sont normalement définies par un champ INT. La base de donnée autoincrémente le champ, en commençant par 1, pour chaque nouvel enregistrement ajouté. De façon alternative, si vous spécifiez votre clé primaire comme CHAR(36) ou BINARY(36), CakePHP génèrera automatiquement des UUIDs lorsque de nouveaux enregistrements sont créés.

Un UUID est une chaine de 32 bytes séparés par quatre tirets, pour un total de 36 caractères. Par exemple :

550e8400-e29b-41d4-a716-446655440000

Les UUIDs sont conçus pour être uniques, pas seulement au sein d’une même table, mais également entre les différentes tables et bases de données. Si vous avez besoin d’un champ qui reste unique quelque soit le système utilisé, alors les UUIDS sont une bonne approche.

find¶

find($type, $params)

Find est, parmi toutes les fonctions de récupération de données des modèles, une véritable bête de somme multi-fonctionnelle. $type peut être 'all', 'first', 'count', 'list', 'neighbors' ou 'threaded'. Le type par défaut est 'first'. Gardez à l’esprit que $type est sensible à la casse. Utiliser un caractère majuscule (par exemple 'All') ne produira pas le résultat attendu.

$params est utilisé pour passer tous les paramètres aux différentes formes de find et il a les clés suivantes disponibles par défaut - qui sont toutes optionnelles :

array(
    'conditions' => array('Model.champ' => $cetteValeur), // tableau de conditions
    'recursive' => 1, // entier
    'fields' => array('Model.champ', 'Model.champ2'), // tableau de nom de champs
    'order' => 'Model.id', // chaîne ou tableau définissant le ORDER BY
    'group' => array('Model.champ'), // champs pour le GROUP BY
    'limit' => n, // entier
    'page' => n, // entier
        'offset'=> n, // entier
    'callbacks' => true //les autres valeurs possibles sont false, 'before', 'after'
)

Il est possible également, d’ajouter et d’utiliser d’autres paramètres, dont il est fait usage dans quelques types de find, dans des comportements (behaviors) et, bien sûr, dans vos propres méthodes de modèle.

function une_fonction() {
   ...
   $this->Article->order = null; // redéfinition s'il l'est déjà
   $articleADemiAleatoire = $this->Article->find();
   $this->Article->order = 'Article.created DESC'; // simule le fait que le modèle ait un ordre de tri par défaut
   $dernierCree = $this->Article->find();
   $dernierCreeEgalement = $this->Article->find('first', array('order' => array('Article.created DESC')));
   $specifiquementCeluiCi = $this->Article->find('first', array('conditions' => array('Article.id' => 1)));
   ...
}

Array
(
    [NomModele] => Array
        (
            [id] => 83
            [champ1] => valeur1,
            [champ2] => valeur2.
            [champ3] => valeur3
        )

    [NomModeleAssocie] => Array
        (
            [id] => 1
            [champ1] => valeur1,
            [champ2] => valeur2.
            [champ3] => valeur3
        )
)

function une_fonction() {
   ...
   $total = $this->Article->find('count');
   $en_attente = $this->Article->find('count', array('conditions' => array('Article.statut' => 'en attente')));
   $auteurs = $this->Article->Utilisateur->find('count');
   $auteursPublies = $this->Article->find('count', array(
      'fields' => 'DISTINCT Article.utilisateur_id',
      'conditions' => array('Article.statut !=' => 'en attente')
   ));
   ...
}

function une_fonction() {
   ...
   $tousLesArticles = $this->Article->find('all');
   $en_attente = $this->Article->find('all', array('conditions' => array('Article.statut' => 'en attente')));
   $tousLesAuteurs = $this->Article->Utilisateur->find('all');
   $tousLesAuteursPublies = $this->Article->User->find('all', array('conditions' => array('Article.statut !=' => 'en attente')));
   ...
}

Array
(
    [0] Array
        (
            [NomModele] => Array
                (
                    [id] => 83
                    [champ1] => valeur1
                    [champ2] => valeur2
                    [champ3] => valeur3
                )

            [NomModeleAssocie] => Array
                (
                    [id] => 1
                    [champ1] => valeur1
                    [champ2] => valeur2
                    [champ3] => valeur3
                )

        )
)

function une_fonction() {
   ...
   $tousLesArticles = $this->Article->find('list');
   $en_attente = $this->Article->find('list', array('conditions' => array('Article.statut' => 'en attente')));
   $tousLesAuteurs = $this->Article->Utilisateur->find('list');
   $tousLesAuteursPublies = $this->Article->User->find('list', array('conditions' => array('Article.statut !=' => 'en attente')));
   ...
}

Array
(
    //[id] => 'valeurAffichage',
    [1] => 'valeurAffichage1',
    [2] => 'valeurAffichage2',
    [4] => 'valeurAffichage4',
    [5] => 'valeurAffichage5',
    [6] => 'valeurAffichage6',
    [3] => 'valeurAffichage3',
)

function une_fonction() {
   ...
   $juste_les_pseudos = $this->Article->Utilisateur->find('list', array('fields' => array('Utilisateur.pseudo'));
   $correspondancePseudo = $this->Article->Utilisateur->find('list', array('fields' => array('Utilisateur.pseudo', 'Utilisateur.prenom'));
   $groupesPseudo = $this->Article->Utilisateur->find('list', array('fields' => array('Utilisateur.pseudo', 'Utilisateur.prenom', 'Utilisateur.groupe'));
   ...
}

 $juste_les_pseudos = Array
(
    //[id] => 'pseudo',
    [213] => 'AD7six',
    [25] => '_psychic_',
    [1] => 'PHPNut',
    [2] => 'gwoo',
    [400] => 'jperras',
)

$correspondancePseudo = Array
(
    //[pseudo] => 'prenom',
    ['AD7six'] => 'Andy',
    ['_psychic_'] => 'John',
    ['PHPNut'] => 'Larry',
    ['gwoo'] => 'Gwoo',
    ['jperras'] => 'Joël',
)

$usernameGroups = Array
(
    ['Utilisateur'] => Array
        (
        ['PHPNut'] => 'Larry',
        ['gwoo'] => 'Gwoo',
        )

    ['Admin'] => Array
        (
        ['_psychic_'] => 'John',
        ['AD7six'] => 'Andy',
        ['jperras'] => 'Joël',
        )

)

function une_fonction() {
   ...
   $toutesLesCategories = $this->Categorie->find('threaded');
   $uneCategorie = $this->Categorie->find('first', array('conditions' => array('parent_id' => 42)); // pas la racine
   $quelquesCategories = $this->Categorie->find('threaded', array(
    'conditions' => array(
        'Article.lft >=' => $uneCategorie['Categorie']['lft'],
        'Article.rght <=' => $uneCategorie['Categorie']['rght']
    )
   ));
   ...
}

Array
(
    [0] => Array
        (
            [nomModele] => Array
                (
                    [id] => 83
                    [parent_id] => null
                    [champ1] => valeur1
                    [champ2] => valeur2
                    [champ3] => valeur3
                )

            [nomModeleAssocie] => Array
                (
                    [id] => 1
                    [champ1] => valeur1
                    [champ2] => valeur2
                    [champ3] => valeur3
                )
            [children] => Array
                (
            [0] => Array
            (
                [nomModele] => Array
                (
                    [id] => 42
                            [parent_id] => 83
                    [champ1] => valeur1
                    [champ2] => valeur2
                    [champ3] => valeur3
                )

                [nomModeleAssocie] => Array
                (
                    [id] => 2
                    [champ1] => valeur1
                    [champ2] => valeur2
                    [champ3] => valeur3
                )
                    [children] => Array
                (
                )
                    )
            ...
                )
        )
)

function une_fonction() {
   $voisins = $this->Article->find('neighbors', array('field' => 'id', 'value' => 3));
}

Array
(
    [prev] => Array
        (
            [NomModele] => Array
                (
                    [id] => 2
                    [champ1] => valeur1
                    [champ2] => valeur2
                    ...
                )
            [NomModeleAssocie] => Array
                (
                    [id] => 151
                    [champ1] => valeur1
                    [champ2] => valeur2
                    ...
                )
        )
    [next] => Array
        (
            [NomModele] => Array
                (
                    [id] => 4
                    [champ1] => valeur1
                    [champ2] => valeur2
                    ...
                )
            [NomModeleAssocie] => Array
                (
                    [id] => 122
                    [champ1] => valeur1
                    [champ2] => valeur2
                    ...
                )
        )
)

findAllBy¶

findAllBy<fieldName>(string $value)

Ces fonctions magiques peuvent être utilisées comme un raccourci pour rechercher dans vos tables sur un champ précis. Ajoutez simplement le nom du champ (au format CamelCase) à la fin de ces fonctions et fournissez le critère de recherche pour ce champ comme premier paramètre.

Les utilisateurs de PHP4 doivent utiliser cette fonction un peu différemment, à cause d’une insensibilité à la casse en PHP4 :

Les fonctions findBy() fonctionnent comme find(“first”,…), tandis que les fonctions findAllBy() fonctionnent comme find(“all”,…).

Dans chaque cas, le résultat retourné est un tableau formaté exactement comme il le serait avec, respectivement, find() ou findAll().

findBy¶

findBy<nomChamp>(string $value)

Ces fonctions magiques peuvent être utilisées comme un raccourci pour rechercher dans vos tables selon un champ précis. Ajoutez simplement le nom du champ (au format CamelCase) à la fin de ces fonctions et fournissez le critère de recherche pour ce champ comme premier paramètre.

Les utilisateurs de PHP4 doivent utiliser cette fonction un peu différemment à cause de l’insensibilité à la casse en PHP4 :

Les fonctions findBy() fonctionnent comme find(“first”,…), alors que les fonctions findAllBy() fonctionnent comme find(“all”,…).

Dans les deux cas, le résultat retourné est un tableau formaté exactement comme il l’aurait été depuis un find() ou un findAll().

query¶

query(string $query)

Les appels SQL que vous ne pouvez pas ou ne voulez pas faire grâce aux autres méthodes de modèle (attention, il y a très peu de circonstances où cela se vérifie), peuvent être exécutés en utilisant la méthode query().

Si vous utilisez souvent cette méthode dans votre application, assurez-vous de connaître la librairie Sanitize de CakePHP, qui vous aide à nettoyer les données provenant des utilisateurs, des attaques par injection et cross-site scripting.

query() ne respecte pas $Model->cachequeries car cette fonctionnalité est par nature déconnectée de tout ce qui concerne l’appel du modèle. Pour éviter les appels au cache de requêtes, fournissez un second argument false, par exemple : query($query, $cachequeries = false)

query() utilise le nom de la table déclaré dans la requête comme clé du tableau de données retourné, plutôt que le nom du modèle. Par exemple,

$this->Photo->query("SELECT * FROM photos LIMIT 2;");

devrait retourner

Array
(
    [0] => Array
        (
            [photos] => Array
                (
                    [id] => 1304
                    [user_id] => 759
                )
        )

    [1] => Array
        (
            [photos] => Array
                (
                    [id] => 1305
                    [user_id] => 759
                )
        )
)

Pour utiliser le nom du modèle comme clé du tableau et obtenir un résultat cohérent avec ce qui est retournée par les méthodes Find, la requête doit être réécrite :

$this->Photo->query("SELECT * FROM photos AS Photo LIMIT 2;");

qui retourne

Array
(
    [0] => Array
        (
            [Photo] => Array
                (
                    [id] => 1304
                    [user_id] => 759
                )
        )

    [1] => Array
        (
            [Photo] => Array
                (
                    [id] => 1305
                    [user_id] => 759
                )
        )
)

Cette syntaxe et la structure de tableau correspondante sont valides pour MySQL seulement. Cake ne fournit aucune abstraction de données lorsqu’on exécute des requêtes manuellement, donc les résultats exacts pourront varier selon la base de données.

field¶

field(string $nom, array $conditions = null, string $ordre = null)

Retourne la valeur d’un unique champ, spécifié par $nom, du premier enregistrement correspondant aux $conditions ordonnées par $ordre. Si aucune condition n’est passée et que l’id du modèle est fixé, cela retournera la valeur du champ pour le résultat de l’enregistrement actuel. Si aucun enregistrement correspondant n’est trouvé cela retournera false.

$modele->id = 22;
echo $modele->field('nom'); // affiche le nom de l'entrée d'id 22

echo $modele->field('nom', array('created <' => date('Y-m-d H:i:s')), 'created DESC'); // affiche le nom de l'instance la plus récemment créée

read()¶

read($fields, $id)

read() est une méthode utilisée pour récupérer les données du modèle courant (Model::$data) - comme lors des mises à jour - mais elle peut aussi être utilisée dans d’autres circonstances, pour récupérer un seul enregistrement depuis la base de données.

$fields est utilisé pour passer un seul nom de champ sous forme de chaîne ou un tableau de noms de champs ; si laissé vide, tous les champs seront retournés.

$id précise l’ID de l’enregistrement à lire. Par défaut, l’enregistrement actuellement sélectionné, tel que spécifié par Model::$id, est utilisé. Passer une valeur différente pour $id fera que l’enregistrement correspondant sera sélectionné.

read() retourne toujours un tableau (même si seulement un nom de champ unique est requis). Utilisez field pour retourner la valeur d’un seul champ.

function beforeDelete($cascade) {
   ...
   $classement = $this->read('classement'); // récupère le classement de l'enregistrement qui doit être supprimé.
   $nom = $this->read('name', $id2); // récupère le nom d'un second enregistrement.
   $classement = $this->read('classement'); // récupère le classement de ce second enregistrement.
   $this->id = $id3; //
   $this->Article->read(); // lit un troisième enregistrement.
   $enregistrement = $this->data // stocke le troisième enregistrement dans $enregistrement
   ...
}

Notez que le troisième appel à read() retourne le classement du même enregistrement que celui lu avant. Cela est du au fait que read() modifie Model::$id pour toute valeur passée comme $id. Les lignes 6-8 démontrent comment read() modifie les données du modèle courant.

Conditions de recherche complexes¶

La plupart des appels de recherche de modèles impliquent le passage d’un jeu de conditions d’une manière ou d’une autre. Le plus simple est d’utiliser un bout de clause WHERE SQL. Si vous vous avez besoin de plus de contrôle, vous pouvez utiliser des tableaux.

L’utilisation de tableaux est plus claire et simple à lire, et rend également la construction de requêtes très simple. Cette syntaxe sépare également les éléments de votre requête (champs, valeurs, opérateurs etc.) en parties manipulables et discrètes. Cela permet à CakePHP de générer les requêtes les plus efficaces possibles, d’assurer une syntaxe SQL correcte, et d’échapper convenablement chaque partie de la requête.

Dans sa forme la plus simple, une requête basée sur un tableau ressemble à ceci :

$conditions = array("Billet.titre" => "Ceci est un billet");

//Exemple d’utilisation avec un modèle:
$this->Billet->find('first', array('conditions' => $conditions));

La structure ici est assez significative : Tous les billets dont le titre à pour valeur « Ceci est un billet » sont cherchés. Nous aurions pu uniquement utiliser « titre » comme nom de champ, mais lorsque l’on construit des requêtes, il vaut mieux toujours spécifier le nom du modèle. Cela améliore la clarté du code, et évite des collisions futures, dans le cas où vous devriez changer votre schéma.

Qu’en est-il des autres types de correspondances ? Elles sont aussi simples. Disons que nous voulons trouver tous les billets dont le titre n’est pas « Ceci est un billet » :

array("Billet.titre" => "<> Ceci est un billet")

Notez le “<>” qui précède l’expression. CakePHP peut parser tout opérateur de comparaison valide de SQL, même les expressions de correspondance utilisant LIKE, BETWEEN, ou REGEX, tant que vous laissez un espace entre l’opérateur et la valeur. La seule exception à ceci sont les correspondance du genre IN(…). Admettons que vous vouliez trouver les billets dont le titre appartient à un ensemble de valeur données :

array(
    "Billet.titre" => array("Premier billet", "Second billet", "Troisième billet")
)

Faire un NOT IN(…) correspond à trouver les billets dont le titre n’est pas dans le jeu de données passé :

array(
    "NOT" => array( "Billet.titre" => array("Premier billet", "Second billet", "Troisième billet") )
)

Ajouter des filtres additionnels aux conditions est aussi simple que d’ajouter des paires clé/valeur au tableau :

array
(
    "Billet.titre" => array("Premier billet", "Second billet", "Troisième billet"),
    "Billet.created >" => date('Y-m-d', strtotime("-2 weeks")
)

Vous pouvez également créer des recherche qui comparent deux champs de la base de données

array("Billet.created = Billet.modified")

L’exemple ci-dessus retournera les billets où la date de création est égale à la date de modification (ie les billets qui n’ont jamais été modifiés sont retournés).

Souvenez-vous que si vous vous trouvez dans l’incapacité de formuler une clause WHERE par cette méthode (ex. opérations booléennes),il vous est toujours possible de la spécifier sous forme de chaîne comme :

array(
    'Modele.champ & 8 = 1',
    // autres conditions habituellement utilisées
)

Par défaut, CakePHP joint les conditions multiples avec l’opérateur booléen AND, ce qui signifie que le bout de code ci-dessus correspondra uniquement aux billets qui ont été créés durant les deux dernières semaines, et qui ont un titre correspondant à ceux donnés. Cependant, nous pouvons simplement trouver les billets qui correspondent à l’une ou l’autre des conditions :

array
("or" =>
    array
    (
        "Billet.titre" => array("Premier billet", "Second billet", "Troisième billet"),
        "Billet.created >" => date('Y-m-d', strtotime("-2 weeks")
    )
)

Cake accepte toute opération booléenne SQL valide, telles que AND, OR, NOT, XOR, etc., et elles peuvent être en majuscule comme en minuscule, comme vous préférez. Ces conditions sont également infiniment « NEST-ABLE ». Admettons que vous ayez une relation hasMany/belongsTo entre Billets et Auteurs, ce qui reviendrait à un LEFT JOIN. Admettons aussi que vous vouliez trouver tous les billets qui contiennent un certain mot-clé « magique » ou qui a été créé au cours des deux dernières semaines, mais que vous voulez restreindre votre recherche aux billets écrits par Bob :

array (
    "Auteur.nom" => "Bob",
    "or" => array
    (
        "Billet.titre LIKE" => "%magique%",
        "Billet.created >" => date('Y-m-d', strtotime("-2 weeks")
    )
)

Cake peut aussi vérifier les champs null. Dans cet exemple, la requête retournera les enregistrements où le titre du billet n’est pas null :

array ("not" => array (
        "Billet.titre" => null,
    )
)

Pour gérer les requêtes BETWEEN, vous pouvez utiliser ceci :

array('Billet.id BETWEEN ? AND ?' => array(1,10))

Note : CakePHP quotera les valeurs numériques selon le type du champ dans votre base de données.

Qu’en est-il de GROUP BY ?

array('fields'=>array('Produit.type','MIN(Produit.prix) as prix'), 'group' => 'Produit.type');

Les données retournées seront dans le format suivant:

Array
(
[0] => Array
(
[Produit] => Array
(
[type] => Vetement
)
[0] => Array
(
[prix] => 32
)
)
[1] => Array....

Un rapide exemple de réalisation d’une requête DISTINCT. Vous pouvez utiliser d’autres opérateurs, tels que MIN(), MAX(), etc., de la même manière

array('fields'=>array('DISTINCT (Utilisateur.nom) AS nom_de_ma_colonne'), 'order'=>array('Utilisateur.id DESC'));

Vous pouvez créer des conditions très complexes, en regroupant des tableaux de conditions multiples :

array(
   'OR' => array(
      array('Entreprise.nom' => 'Futurs Gains'),
      array('Entreprise.nom' => 'Le truc qui marche bien')
   ),
   'AND' => array(
      array(
         'OR'=>array(
            array('Entreprise.status' => 'active'),
            'NOT'=>array(
               array('Entreprise.status'=> array('inactive', 'suspendue'))
            )
         )
     )
   )
);

Qui produira la requête SQL suivante :

SELECT `Entreprise`.`id`, `Entreprise`.`nom`,
`Entreprise`.`description`, `Entreprise`.`location`,
`Entreprise`.`created`, `Entreprise`.`status`, `Entreprise`.`taille`

FROM
   `entreprises` AS `Entreprise`
WHERE
   ((`Entreprise`.`nom` = 'Futurs Gains')
   OR
   (`Entreprise`.`nom` = 'Le truc qui marche bien'))
AND
   ((`Entreprise`.`status` = 'active')
   OR (NOT (`Entreprise`.`status` IN ('inactive', 'suspendue'))))

Sous requêtes

Par exemple, imaginons que nous avons une table « utilisateurs » avec « id », « nom » et « statuts ». Le statuts peut être « A », « B » ou « C ». Et nous voulons récupérer tous les utilisateurs qui ont un statuts différent de « B » en utilisant une sous requête.

Pour pouvoir effectuer cela, nous allons appeler la source de données du modèle et lui demander de construire la requête comme si nous appelions une méthode « find », mais elle retournera uniquement la commande SQL. Après cela, nous construisons une expression et l’ajoutons au tableau des conditions.

$conditionsSousRequete['"Utilisateur2"."status"'] = 'B';

$dbo = $this->Utilisateur->getDataSource();
$sousRequete = $dbo->buildStatement(
array(
'fields' => array('"Urilisateur2"."id"'),
'table' => $dbo->fullTableName($this->Utilisateur),
/> 'alias' => 'Utilisateur2',
'limit' => null,
'offset' => null,
'joins' => array(),
'conditions' => $conditionsSousRequete,
'order' => null,
'group' => null
),
$this->Utilisateur
);
$sousRequete = ' "Utilisateur"."id" NOT IN (' . $sousRequete . ') ';
$expressionSousRequete = $dbo->expression($sousRequete);

$conditions[] = $expressionSousRequete;

$this->Utilisateur->find('all', compact('conditions'));

Ceci devrait généré la commande SQL suivante :

SELECT
"Utilisateur"."id" AS "Utilisateur__id",
"Utilisateur"."nom" AS "Utilisateur__nom",
"Utilisateur"."status" AS Utilisateur__status"
FROM
"utilisateurs" AS "Utilisateur"
WHERE
"Utilisateur"."id" NOT IN (
SELECT
"Utilisateur2"."id"
FROM
"utilisateurs" AS "Utilisateur2"
WHERE
"Utilisateur2"."status" = 'B'
)

Sauvegarder les données des modèles liés (hasOne, hasMany, belongsTo)¶

Quand on travaille avec des modèles associés, il est important de réaliser que sauvegarder les données d’un modèle doit toujours se faire depuis le modèle CakePHP correspondant. Si vous sauvegardez un nouveau Post et ses Commentaires associés, vous devrez alors utiliser à la fois les modèles Post et Commentaire durant l’opération de sauvegarde.

Si aucun enregistrement des modèles associés n’existe dans le système à ce moment là (par exemple si vous souhaitez sauvegarder un nouvel Utilisateur et ses enregistrements de Profil liés en même temps), vous devrez d’abord sauvegarder le modèle primaire (ou parent).

Pour avoir une idée de comment cela fonctionne, imaginons que nous ayons une action dans notre contrôleur UtilisateurController qui permette de sauvegarder un nouvel Utilisateur et un Profil lié. L’exemple d’action ci-dessous supposera que vous ayez POSTé suffisamment de données (en utilisant le FormHelper) pour créer un Utilisateur et un Profil.

<?php
function add() {
    if (!empty($this->data)) {


        // On peut sauvegarder les données Utilisateur
        // elles devraient être dans $this->data['Utilisateur']

        $utilisateur = $this->Utilisateur->save($this->data);



        // Si l'utilisateur a été sauvegardé nous ajoutons cette information aux données à sauvegarder
        // et sauvegardons le Profil


        if (!empty($utilisateur)) {
            // L'ID de l'Utilisateur nouvellement créé a été stockée dans
            // $this->Utilisateur->id.
            $this->data['Profil']['utilisateur_id'] = $this->Utilisateur->id;

            // Car Utilisateur hasOne Profil, nous pouvons accéder
            // au modèle Profil à travers le modèle Utilisateur :
            $this->Utilisateur->Profil->save($this->data);
        }
    }
}
?>

Une règle lorsque l’on travaille avec les associations hasOne, hasMany et belongsTo : tout n’est que manipulation de clés. L’idée de base est de prendre la clé d’un modèle et de la placer dans le champ de clé étrangère de l’autre. Quelquefois, cela implique l’utilisation de l’attribut $id de la classe de modèle après une sauvegarde (save()), mais dans d’autres cas il s’agit simplement de la récupération d’un ID depuis le champ caché du formulaire qui a été POSTé vers une action de contrôleur.

En complément de l’approche basique utilisée ci-dessus, CakePHP offre une méthode saveAll() très pratique, qui permet de valider et de sauvegarder des modèles multiples en une seule fois. De plus, saveAll() fournit un support transactionnel pour assurer l’intégrité des données dans votre base de données (càd que si votre modèle ne parvient pas à se sauvegarder, les autres modèles ne seront pas sauvegardés non plus).

Pour que les transactions fonctionnent correctement dans MySQL vos tables doivent utiliser InnoDB. Rappelez-vous que le tables MyISAM ne supportent pas les transactions.

Regardons comment nous pouvons utiliser saveAll() pour sauvegarder les modèles Entreprise et Compte en même temps.

D’abord, vous devrez construire votre formulaire à la fois pour les modèles Entreprise et Compte (nous supposerons qu’une Entreprise hasMany Compte).

echo $form->create('Entreprise', array('action'=>'ajouter'));
echo $form->input('Entreprise.nom', array('label'=>'Nom de l\'entreprise'));
echo $form->input('Entreprise.description');
echo $form->input('Entreprise.localisation');

echo $form->input('Compte.0.nom', array('label'=>'Nom du compte'));
echo $form->input('Compte.0.login');
echo $form->input('Compte.0.email');

echo $form->end('Ajouter');

Jetons un œil à la manière dont nous avons nommé les champs du formulaire pour le modèle Compte. Si Entreprise est notre modèle principal, saveAll() s’attendra à ce que les données des modèles liés (Compte) arrivent dans un format spécifique. Ainsi, Compte.0.nomDuChamp est exactement ce dont nous avons besoin.

Le nommage des champs ci-dessus est nécessaire pour une association hasMany. Si l’association entre les modèles est de type hasOne, il faudra utiliser la notation NomDuModele.nomChamp pour le modèle associé.

Maintenant, dans notre contrôleur entreprises_controller nous pouvons créer une action ajouter() :

function ajouter() {
   if(!empty($this->data)) {
      $this->Entreprise->saveAll($this->data, array('validate'=>'first'));
   }
}

C’est tout ce qu’il y a à faire. Désormais nos modèles Entreprise et Compte seront tous deux validés et sauvegardés au même moment. Une chose à noter, est l’utilisation ici de array('validate'=>'first'), cette option nous assure que les deux modèles seront validés.

mon_modele_count

class Image extends AppModel {
    var $belongsTo = array(
        'ImageAlbum' => array('counterCache' => true)
    );
}

class Image extends AppModel {
    var $belongsTo = array(
        'ImageAlbum' => array(
            'counterCache' => true,
            'counterScope' => array('active' => 1) // Compte seulement si 'Image est actif = 1
    ));
}

Sauvegarder les données des modèles liés (HABTM)¶

Sauvegarder des modèles qui sont associés par un hasOne, belongsTo et hasMany est relativement simple : vous n’avez qu’à renseigner la clé étrangère avec l’ID du modèle associé. Une fois que ceci est fait, il vous suffit d’appeler la méthode save() sur le modèle et tout se reliera correctement.

Avec les relations HABTM, vous devez fixer l’ID du modèle associé dans votre tableau de données. Nous allons construire un formulaire qui crée un nouveau tag et l’associe à la volée à une recette.

Le formulaire le plus simpliste ressemblerait à quelque chose comme ceci (nous supposerons que $recette_id contient déjà une valeur) :

<?php echo $form->create('Tag');?>
    <?php echo $form->input(
        'Recette.id',
        array('type'=>'hidden', 'value' => $recette_id)); ?>
    <?php echo $form->input('Tag.nom'); ?>
    <?php echo $form->end('Ajouter le tag'); ?>

Dans cet exemple, vous pouvez remarquer le champ caché Recette.id dont la valeur est l’ID de la recette à laquelle nous voulons relier le tag.

Quand la méthode save() est invoquée dans le contrôleur, elle sauvera automatiquement les données HABTM dans la base de données.

function add() {
    // Sauvegarde l'association
    if ($this->Tag->save($this->data)) {
        // Faire quelque chose en cas d'enregistrement réussi
    }
}

Avec le code précédent, notre nouveau Tag est créé et associé avec une Recette, dont l’ID était défini dans $this->data[“Recette”][“id”].

Pour d’autres raisons nous pourrions vouloir présenter les données associées sous forme de liste déroulante. Les données peuvent être récupérées depuis le modèle en utilisant la méthode find('list') et assignées à une variable de vue au nom du modèle. Un champ input avec le même nom sera automatiquement affiché comme un select contenant les données.

// dans le contrôleur
$this->set('tags', $this->Recette->Tag->find('list'));

// dans la vue
$form->input('tags');

Un scénario plus probable avec une relation HABTM inclurait un ensemble de select pour permettre des sélections multiples. Par exemple, une Recette peut avoir de multiples Tags qui lui sont assignés. Dans ce cas, les données sont tirées du modèle de la même manière, mais le champ de formulaire est déclaré de manière un peu différente. Le nom du tag est défini en utilisant la convention NomModele.

// dans le contrôleur
$this->set('tags', $this->Recette->Tag->find('list'));

// dans la vue
$form->input('Tag');

En utilisant le code précédent, un menu déroulant de sélection multiple est créé, permettant la sauvegarde automatique de choix multiples pour la Recette existante lors d’un ajout ou d’une sauvegarde dans la base de données.

Que faire quand la relation HABTM devient compliquée ?

Par défaut, en sauvant une relation « HasAndBelongsToMany », Cake effacera toutes les lignes de la table de jointure avant de sauvegarder les nouvelles. Par exemple, si vous avez un « Club » qui a 10 « Affilié » associés, et que vous mettez à jour le « Club » avec 2 nouveaux « Affilié », le « Club » ne comptera que 2 « Affilié », et pas 12.

Notez également que, si vous voulez ajouter d’autres champs à la table de jointure (quand il a été créé ou des métas informations), c’est possible avec les tables de jointure HABTM, mais il est important de comprendre que vous avez une option plus facile.

Une relation HABTM entre deux modèles est en réalité un raccourci pour trois modèles associés deux à deux par des relations hasMany et belongsTo.

Considérons cet exemple :

Affilié hasAndBelongsToMany Club

Une autre façon de voir les choses est d’ajouter un modèle « Abonnement »

Affilié hasMany Abonnement
Abonnement belongsTo Affilié, Club
Club hasMany Abonnement

Ces deux exemples sont quasiment identiques. Ils utilisent le même nombre de champs dans la base de données et le même nombre de modèles. Les différences importantes sont que le modèle de jointure est nommé différemment et que son comportement est plus prévisible.

Quand votre table de jointure contient des champs en plus des clés étrangères, la plupart du temps, il est plus facile de créer un modèle pour la jointure et des relations « hasMany » et « belongsTo » comme dans l’exemple ci-dessus, au lieu d’utiliser des relations HABTM.

delete¶

delete(int $id = null, boolean $cascade = true);

Supprime l’enregistrement identifié par $id. Par défaut, supprime également les enregistrements dépendants de l’enregistrement mentionné comme devant être supprimé.

Par exemple, lors de la suppression d’un enregistrement Utilisateur lié à plusieurs enregistrements Recette :

• si $cascade est fixé à true, les entrées Recette liées sont aussi supprimées si les valeurs « dependant » des modèles sont à true.

• si $cascade est fixé à false, les entrées Recette resteront après que l’Utilisateur ait été supprimé.

remove¶

remove(int $id = null, boolean $cascade = true);

Un synonyme de delete().

deleteAll¶

deleteAll(mixed $conditions, $cascade = true, $callbacks = false)

Identique à delete() et remove(), sauf que deleteAll() supprime tous les enregistrements correspondant aux conditions fournies. Le tableau $conditions doit être un fragment SQL ou un tableau.

Types de relations¶

Les quatre types d’associations dans CakePHP sont : hasOne (a un seul), hasMany (a plusieurs), belongsTo (appartient à), et hasAndBelongsToMany (HABTM) (appartient à et est composé de plusieurs).

Les associations se définissent en créant une variable de classe nommée comme l’association que vous souhaitez définir. La variable de classe peut quelquefois se limiter à une chaîne de caractère, mais peut également être aussi complète qu’un tableau multi-dimensionnel utilisé pour définir les spécificité de l’association.

<?php

class Utilisateur extends AppModel {
    var $name = 'Utilisateur ';
    var $hasOne = 'Profil';
    var $hasMany = array(
        'Recette' => Array
            'className'  => 'Recette',
            'conditions' => array('Recette.acceptee' => '1'),
            'order'      => 'Recette.created DESC'
        )
    );
}

?>

Dans l’exemple ci-dessus, la première instance du mot “Recette” est ce que l’on appelle un “Alias”. C’est un identifiant pour la relation et cela peut être ce que vous souhaitez. En règle générale, on choisit le même nom que la classe qu’il référence. Toutefois, les alias doivent être uniques à la fois dans un modèle et de part et d’autre d’une relation belongsTo/hasMany ou belongsTo/hasOne. Choisir des noms non-uniques pour des alias de modèle peut engendrer des comportements non souhaités.

Cake créera automatiquement des liens entre les objets de modèles associés. Par exemple dans notre modèle Utilisateur vous pourrez accéder au modèle Recette par

$this->Recette->uneFonction();

De la même manière dans votre contrôleur vous pouvez accéder à un modèle associé en suivant simplement les associations de modèle et sans l’ajouter dans le tableau $uses :

$this->Utilisateur->Recette->uneFonction();

Rappelez-vous que les associations sont définies “dans un seul sens”. Si vous définissez Utilisateur hasMany Recette cela n’aura aucun effet sur le modèle Recette. Vous devrez définir Recette belongsTo Utilisateur pour pouvoir accéder au modèle Utilisateur depuis le modèle Recette.

hasOne¶

Mettons en place un modèle Utilisateur avec une relation de type hasOne vers un modèle Profil.

Tout d’abord, les tables de votre base de données doivent être saisies correctement. Pour qu’une relation de type hasOne fonctionne, une table doit contenir une clé étrangère qui pointe vers un enregistrement de l’autre. Dans notre cas la table profils contiendra un champ nommé utilisateur_id. Le motif de base est :

Table: hasOne: l”autre modèle contient la clé étrangère.

Le fichier du modèle Utilisateur sera sauvegardé dans /app/models/utilisateur.php. Pour définir l’association “Utilisateur hasOne Profil”, ajoutez la propriété $hasOne à la classe du modèle. Pensez à avoir un modèle Profil dans /app/models/profil.php, sans quoi l’association ne fonctionnera pas.

<?php

class Utilisateur  extends AppModel {
    var $name = 'Utilisateur ';
    var $hasOne = 'Profil';
}
?>

Il y a deux manières de décrire cette relation dans vos fichiers de modèle. La méthode la plus simple est de fixer comme valeur à l’attribut $hasOne une chaîne de caractères contenant le nom de la classe associée au modèle, comme nous l’avons fait ci-dessus.

Si vous avez besoin de plus de contrôle, vous pouvez définir vos associations en utilisant un tableau. Par exemple, vous pourriez vouloir classer les colonnes par date décroissante, ou limiter l’association afin qu’elle n’inclue que certains enregistrements.

<?php

class Utilisateur  extends AppModel {
    var $name = 'Utilisateur ';
    var $hasOne = array(
        'Profile' => array(
            'className'    => 'Profil',
            'conditions'   => array('Profil.publie' => '1'),
            'dependent'    => true
        )
    );
}
?>

Les clés possibles pour un tableau décrivant une association $hasOne sont :

• className : le nom de la classe du modèle que l’on souhaite associer au modèle actuel. Si l’on souhaite définir la relation “Utilisateur a un Profil”, la valeur associée à la clé “className” devra être “Profil”.

• foreignKey : le nom de la clé etrangère que l’on trouve dans l’autre modèle. Ceci sera particulièrement pratique si vous avez besoin de définir des relations hasOne multiples. La valeur par défaut de cette clé est le nom du modèle actuel (avec des underscores) suffixé avec “_id”. Dans l’exemple ci-dessus la valeur par défaut aurait été “utilisateur_id”.

• conditions : un fragment de code SQL utilisé pour filtrer les enregistrements du modèle relié. C’est une bonne pratique que d’utiliser les noms des modèles dans ces portions de code : « Profil.approuve = 1 » sera toujours mieux qu’un simple « approuve = 1 ».

• fields : une liste des champs à récupérer lorsque les données du modèle associé sont parcourues. Par défaut, cela retourne tous les champs.

• order : un fragment SQL qui définit l’ordre pour les lignes de résultats retournées.

• dependent : lorsque la valeur de la clé “dependent” est true et que la méthode delete() du modèle est appelée avec le paramètre “cascade” valant true également, les enregistrements des modèles associés sont supprimés. Dans ce cas nous avons fixé la valeur à true de manière à ce que la suppression d’un Utilisateur supprime également le Profil associé.

Une fois que cette association aura été définie, les opérations de recherche sur le modèle Utilisateur récupèreront également les enregistrements Profils liés s’il en existe :

//Exemple de résultats d'un appel à $this->Utilisateur->find().

Array
(
    [Utilisateur] => Array
        (
            [id] => 121
            [nom] => Gwoo le Kungwoo
            [created] => 2007-05-01 10:31:01
        )
    [Profil] => Array
        (
            [id] => 12
            [utilisateur_id] => 121
            [competences] => Cuisiner des gâteaux
            [created] => 2007-05-01 10:31:01
        )
)

belongsTo¶

Maintenant que nous avons accès aux données du Profil depuis le modèle Utilisateur, définissons une association belongsTo (appartient a) dans le modèle Profil afin de pouvoir accéder aux données Utilisateur liées. L’association belongsTo est un complément naturel aux associations hasOne et hasMany : elle permet de voir les données dans le sens inverse.

Lorsque vous définissez les clés de votre base de données pour une relation de type belongsTo, suivez cette convention :

Table: belongsTo: le modèle actuel contient la clef étrangère.

Si un modèle (table) contient une clé étrangère, elle appartient à (belongsTo) l’autre modèle (table).

On peut définir l’association belongsTo dans notre modèle Profil (/app/models/profil.php) en utilisant une chaîne de caractère de cette manière :

<?php

class Profil extends AppModel {
    var $name = 'Profil';
    var $belongsTo = 'Utilisateur';
}
?>

Nous pouvons également définir une relation plus spécifique en utilisant un tableau :

<?php

class Profil extends AppModel {
    var $name = 'Profil';
    var $belongsTo = array(
        'Utilisateur' => array(
            'className'    => 'Utilisateur',
            'foreignKey'    => 'utilisateur_id'
        )
    );
}
?>

Les clés possibles pour le tableau d’association belongsTo sont :

• className : le nom de la classe du modèle que l’on souhaite associer au modèle actuel. Si l’on souhaite définir la relation “Profil appartient à Utilisateur”, la valeur associée à la clef “className” devra être “Utilisateur”.

• foreignKey : le nom de la clef étrangère que l’on trouve dans le modèle actuel. Ceci sera particulièrement pratique si vous avez besoin de définir des relations belongsTo multiples. La valeur par défaut de cette clef est le nom de l’autre modèle (avec des underscores) suffixé avec “_id”.

• conditions : un fragment de code SQL utilisé pour filtrer les enregistrements du modèle relié. C’est une bonne pratique que d’utiliser les noms des modèles dans ces portions de code : « Utilisateur.actif = 1 » sera toujours mieux qu’un simple « actif = 1 ».

• fields : une liste des champs à récupérer lorsque les données du modèle associé sont parcourues. Par défaut, cela retourne tous les champs.

• order : un fragment SQL qui définit l’ordre des lignes de résultat retournées.

• counterCache : si il vaut true le Modèle associé incrémentera ou décrémentera automatiquement le champ « [nom_du_modele_au_singulier]_count » dans la table étrangère dès qu’un appel a save() ou delete() sera effectué. Si c’est une chaîne de caractère alors cela représente le nom du champ à utiliser. La valeur dans le champ du compteur représente le nombre d’enregistrements liés.

• counterScope : tableau de conditions optionnelles à utiliser pour mettre à jour le champ du cache de compteur.

Une fois que cette association aura été définie, les opérations de recherche sur le modèle Profil récupèreront également les enregistrements Utilisateurs liés s’il en existe :

//Exemple de résultats d'un appel à $this->Profil->find().

Array
(
   [Profil] => Array
        (
            [id] => 12
            [utilisateur_id] => 121
            [competences] => Cuisiner des gâteaux
            [created] => 2007-05-01 10:31:01
        )
    [Utilisateur] => Array
        (
            [id] => 121
            [nom] => Gwoo le Kungwoo
            [created] => 2007-05-01 10:31:01
        )
)

hasMany¶

Prochaine étape : définir une association « Utilisateur hasMany Commentaire ». Une association hasMany nous permettra de récupérer les commentaires d’un utilisateur lors de la récupération d’un enregistrement Utilisateur.

Lorsque vous définissez les clés de votre base de données pour une relation de type hasMany, suivez cette convention :

hasMany: l”autre modèle contient la clé étrangère.

Relation

Schéma

Utilisateur hasMany Commentaire

Commentaire.utilisateur_id

Cake hasMany Vertue

Vertue.cake_id

Produit hasMany Option

Option.produit_id

On peut définir l’association hasMany dans notre modèle Utilisateur (/app/models/utilisateur.php) en utilisant une chaîne de caractère de cette manière :

<?php

class Utilisateur extends AppModel {
    var $name = 'Utilisateur ';
    var $hasMany = 'Commentaire';
}
?>

Nous pouvons également définir une relation plus spécifique en utilisant un tableau :

<?php

class Utilisateur extends AppModel {
    var $name = 'Utilisateur ';
    var $hasMany = array(
        'Commentaire' => array(
            'className'     => 'Commentaire',
            'foreignKey'    => 'utilisateur_id',
            'conditions'    => array('Commentaire.statut' => '1'),
            'order'    => 'Commentaire.created DESC',
            'limit'        => '5',
            'dependent'=> true
        )
    );
}
?>

Les clés possibles pour les tableaux d’association hasMany sont :

• className: le nom de la classe du modèle que l’on souhaite associer au modèle actuel. Si l’on souhaite définir la relation “Utilisateur a plusieurs Commentaire”, la valeur associée à la clef “className” devra être “Commentaire”.

• foreignKey: le nom de la clé etrangère que l’on trouve dans l’autre modèle. Ceci sera particulièrement pratique si vous avez besoin de définir des relations hasMany multiples. La valeur par défaut de cette clef est le nom du modèle actuel (avec des underscores) suffixé avec “_id”.

• conditions: un fragment de code SQL utilisé pour filtrer les enregistrements du modèle relié. C’est une bonne pratique que d’utiliser les noms des modèles dans ces portions de code : « Commentaire.statut= 1 » sera toujours mieux qu’un simple « statut = 1 ».

• fields: une liste des champs à récupérer lorsque les données du modèle associé sont parcourues. Par défaut, cela retourne tous les champs.

• order: un fragment de code SQL qui définit l’ordre des entrées associées.

• limit: le nombre maximum d’entrées associées qui seront retournées.

• offset: le nombre d’entrées associées à sauter (les conditions et l’ordre de classement étant donnés) avant de récupérer de nouveaux enregistrements et de les associer.

• dependent: lorsque dependent vaut true, une suppression récursive du modèle est possible. Dans cet exemple, les enregistrements Commentaires seront supprimés lorsque leur Utilisateur associé l’aura été.

• exclusive: Lorsque exclusive est fixé à true, la suppression récursive de modèle effectue la suppression avec un deleteAll() au lieu du supprimer chaque entité séparément. Cela améliore grandement la performance, mais peut ne pas être idéal dans toutes les circonstances.

• finderQuery: une requête SQL complète que CakePHP peut utiliser pour retrouver les enregistrements associés au modèle. Ceci ne devrait être utilisé que dans les situations qui nécessitent des résultats très personnalisés. Si une de vos requêtes a besoin d’une référence à l’ID du modèle associé, utilisez le marqueur spécial {$__cakeID__$} dans la requête. Par exemple, si votre modèle Pomme hasMany Orange, la requête devrait ressembler à ça :

SELECT Orange.* from oranges as Orange WHERE Orange.pomme_id = {$__cakeID__$};

Une fois que cette association a été définie, les opérations de recherche sur le modèle Utilisateur récupèreront également les Commentaires reliés si ils existent :

//Exemple de résultats d'un appel à $this->Utilisateur->find().

Array
(
    [Utilisateur] => Array
        (
            [id] => 121
            [nom] => Gwoo le Kungwoo
            [created] => 2007-05-01 10:31:01
        )
    [Commentaire] => Array
        (
            [0] => Array
                (
                    [id] => 123
                    [utilisateur_id] => 121
                    [titre] => Sur Gwoo le Kungwoo
                    [corps] => La Kungwooité est assez Gwooteuse
                    [created] => 2006-05-01 10:31:01
                )
            [1] => Array
                (
                    [id] => 123
                    [utilisateur_id] => 121
                    [titre] => Plus sur Gwoo
                    [corps] => Mais qu'en est-il ?
                    [created] => 2006-05-01 10:41:01
                )
        )
)

Une chose dont il faut se rappeler est que vous aurez besoin d’une association « Commentaire belongsTo Utilisateur » en complément, afin de pouvoir récupérer les données dans les deux sens. Ce que nous avons défini dans cette section vous donne la possibilité d’obtenir les données de Commentaire depuis l’Utilisateur. En ajoutant l’association « Commentaire belongsTo Utilisateur » dans le modèle Commentaire, vous aurez la possibilité de connaître les données de l’Utilisateur depuis le modèle Commentaire - cela complète la connexion entre eux et permet un flot d’informations depuis n’importe lequel des deux modèles.

hasAndBelongsToMany (HABTM)¶

Très bien. A ce niveau, vous pouvez déjà vous considérer comme un professionnel des associations de modèles CakePHP. Vous vous êtes déjà assez compétents dans les 3 types d’associations afin de pouvoir effectuer la plus grande partie des relations entre les objets.

Abordons maintenant le dernier type de relation : hasAndBelongsToMany (a et appartient à plusieurs), ou HABTM. Cette association est utilisée lorsque vous avez deux modèles qui ont besoin d’être reliés, de manière répétée, plusieurs fois, de plusieurs façons différentes.

La principale différence entre les relations hasMany et HABTM est que le lien entre les modèles n’est pas exclusif dans le cadre d’une relation HABTM. Par exemple, relions notre modèle Recette avec un modèle Tag en utilisant HABTM. Le fait d’attacher le tag « Italien » à la recette de Gnocchi de ma grand-mère ne « consomme » pas le tag. Je peux aussi taguer mes Spaghettis Caramélisées au miel comme « Italien » si je le souhaite.

Les liens entre des objets liés par une association hasMany sont exclusif. Si mon Utilisateur « hasMany » Commentaires, un commentaire ne sera lié qu’à un utilisateur spécifique. Il ne sera plus disponible pour d’autres.

Continuons. Nous aurons besoin de mettre en place une table supplémentaire dans la base de données qui contiendra les associations HABTM. Le nom de cette nouvelle table de jointure doit inclure les noms des deux modèles concernés, dans l’ordre alphabétique, et séparés par un underscore (_). La table doit contenir au minimum deux champs, chacune des clés étrangères (qui devraient être des entiers) pointant sur les deux clés primaires des modèles concernés. Pour éviter tous problèmes, ne définissez pas une première clé composée de ces deux champs, si votre application le nécessite vous pourrez définir un index unique. Si vous prévoyez d’ajouter de quelconques informations supplémentaires à cette table, c’est une bonne idée que d’ajouter un champ supplémentaire comme clé primaire (par convention “id”) pour rendre les actions sur la table aussi simple que pour tout autre modèle.

HABTM Nécessite une table de jointure séparée qui contient les deux noms de modèles.

Le nom des tables est par convention dans l’ordre alphabétique.

Une fois que cette nouvelle table a été créée, on peut définir l’association HABTM dans les fichiers de modèle. Cette fois ci, nous allons directement voir la syntaxe tabulaire :

<?php

class Recette extends AppModel {
    var $name = 'Recette';
    var $hasAndBelongsToMany = array(
        'Tag' =>
            array(
                 'className'              => 'Tag',
                 'joinTable'              => 'recettes_tags',
                 'with'                   => '',
                'foreignKey'             => 'recette_id',
                'associationForeignKey'  => 'tag_id',
                'unique'                 => true,
                'conditions'             => '',
                'fields'                 => '',
                'order'                  => '',
                'limit'                  => '',
                'offset'                 => '',
                'finderQuery'            => '',
                'deleteQuery'            => '',
                'insertQuery'            => ''
            )
    );
}
?>

Les clés possibles pour un tableau définissant une association HABTM sont :

• className: le nom de la classe du modèle que l’on souhaite associer au modèle actuel. Si l’on souhaite définir la relation “Utilisateur HABTM Commentaire”, la valeur associée à la clef “className” devra être “Commentaire”.

• joinTable: Le nom de la table de jointure utilisée dans cette association (si la table ne colle pas à la convention de nommage des tables de jointure HABTM).

• with: Définit le nom du modèle pour la table de jointure. Par défaut CakePHP créera automatiquement un modèle pour vous. Dans l’exemple ci-dessus la valeur aurait été RecettesTag. En utilisant cette clé vous pouvez surcharger ce nom par défaut. Le modèle de la table de jointure peut être utilisé comme tout autre modèle « classique » pour accéder directement à la table de jointure.

• foreignKey: le nom de la clef étrangère que l’on trouve dans le modèle actuel. Ceci sera particulièrement pratique si vous avez besoin de définir des relations HABTM multiples. La valeur par défaut de cette clé est le nom du modèle actuel (avec des underscores) suffixé avec “_id”.

• associationForeignKey: le nom de la clé etrangère que l’on trouve dans l’autre modèle. Ceci sera particulièrement pratique si vous avez besoin de définir des relations HABTM multiples. La valeur par défaut de cette clef est le nom de l’autre modèle (avec des underscores) suffixé avec “_id”.

• unique: Si true (valeur par défaut) Cake supprimera d’abord les enregistrement des relations existantesdans la table des clés étrangères avant d’en insérer de nouvelles, lors de la mise à jour d’un enregistrement. Ainsi les associations existantes devront être passées encore une fois lors d’une mise à jour.

• conditions: un fragment de code SQL utilisé pour filtrer les enregistrements du modèle relié. C’est une bonne pratique que d’utiliser les noms des modèles dans ces portions de code : « Commentaire.statut= 1 » sera toujours mieux qu’un simple « statut = 1 ».

• fields: une liste des champs à récupérer lorsque les données du modèle associé sont parcourues. Par défaut, cela retourne tous les champs.

• order: un fragment de code SQL qui définit l’ordre des entrées associées.

• limit: le nombre maximum d’entrées associées qui seront retournées.

• offset: le nombre d’entrées associées à sauter (les conditions et l’ordre de classement étant donnés) avant de récupérer de nouveaux enregistrements et de les associer.

• finderQuery: une requête SQL complète que CakePHP peut utiliser pour retrouver, supprimer ou créer de nouveaux enregistrements d’associations de modèles. Ceci ne devrait être utilisé que dans les situations qui nécessitent des résultats très personnalisés.

Une fois que cette association a été définie, les opérations de recherche sur le modèle Recette récupèreront également les Tag reliés si ils existent :

//Exemple de résultats d'un appel a $this->Recette->find().

Array
(
    [Recette] => Array
        (
            [id] => 2745
            [nom] => Bombes de sucres au chocolat glacé
            [created] => 2007-05-01 10:31:01
            [utilisateur_id] => 121
        )
    [Tag] => Array
        (
            [0] => Array
                (
                    [id] => 123
                    [nom] => Petit déjeuner
                )
           [1] => Array
                (
                    [id] => 124
                    [nom] => Dessert
                )
           [2] => Array
                (
                    [id] => 125
                    [nom] => Déprime sentimentale
                )
        )
)

N’oubliez pas de définir une association HABTM dans le modèle Tag si vous souhaitez retrouver les données de Recette lorsque vous manipulez le modèle Tag.

Il est également possible d’exécuter des requêtes de recherche personnalisées basées sur des relations HABTM. Regardez les exemples suivants :

En supposant que nous avons la même structure que dans les exemples ci-dessus (Recette HABTM Tag), disons que nous voulions récupérer toutes les Recettes avec le Tag « Dessert ». Une solution rapide (mais incorrecte) pour faire ceci serait d’utiliser une condition complexe sur le modèle Recette :

$this->Recette->bindModel(array(
    'hasAndBelongsToMany' => array(
        'Tag' => array('conditions'=>array('Tag.nom'=>'Dessert'))
)));
$this->Recette->find('all');

// Données retournées
Array
(
    0 => Array
        {
        [Recette] => Array
            (
                [id] => 2745
                [nom] => Bombes de sucres au chocolat glacé
                [created] => 2007-05-01 10:31:01
                [utilisateur_id] => 121
            )
        [Tag] => Array
            (
               [0] => Array
                    (
                        [id] => 124
                        [nom] => Dessert
                    )
            )
    )
    1 => Array
        {
        [Recette] => Array
            (
                [id] => 2745
                [nom] => Gâteau au crabe
                [created] => 2008-05-01 10:31:01
                [utilisateur_id] => 121
            )
        [Tag] => Array
            (
            }
        }
}

Notez que cet exemple retourne TOUTES les recettes, mais seulement les tags « Dessert ». Pour parvenir proprement à notre but, il y a de nombreux moyens de faire. Une option est de faire une recherche sur le modèle Tag (au lieu de Recette), ce qui nous donnera également toutes les Recettes associées.

$this->Recette->Tag->find('all', array('conditions'=>array('Tag.nom'=>'Dessert')));

Nous pouvons également utiliser le modèle de la table de jointure (que cakePHP nous fournit), pour rechercher un ID donné.

$this->Recette->bindModel(array('hasOne' => array('RecettesTag')));
$this->Recette->find('all', array(
        'fields' => array('Recette.*'),
        'conditions'=>array('RecettesTag.tag_id'=>124) // id de Dessert
));

Il est également possible de créer une association exotique dans le but de créer autant de jointures que nécessaires pour permettre le filtrage, par exemple :

$this->Recette->bindModel(array(
    'hasOne' => array(
        'RecettesTag',
        'FiltreTag' => array(
            'className' => 'Tag',
            'foreignKey' => false,
            'conditions' => array('FiltreTag.id = RecettesTag.id')
))));
$this->Recette->find('all', array(
        'fields' => array('Recette.*'),
        'conditions'=>array('FiltreTag.nom'=>'Dessert')
));

Ces deux méthodes retourneront les données suivantes :

// Données retournées
Array
(
    0 => Array
        {
        [Recette] => Array
            (
                [id] => 2745
                [nom] => Bombes de sucres au chocolat glacé
                [created] => 2007-05-01 10:31:01
                [utilisateur_id] => 121
            )
    [Tag] => Array
        (
            [0] => Array
                (
                    [id] => 123
                    [nom] => Petit déjeuner
                )
           [1] => Array
                (
                    [id] => 124
                    [nom] => Dessert
                )
           [2] => Array
                (
                    [id] => 125
                    [nom] => Déprime sentimentale
                )
        )
}

La même astuce de lien peut être utilisée pour paginer facilement vos modèles HABTM. Juste un mot d’avertissement : comme paginate nécessite deux requêtes (une pour compter les enregistrements et une pour récupérer les données effectives), soyez sûrs d’avoir fourni le paramètre false à bindModel(); car cela permet essentiellement de dire à CakePHP de garder l’association de manière persistance sur les requêtes multiples, au lieu de sur une seule comme dans le comportement par défaut. Merci de vous référer à l’API pour plus de détails.

Pour plus d’informations sur l’enregistrement d’objets HABTM, voir Sauvegarder les données des modèles liés (HABTM)

Pour plus d’informations sur l’association de modèles à la volée, voir Créer et détruire des associations à la volée

Mélangez et faites correspondre les techniques pour parvenir à votre but !

Créer et détruire des Associations à la volée¶

Quelquefois il devient nécessaire de créer et détruire les associations de modèles à la volée. Cela peut être le cas pour un certain nombre de raisons :

• Vous voulez réduire la quantité de données associées qui seront récupérées, mais toutes vos associations sont sur le premier niveau de récursion.

• Vous voulez changer la manière dont une association est définie afin de classer ou filtrer les données associées.

La création et destruction se font en utilisant les méthodes de modèles CakePHP bindModel() et unbindModel(). Mettons en place quelques modèles pour pouvoir ensuite voir comment fonctionnent bindModel() et unbindModel(). Nous commencerons avec deux modèles :

<?php

class Meneur extends AppModel {
    var $name = 'Meneur';

    var $hasMany = array(
        'Suiveur' => array(
            'className' => 'Suiveur',
            'order'     => 'Suiveur.rang'
        )
    );
}

?>

<?php

class Suiveur extends AppModel {
    var $name = 'Suiveur';
}

?>

Maintenant, dans le contrôleur MeneursController, nous pouvons utiliser la méthode find() du modèle Meneur pour retrouver un Meneur et les Suiveurs associés. Comme vous pouvez le voir ci-dessus, le tableau d’association dans le modèle Meneur définit une relation « Meneur hasMany (a plusieurs) Suiveurs ». Dans un but démonstratif, utilisons unbindModel() pour supprimer cette association dans une action du contrôleur.

function uneAction() {
    // Ceci récupère tous les Meneurs, ainsi que leurs Suiveurs
    $this->Meneur->findAll();

    // Supprimons la relation hasMany() ...
    $this->Meneur->unbindModel(
        array('hasMany' => array('Suiveur'))
    );

    // Désormais l'utilisation de la fonction find() retournera
    // des Meneurs, sans aucun Suiveurs
    $this->Meneur->findAll();

    // NOTE : unbindModel n'affecte que la prochaine fonction find.
    // Un autre appel à find() utilisera les informations d'association
    // telles que configurée.

    // Nous avons déjà utilisé findAll() après unbindModel(),
    // ainsi cette ligne récupèrera une fois encore les Meneurs
    // avec leurs Suiveurs ...
    $this->Meneur->findAll();
}

Encore un rappel. Enlever ou ajouter des associations en utilisant bindModel() et unbindModel() ne fonctionne que pour la prochaine opération sur le modèle, à moins que le second paramètre n’ait été fixé à true. Si le second paramètre a été fixé à true, le lien reste en place pour la suite de la requête.

Voici un exemple basique d’utilisation de unbindModel() :

$this->Modele->unbindModel(
    array('associationType' => array('nomDeClasseModeleAssocie'))
);

Maintenant que nous sommes arrivés à supprimer une association à la volée, ajoutons-en une. Notre Meneur jusqu’à présent sans Principes a besoin d’être associé à quelques Principes. Le fichier de modèle pour notre modèle Principe est dépouillé, il n’y a que la ligne var $name. Associons à la volée des Principes à notre Meneur (mais rappelons-le, seulement pour la prochaine opération find). Cette fonction apparaît dans le contrôleur MeneursController :

function uneAutreAction() {
    // Il n'y a pas d'association Meneur hasMany Principe
    // dans le fichier de modèle meneur.php, ainsi un find
    // situé ici ne récupèrera que les Meneurs.
    $this->Meneur->findAll();

    // Utilisons bindModel() pour ajouter une nouvelle association
    // au modèle Meneur :
    $this->Meneur->bindModel(
        array('hasMany' => array(
                'Principe' => array(
                    'className' => 'Principe'
                )
            )
        )
    );

    // Maintenant que nous les avons associés correctement,
    // nous pouvons utiliser la fonction find une seule fois
    // pour récupérer les Meneurs avec leurs Principes associés :
    $this->Meneur->findAll();
}

Ça y est, vous y êtes. L’utilisation basique de bindModel() est l’encapsulation d’un tableau d’association classique, dans un tableau dont la clé est le nom du type d’association que vous essayez de créer :

$this->Modele->bindModel(
        array('nomAssociation' => array(
                'nomDeClasseModeleAssocie' => array(
                    // les clés normales d'une association sont à mettre ici ...
                )
            )
        )
    );

Bien que le modèle nouvellement associé n’ait besoin d’aucune définition d’association dans son fichier de modèle, il devra tout de même contenir les clés afin que la nouvelle association fonctionne bien.

Relations multiples avec le même modèle¶

Il y a des cas où un Modèle a plus d’une relation avec un autre Modèle. Par exemple, vous pourriez avoir un modèle Message qui a deux relations avec le modèle Utilisateur. Une relation avec l’utilisateur qui envoie un message et une seconde avec l’utilisateur qui reçoit le message. La table messages aura un champ utilisateur_id, mais aussi un champ receveur_id. Maintenant, votre modèle Message peut ressembler à quelque chose comme :

<?php
class Message extends AppModel {
    var $name = 'Message';
    var $belongsTo = array(
        'Expediteur' => array(
            'className' => 'Utilisateur',
            'foreignKey' => 'utilisateur_id'
        ),
        'Receveur' => array(
            'className' => 'Utilisateur',
            'foreignKey' => 'receveur_id'
        )
    );
}
?>

Receveur est un alias pour le modèle Utilisateur. Maintenant, voyons à quoi devrait ressembler le modèle Utilisateur.

<?php
class Utilisateur extends AppModel {
    var $name = 'Utilisateur';
    var $hasMany = array(
        'MessageEnvoye' => array(
            'className' => 'Message',
            'foreignKey' => 'utilisateur_id'
        ),
        'MessageRecu' => array(
            'className' => 'Message',
            'foreignKey' => 'receveur_id'
        )
    );
}
?>

Joindre des tables¶

En SQL, vous pouve combiner des tables liées en utilisant la clause JOIN. Ceci vous permet de réaliser des recherches complexes à travers des tables multiples (par ex. : rechercher les posts plusieurs tags donnés).

Dans CakePHP, certaines associations (belongsTo et hasOne) effectuent des jointures automatiques pour récupérer les données, vous pouvez donc lancer des requêtes pour récupérer les modèles basés sur les données de celui qui est lié.

Mais ce n’est pas le cas avec les associations hasMany et hasAndBelongsToMany. C’est là que les jointures forcées viennent à notre secours. Vous devez seulement définir les jointures nécessaires pour combiner les tables et obtenir les résultats désirés pour votre requête.

Pour forcer une jointure entre tables, vous avez besoin d’utiliser la syntaxe « moderne » de Model::find(), en ajoutant une clé “joins” au tableau $options. Par exemple :

$options['joins'] = array(
    array('table' => 'channels',
        'alias' => 'Channel',
        'type' => 'LEFT',
        $conditions = array(
            'Channel.id = Item.channel_id',
        )
    );

$Item->find('all', $options);

Notez que les tableaux “join” ne sont pas indexés.

Dans l’exemple ci-dessus, un modèle appelé Item est joint à gauche à la table channels. Vous pouvez ajouter un alias à la table, avec le nom du Modèle, ainsi les données retournées se conformeront à la structure de données de CakePHP.

Les clés qui définissent la jointure sont les suivants :

• table : la table pour la jointure.

• alias : un alias vers la table. Le nom du modèle associé avec la table est le meilleur choix.

• type : le type de jointure : inner, left ou right.

• conditions : les conditions pour réaliser la jointure.

Avec joins, vous pourriez ajouter des conditions basées sur les champs du modèle relié :

$options['joins'] = array(
    array('table' => 'channels',
        'alias' => 'Channel',
        'type' => 'LEFT',
        $conditions = array(
            'Channel.id = Item.channel_id',
        )
    );

$options['conditions'] => array(
    'Channel.private' => 1
)

$pirvateItems = $Item->find('all', $options);

Au besoin, vous pourriez réaliser plusieurs jointures avec une relation hasBelongsToMany :

Supposez une association Livre hasAndBelongsToMany Tag. Cette relation utilise une table livres_tags table comme table de jointure, donc vous avez besoin de joindre la table livres à la table livres_tags et celle-ci avec la table tags :

$options['joins'] = array(
    array('table' => 'livres_tags',
        'alias' => 'LivresTag',
        'type' => 'inner',
        'conditions' => array(
            'Livres.id = LivresTag.livres_id'
        )
    ),
    array('table' => 'tags',
        'alias' => 'Tag',
        'type' => 'inner',
        'conditions' => array(
            'LivresTag.tag_id = Tag.id'
        )
    )
);

$options['conditions'] = array(
    'Tag.tag' => 'Nouvelle'
);

$livres = $Livre->find('all', $options);

Utiliser joins avec le comportement Containable pourrait conduire à quelques erreurs SQL (tables dupliquées), vous devez donc utiliser la méthode joins comme une alternative à Containable, si objectif principal est de réaliser des recherches basées sur les données liées. Containable est plus approprié pour restreindre le volume de données reliées rapportées par une instruction find .

beforeFind¶

beforeFind(mixed $donneesRequete)

Appelée avant toute opération liée à la recherche. Les $donneesRequete passées à cette méthode de callback contiennent des informations sur la requête courante : conditions, champs, etc.

Si vous ne souhaitez pas que l’opération de recherche commence (par rapport à une décision liée aux options de $donneesRequete), retournez false. Autrement, retournez la variable $donneesRequete éventuellement modifiée, ou tout ce que vous souhaitez voir passé à la méthode find() ou ses équivalents.

Vous pouvez utiliser cette méthode de callback pour restreindre les opérations de recherche en se basant sur le rôle de l’utilisateur, ou prendre des décisions sur la politique de mise en cache en fonction de la charge actuelle.

afterFind¶

afterFind(array $resultats, bool $primaire

Utilisez cette méthode de callback pour modifier les résultats qui ont été retournés par une opération de recherche, ou pour effectuer toute logique post-recherche. Le paramètre $results passé à cette méthode contient les résultats retournés par l’opération find() du modèle, càd quelque chose come :

resultats = array(
  0 => array(
    'NomModele' => array(
      'champ1' => 'valeur1',
      'champ2' => 'valeur2',
    ),
  ),
);

La valeur de retour de ce callback doit être le résultat de l’opération de recherche (potentiellement modifié) qui a déclenché ce callback.

Si $primaire est faux, le format de $resultats sera un peu différent de ce que l’on peut attendre; à la place du résultat que vous auriez habituellement reçu d’une opération de recherche, vous aurez ceci :

resultats = array(
  'champ_1' => 'valeur',

  'champ_2' => 'valeur2'
);

Un code nécessitant que $primaire soit vrai auront probablement l’erreur fatale « Cannot use string offset as an array » de la part de PHP si une recherche récursive est utilisée.

Ci-dessous un exemple de la manière dont afterfind peut être utilisé pour formater des dates.

function afterFind($resultats) {
    foreach ($resultats as $clef => $val) {
        if (isset($val['Evenement']['debut'])) {
            $results[$clef]['Evenement']['fin'] = $this->dateFormatAfterFind($val['Evenement']['debut']);
        }
    }
    return $resultats;
}

function dateFormatAfterFind($date) {
    return date('d-m-Y', strtotime($date));
}

beforeValidate¶

beforeValidate()

Utilisez ce rappel pour modifier les données du modèle avant qu’elles ne soient validées ou pour modifier les règles de validation si nécessaire. Cette fonction doit aussi retourner vrai, sinon l’exécution du save() courant sera annulée.

beforeSave¶

beforeSave()

Placez toute logique de pré-enregistrement dans cette fonction. Cette fonction s’exécute immediatement après que les données du modèle ont été validées avec succès, mais juste avant que les données ne soient sauvegardées. Cette fonction devrait toujours retourner vrai si voulez que l’opération d’enregistrement se poursuive.

Ce callback est particulièrement pratique, pour toute logique de manipulation des données qui nécessite de se produire avant que vos données ne soient stockées. Si votre moteur de stockage nécessite un format spécifique pour les dates, accédez-y par $this->data et modifiez-les.

Ci-dessous un exemple montrant comment beforeSave peut-être utilisé pour la conversion de date. Le code de l’exemple est utilisé pour une application qui a une date de début, au format YYYY-MM-DD dans la base de données et au format DD-MM-YYYY dans l’affichage de l’application. Bien sûr, ceci peut être très facilement modifié. Utilisez le code ci-dessous dans le modèle approprié.

function beforeSave() {
    if(!empty($this->data['Evenement']['date_debut']) && !empty($this->data['Evenement']['date_fin'])) {
            $this->data['Evenement']['date_debut'] = $this->dateFormatBeforeSave($this->data['Evenement']['date_debut']);
            $this->data['Evenement']['date_fin'] = $this->dateFormatBeforeSave($this->data['Evenement']['date_fin']);
    }
    return true;
}

function dateFormatBeforeSave($dateString) {
    return date('Y-m-d', strtotime($dateString)); // Le sens d'affichage provient de là
}

Assurez-vous que beforeSave() retourne vrai ou bien votre sauvegarde échouera.

afterSave¶

afterSave(boolean $created)

Si vous avez besoin d’exécuter de la logique juste après chaque opération de sauvegarde, placez-la dans cette méthode de rappel.

La valeur de $created sera vrai si un nouvel objet a été créé (plutôt qu’un objet mis à jour).

beforeDelete¶

beforeDelete(boolean $cascade)

Placez dans cette fonction, toute logique de pré-suppression. Cette fonction doit retourner vrai si vous voulez que la suppression continue et faux si vous voulez l’annuler.

La valeur de $cascade sera true, pour que les enregistrements qui dépendent de cet enregistrement soient aussi supprimés.

afterDelete¶

afterDelete()

Placez dans cette méthode de rappel, toute logique que vous souhaitez exécuter après chaque suppression.

onError¶

onError()

Appelée si quelque problème se produit.

useDbConfig¶

La propriété useDbConfig spécifie quel paramètre du fichier de configuration de la base de données vous voulez utiliser. Le fichier de configuration de la base de données est stocké dans /app/config/database.php.

Exemple d’utilisation:

class Example extends AppModel {
   var $useDbConfig = 'alternative';
}

La valeur par défaut de useDbConfig est “default”.

useTable¶

La propriété useTable spécifie le nom de la table de la base de données. Par défaut, le modèle utilise le nom de la classe modèle au pluriel et en minuscule. Donnez à cet attribut le nom d’une table alternative, ou false

Exemple d’utilisation :

class Exemple extends AppModel {
   var $useTable = false; // Ce modèle n'utilise pas de table de la base de données
}

Table alternative :

class Exemple extends AppModel {
   var $useTable = 'exmp'; // Ce modèle utilise la table 'exmp'
}

tablePrefix¶

Le nom du préfixe de la table utilisée par le modèle. Initialement, le préfixe utilisé est celui renseigné avec la connexion à la base de données dans /app/config/database.php. Par défaut il n’y a aucun préfixe. Vous pouvez surcharger la valeur par défaut en configurant l’attribut tablePrefix dans le modèle.

Exemple d’utilisation :

class Exemple extends AppModel {
   var $tablePrefix = 'alt_'; // cherchera la table 'alt_exemples'
}

primaryKey¶

Chaque table a normalement une clé primaire, id. Vous pouvez changer le champ qui sera utilisé par le modèle comme sa clé primaire. Ceci est fréquent lorsque l’on configure CakePHP pour utiliser une table existant déjà dans la base de données.

Exemple d’utilisation :

class Exemple extends AppModel {
    var $primaryKey = 'exemple_id'; // exemple_id est le nom du champ dans la base de données
}

displayField¶

L’attribut displayField spécifie quel champ de la base de données doit être utilisé comme intitulé pour l’enregistrement. L’intitulé est utilisé dans le maquettage rapide (scaffolding) ainsi que dans les appels à find('list'). Le modèle utilisera name ou title par défaut.

Par exemple, pour utiliser le champ pseudo :

class Utilisateur extends AppModel {
   var $displayField = 'pseudo';
}

Les noms de champs multiples ne peuvent pas être combinés en un unique champ à afficher. Par exemple, vous ne pouvez pas spécifier array('prenom', 'nom') comme le champ à afficher.

recursive¶

La propriété recursive définit la profondeur jusqu’à laquelle CakePHP doit récupérer les données des modèles associés, via les méthodes find(), findAll() et read().

Imaginons que votre application représente des Groupes qui appartiennent à un domaine et qui ont plusieurs Utilisateurs qui, à leur tour, ont plusieurs Articles. Vous pouvez attribuer à $recursive des valeurs différentes en fonction de la quantité de données que vous souhaitez récupérer en appelant $this->Groupe->find() :

Ne le fixer pas trop haut par rapport à vos besoins. Demander à CakePHP de récupérer des données dont vous n’avez pas besoin ralentit votre application inutilement.

Si vous voulez combiner $recursive avec la fonctionnalité fields, vous devrez ajouter manuellement les colonnes contenant les clés étrangères nécessaires dans le tableau fields. Dans l’exemple ci-dessus, cela pourrait être l’ajout de domaine_id

order¶

L’ordre par défaut des données lors de toute opération find. Les valeurs possibles sont :

var $order = "champ"
var $order = "Modele.champ";
var $order = "Modele.champ asc";
var $order = "Modele.champ ASC";
var $order = "Modele.champ DESC";
var $order = array("Modele.champ" => "asc", "Modele.champ2" => "DESC");

data¶

Le conteneur pour les données récupérées par le modèle. Bien que les données renvoyées depuis une classe de modèle sont en règle générale renvoyées par un appel à find(), vous pourriez avoir besoin d’accéder aux informations stockées dans $data à l’intérieur des callbacks du modèle.

_schema¶

Contient des méta-données décrivant les champs de la table de la base de données associée au modèle. Chaque champ est décrit par :

• nom

• type (integer, string, datetime, etc.)

• null

• valeur par défaut

• longueur

Exemple d’utilisation :

var $_schema = array(
    'prenom' => array(
        'type' => 'string',
        'length' => 30
    ),
    'nom' => array(
        'type' => 'string',
        'length' => 30
    ),
    'email' => array(
        'type' => 'string',
        'length' => 30
    ),
    'message' => array(
        'type' => 'text'
    )
);

validate¶

Cet attribut rassemble les règles permettant au modèle de décider de la validité des données avant une sauvegarde. Les clés mentionnées après le champ contiennent des expressions régulières permettant au modèle d’essayer de faire des correspondances.

Il n’est pas nécessaire d’appeler la méthode validate() avant save() : cette dernière validera automatiquement les données avant de sauvegarder de façon définitive.

Pour plus d’informations concernant la validation, regardez le chapitre Validation des données plus loin dans ce manuel

name¶

Comme vu plus tôt dans ce chapitre, l’attribut name est une caractéristique pour la compatibilité avec PHP4, il est fixé à la même valeur que le nom du modèle.

Exemple d’utilisation :

class Exemple extends AppModel {
   var $name = 'Exemple';
}

cacheQueries¶

Si il est mis à true, les données récupérées par le modèle lors d’une requête seule sont mises en cache. Cette mise en cache ne se fait qu’en mémoire et ne dure que le temps d’une requête. Ainsi, toutes les requêtes dupliquées pour les même données sont gérées par le cache.