Notre première application sera un simple formulaire d'enregistrement d'un nouvel utilisateur. Les données sont stockées dans une table SQL. Elle contiendra le nom, le prénom, l'identifiant, l'adresse email.
La table "utilisateurs".
Le numéro 'id' sera la clé primaire et l'identifiant ainsi que l'email seront uniques.
Pour MySQL :
CREATE TABLE 'utilisateurs' (
'id' INT( 10 ) NOT NULL AUTO_INCREMENT ,
'identifiant' VARCHAR( 40 ) NOT NULL ,
'motdepasse' VARCHAR( 40 ) NOT NULL ,
'email' VARCHAR( 255 ) NOT NULL ,
'prenom' VARCHAR( 40 ) NOT NULL ,
'nom' VARCHAR( 40 ) NOT NULL ,
'derniere_connexion' VARCHAR( 24 ) NOT NULL ,
PRIMARY KEY ('id'),
UNIQUE KEY 'identifiant' ('identifiant'),
UNIQUE KEY 'email' ('email')
Pour PostgreSQL :
CREATE TABLE utilisateurs
 id serial NOT NULL,
 identifiant character varying(40) NOT NULL,
 motdepasse character varying(40) NOT NULL,
 email character varying(255) NOT NULL,
 prenom character varying(40) NOT NULL,
 nom character varying(40) NOT NULL,
 derniere_connexion character varying(24),
 CONSTRAINT utilisateurs_pkey PRIMARY KEY (id),
 CONSTRAINT utilisateurs_email_key UNIQUE (email),
 CONSTRAINT utilisateurs_identifiant_key UNIQUE (identifiant)
Le modèle.
La table créée, nous devons créer un modèle pour interagir avec. Notre modèle "utilisateur" lira, insèrera et validera les données de la table mais pour l'instant c'est une ébauche.
<?php
class Utilisateur extends AppModel {
 var $name = 'Utilisateur';
?>
Enregistrez ce listing dans codice_1
La vue.
La vue "enregistrer" est notre formulaire d'enregistrement de nouveau compte utilisateur.
<?php echo $html->formTag('/utilisateurs/enregistrer') ?>
<p>Complétez le formulaire pour enregistrer votre compte.</p>
<label>Identifiant :</label><input name="identifiant" size="40" />
<label>Mot de passe :</label><input type="password" name="motdepasse" size="40" />
<label>Adresse email :</label><input name="email" size="40" maxlength="255" />
<label>Prénom :</label><input name="prenom" size="40" />
<label>Nom :</label><input name="nom" size="40" />
<input type="submit" value="enregistrer" />
</form>
Enregistrez ce listing dans codice_2
Le contrôleur.
Notre contrôleur va contenir les actions associées à notre modèle "Utilisateur". Une action correspond à une fonction, notre première action sera d'enregistrer les données. 
Un contrôleur CakePHP hérite d"'AppController".
<?php
class UtilisateursController extends AppController
 function enregistrer()
 //...
L'action "enregistrer" va devoir vérifier si le formulaire a bien été soumis. Ensuite notre action va sauvegarder ("$this->Utilisateur->save($this->params['form']") les données du formulaire (le tableau "$this->params['form']") dans la table en utilisant les clés du tableau comme nom de colonne et les valeurs comme une requête SQL d'insertion.
La table SQL doit se nommer d'après le nom de notre modèle ("Utilisateur") au pluriel (table "utilisateurs").
class UtilisateursController extends AppController
 function enregistrer()
 if (!empty($this->params['form']))
 if ($this->Utilisateur->save($this->params['form']))
 $this->flash('Enregistrement accepté.', '/utilisateur/enregistrer');
 } else {
 $this->flash('Problème avec votre enregistrement', '/utilisateur/enregistrer');
Enregistrez ce listing dans codice_3.
La methode Flash permet d'alerter l'utilisateur avec un message puis de renvoyer (2e paramètre) ici vers la vue du formulaire d'enregistrement.
Essais.
Il est temps d'observer le résultat, téléchargez les fichiers sur votre serveur puis allez à l'adresse :
 http://votre_serveur/utilisateurs/enregistrer
Normalement, votre enregistrement doit être accepté.
Votre table codice_4 doit contenir :
 cake_monapp=# select * from utilisateurs;
 id | identifiant | motdepasse | email | prenom | nom | derniere_connexion
 1 | Trygver | mvc | trygver@serveur.no | Trygve | Reenskaug |
Réessayer d'enregistrer les mêmes informations, vous obtiendrez un message d'erreur :
 SQL Error: ERROR: duplicate key violates unique constraint "utilisateurs_identifiant_key"
Ceci est dû au fait que la colonne codice_5 a été définie avec comme contrainte d'être unique en langage SQL. Avec des données différentes l'enregistrement est accepté.
Conclusion.
Dans ce premier exemple, nous avons juste défini une page formulaire simple (notre vue) et sa représentation dans la base de données. Notre traitement (le contrôleur) se limitant juste à vérifier que le formulaire a bien été saisi, tout le reste a été géré automatiquement. L’utilisation d’un cadriciel permet de ne pas avoir à tout réinventer afin d’éviter les erreurs et bugs courants de conception.

PostgreSQL
Grammaire néerlandaise/le nom/le diminutif

Le français, comme beaucoup d'autres langues, utilise de temps en temps une forme diminutive d'un mot, par exemple :
Dans la plupart des langues, le diminutif joue un rôle assez limité. Le néerlandais par contre a développé tout un système de diminutifs. On peut même dire que le suffixe diminutif est un des plus importants parmi le peu de suffixes vraiment productifs de la langue. Souvent le diminutif est aussi courant ou même plus courant que le nom lui-même. Il y a même des mots qui n'existent que sous forme de diminutif ou sous forme de diminutifs qui ont été "lexicalisés", c'est-à-dire qu'ils fonctionnent comme un mot nouveau qui signifient autre chose que le nom dont ils ont été dérivés.
Formation.
Le suffixe de base est "-je" dans la langue standardisée. Il y a des variations régionales : souvent "-je" est prononcé comme "-ie" et en Flandre, on entend souvent "-ke": man - manneke, comme par exemple dans "Manneke Pis".
Le diminutif est toujours neutre et son pluriel se forme en -s.
Souvent en prononciation "-je" cause la palatellisation de la consonne finale du nom. Ainsi "sj" dans "ja"sje se prononce un peu comme "si" en français "sien" (plutôt que "ch"ien, car le son du 'ch' français est rare en néerlandais). 
Les nasales et liquides finales sont fortifiés avec un plosif :
Après "-n,-l,-r" on trouve "-tje" :
Un "-ng" final devient "-nkje" si l'accent du mot se situe sur la syllabe pénultième:
Autrement "-ng" devient "-ngetje"
Après "-m" on trouve parfois "-pje" :
Mais dans le dernier cas on trouve aussi "-'etje" :
Cette insertion d'une autre syllabe est plus commune :
Si la voyelle change de courte en longue dans le pluriel, le diminutif peut suivre le pluriel :
Souvent il y a plusieurs formes :
Il y a des irrégularités dans les mots avec un pluriel en "-eren" :
Usage.
La base du diminutif est de contraster le petit et le grand, par exemple :
Un vase que l'on prend facilement dans une seule main est un "vaasje". Un vase plus grand "vaas". Un ticket est toujours "kaartje", tout comme une carte de visite : visitekaar"tje". On n'a pas vraiment besoin de deux mains dans un tel cas ! 
Ainsi c'est le diminutif qui est rencontré le plus souvent pour des objets de taille limitée.
Souvent le diminutif impart la connotation d'une certaine affection.
Une autre connotation est celle de la familiarité ou d'un usage inofficiel.
Une lettre officielle est toujours "brief". Un bout de papier quelconque peut être "briefje". Dans ces cas, le diminutif gagne un aspect péjoratif :
Lexicalisation.
Dans ce cas, on voit que le diminutif a évolué dans une direction particulière. Il y a des mots où la différence est plus grande. Un exemple qui existe aussi en français :
En hiver, s'il gèle, on trouve "ijs" sur un lac. Par contre, on mange "een ijsje" pour dessert. Et on peut même en manger une grande : "een groot ijsje".
Dans le dernier cas, la lexicalisation a fait perdre la connotation « de petite taille ».
Le suffixe diminutif n'est pas limité aux nom substantifs. On l'ajoute aux adjectifs avec un -s en formant des adverbes:
Il y même des phrases prépositionelles qui ont formé des noms nouveaux :
Dans le dernier cas, le nom "*onderons" n'existe pas. 
Il y plusieurs exemples de "diminutiva tanta", voir:

Tribologie/Applications pratiques/Fabrications mécaniques