| Home | ||||||||||||||
| Le tutoriel de Sashipa | ||||||||||||||
Deux tutoriels sont disponibles pour apprendre le langage Sashipa : l'article d'apprentissage de Sashipa au format pdf, ainsi que le contenu de cette page. Je vous recommande de commencer par l'article pdf, qui aborde le problème d'un point de vue pratique. Ensuite, vous pourrez parcourir cette page pour une approche plus théorique.
Précisions sur les bases de données | ||||||||||||||
| Introduction | ||||||||||||||
|
Sashipa est un format XML pour décrire des applications interfaces de bases de données relationnelles. Je donne ici quelques précisions sur les bases de données avec lesquelles Sashipa-Melba peut travailler. Voici un tutoriel pour écrire vos premières applications Sashipa. Il repose sur l'exemple de la base DemoContact. Si vous ne l'avez pas déjà installée, cliquez ici. |
||||||||||||||
| Bases de données relationnelles | ||||||||||||||
|
Une base de données relationnelle est un ensemble de tables composées chacunes de colonnes. Les données sont les lignes. On les appelle aussi enregistrements ou tuples. Une base est créée, puis interrogée, au moyen d'un langage standard : le SQL. Voici le script SQL de création de la base des Contacts : |
||||||||||||||
|
||||||||||||||
| Identifiants, les bonnes manières | ||||||||||||||
|
Chaque table dispose d'une clef primaire, le plus souvent composée d'une unique colonne de type integer (exemple: ProfessionId pour la table PROFESSION). Cette colonne servira exclusivement à identifier les lignes de façon unique au sein de la base. Les données mises dans cette colonne ne devront jamais être modifiées par la suite sous peine de rendre la base non intègre. En règle générale, les valeurs d'une clef primaire ne sont jamais affichées à l'utilisateur. En effet, si c'était le cas, l'utilisateur les utiliserait pour ses propres besoin (pour ses dossiers papier par exemple) et tôt ou tard aurait besoin de les modifier. L'utilisateur a besoin, lui aussi, d'identifier chaque ligne de la table. On utilise pour cela la contrainte UNIQUE qui fonctionne comme une clef primaire, sauf qu'elle ne permet pas de faire de liens entre les tables (exemple: ProfessionLabel pour la table PROFESSION). Pour chaque table, on peut donc distinguer l'identifiant "base de données" (la clef primaire) de l'identifiant "utilisateur" (la contrainte UNIQUE). Les liens entre les tables sont faits au moyen de clefs étrangères référençant les clefs primaires. Exemple: ProfessionRef dans la table CONTACT référence la colonne ProfessionId de la table PROFESSION. Ceci implique que les valeurs que l'on trouve dans CONTACT.ProfessionRef pointent sur les valeurs de PROFESSION.ProfessionId. De cette manière, on peut retrouver la profession de chaque contact. |
||||||||||||||
| Fonctionalités du SGBD à éviter ! | ||||||||||||||
|
Attention : inutile de déclarer la clef primaire comme auto-incrémentée. L'application s'en chargera automatiquement lors de l'insertion si ce champ n'a pas de valeur. Il risque donc d'y avoir conflit si le SGBD tente d'y affecter lui-même une valeur. Deuxième problème : les applications générées disposent d'un cache pour mémoriser les derniers enregistrements chargés. Ce cache est rafraichi lorsque la partie serveur (la servlet) signale une modification faite par une de ses applications clientes. Donc vous aurez des problèmes de cache non à jour si vous faites des modifications par triggers ou si un programme tiers accède à la base sans passer par la servlet. Plus grave : la gestion des transactions est faite par programme au niveau de la servlet. Donc si un programme tiers modifie des données sans passer par la servlet, il y a un risque de rendre la base non intègre. Surtout si votre SGBD ne gère pas l'intégrité référentielle. |
||||||||||||||
Aperçu d'un fichier Sashipa | ||||||||||||||
|
Vous trouverez le source ici. Voici pour commencer le squelette de l'application Contact en Sashipa. |
||||||||||||||
|
||||||||||||||
|
Les principales parties de ce fichier XML sont :
|
||||||||||||||
Environnement | ||||||||||||||
|
La première partie d'un fichier Sashipa est la description de l'environnement serveur. Le nom réel du serveur est stocké dans <physicalName>. Remarque : le nom 'dbmsMain' est interne au fichier Sashipa et sert quand des éléments du fichier font référence à ce serveur. Notez que c'est un point commun à chaque élément dans Sashipa : l'attribut "name" d'un composant sert uniquement à l'identification de celui-ci au sein du fichier Sashipa et ne correspond pas au nom réel. |
||||||||||||||
|
||||||||||||||
|
C'est ici, notamment, qu'est décrite la base de données DemoContact. Je donne ci-dessous la description de la table "PROFESSION" ainsi que de la colonne CONTACT.ProfessionRef pour un exemple de clef-étrangère. |
||||||||||||||
|
||||||||||||||
Graphical User Interface | ||||||||||||||
| Structure générale | ||||||||||||||
Voici la structure générale d'une GUI Sashipa. |
||||||||||||||
|
||||||||||||||
|
Important : le bloc <resourceName> contient le nom de la classe principale de l'application. La commande de lancement de votre application généré sera donc "java Contact" dans notre cas. Le bloc <mainScreenRef> précise le premier écran qui sera affiché lors du lancement de l'application. |
||||||||||||||
| Les composants de la GUI | ||||||||||||||
|
L'apparence de l'interface d'une base de données est fortement liée au schéma (la structure) de sa base de données. Sashipa distingue trois niveaux dans les composants de cette interface : les Screens, les Forms et les Fields. Je ne donne pas d'exemple de code XML pour les composants de la GUI. Je recommande au lecteur de se référer au code source pour visualiser concrètement ce qu'il lit. |
||||||||||||||
| Les Screens | ||||||||||||||
|
Une application interface de base de données affiche une succession d' écrans : ce sont les Screens. L'application n'affichera qu'un unique Screen à la fois. |
||||||||||||||
| Les Forms | ||||||||||||||
|
Un Screen est un conteneur de formulaires. Pour chaque table, on aura les formulaires suivant :
De plus, on crée les menus avec les MenuForm. Les menus sont indépendants des tables. Un menu permet d'ouvrir d'autres Screens. |
||||||||||||||
| Les Fields et FkFields | ||||||||||||||
|
Les formulaires CardForm et ResearchForm contiennent un ensemble de champs. Il existe deux catégories de champs :
Voici la liste des Fields disponibles :
Et la liste des FkFields :
|
||||||||||||||
| Conception en Sashipa | ||||||||||||||
|
Voici quelques notions théoriques sur comment déduire une interface graphique d'un schéma de base de données. |
||||||||||||||
| Incidence des clefs étrangères sur l'interface graphique | ||||||||||||||
|
Prenont comme exemple les tables CONTACT et CONTACTADRESSE. La table CONTACTADRESSE possède une clef étrangère composée d'une unique colonne ContactRef référençant la colonne CONTACT.ContactId . Une interface classique pour cette base sera : Screen 1 : Un menu (MenuForm) avec entre-autres un bouton menant au Screen 2. Screen 2 : Un ListForm contenant la totalité des lignes présentes dans la table CONTACT. Si l'on double-clique sur une des lignes, on ouvre le Screen 3. Screen 3 :
Screen 4 : Un CardForm pour afficher la fiche de l'adresse (une ligne de CONTACTADRESSE). De plus, dans ce CardForm, on aura un FkField pour afficher / choisir le contact auquel cette adresse est liée. |
||||||||||||||
| Plus généralement, une clef-étrangère implique : | ||||||||||||||
|
||||||||||||||
| Notion de filtres | ||||||||||||||
|
Quand l'application ouvre un Screen, elle lui propose une liste ordonnée de filtres ainsi que le filtre courant. Un filtre est, au sens Sashipa du terme, la valeur d'une clef primaire. Le Screen gère ensuite le passage d'un filtre à l'autre dans la liste ordonnée avec les boutons Précédents et Suivants. Lorsque le Screen dispose d'un nouveau filtre, il le signale à ses formulaires. Ceux-ci réagissent de façon différente :
Les champs FkFields sont aussi sensibles aux filtres, de la même manière qu'un ListForm. Remarque: ces comportements par défaut peuvent être paramétrés au moyen de CastFilter. |
||||||||||||||
L'architecture générée | ||||||||||||||
|
Toutes les informations spécifiques à votre environnement sont décrites ici : le type de SGBD, les informations de connexion (login, mot de passe, ...) à votre base de données, etc.. |
||||||||||||||
|
||||||||||||||
|
On remarque l'attribut guiType='application' qui signifie qu'une application sera générée. Pour générer une applet, il suffit de le changer en guiType='applet'. L'attribut database='dbContact' fait référence à la base décrite dans la partie Environment. L'attribut architecture='clientDatabase' signifie que l'architecture de l'application générée est client-base de données. Pour construire une architecture client-servlet-base de données, il suffit de modifier ceci en architecture='clientServerDatabase'. Cependant, aujourd'hui tous les fichiers construits sont regroupés dans une unique archive. Il vous faudra donc désarchiver manuellement pour séparer la servlet de la partie cliente. Note : le bloc <specificToServer> n'est utilisé que pour une architecture avec servlet. Sinon il est ignoré. On y trouve le nom de la classe de la servlet, ainsi que l'url utilisée par la partie cliente pour accéder à la servlet. Les fichiers journaux de votre application, gérés par la couche d'accès au données, sont précisés ici aussi. Enfin, vous choisissez la langue dans laquelle votre application travaillera. |
||||||||||||||
J'espère que cette technologie vous sera utile. | ||||||||||||||
Bon courage, | ||||||||||||||
Annexes | ||||||||||||||
| Glossaire | ||||||||||||||
|
||||||||||||||
| Haut |