2013
Dernière modification le:
03.07.2013
Date de création:
26.04.2012
Version du document:
1.0
Type de réalisation:
Intra-muros
D - Pratique
APIs de table pour SQL Server
Établissement:
HEG Arc Haute école Arc Gestion
Réalisé par:
M. Arnaud Senft
Informaticien de gestion 2009-2013
S’adresse à:
M.Fabrice Camus
Date de début et de fin du travail de
Bachelor
08.04.2013 05.07. 2013
APIs de table pour SQL Server Rapport pratique
Arnaud Senft
Page 2 sur 42
Sommaire
1 Introduction .................................................................................................................... 4
2 Avant-Projet ................................................................................................................... 5
2.1 Planification ............................................................................................................. 5
2.2 Planifié .................................................................................................................... 5
2.3 Réali.................................................................................................................... 6
2.4 Administration du projet ........................................................................................... 7
2.5 Analyse des risques ................................................................................................ 8
2.6 Technologies utilisées ............................................................................................10
3 Convention de nommage ..............................................................................................11
4 Valeurs taguées utilisées ...............................................................................................12
5 Fonctionnement du plugin .............................................................................................15
5.1 Principe de base ....................................................................................................15
5.2 Déclenchement du plugin .......................................................................................16
5.2.1 Prérequis .........................................................................................................16
5.2.2 Utilisation ........................................................................................................16
5.2.3 Sélection des tables ........................................................................................17
5.2.4 Schéma de fonctionnement .............................................................................18
6 L’utilité concrète du plugin .............................................................................................19
6.1 Avant exécution du plugin ......................................................................................19
6.2 Résultat de l’exécution ...........................................................................................20
7 Développement .............................................................................................................25
7.1 Génération des scripts d’APIs de tables .................................................................25
7.2 Génération des logs ...............................................................................................25
7.3 Exécution des scripts .............................................................................................26
7.3.1 Tables de journalisation ..................................................................................26
7.3.2 Tables de journalisation des exceptions ..........................................................26
7.3.3 Colonnes d’audit .............................................................................................26
7.3.4 Triggers ...........................................................................................................27
7.3.5 Procédures stockées .......................................................................................27
7.5 Abstraction des scripts ...........................................................................................28
7.5.1 Génération des procédures .............................................................................28
7.5.2 Génération du code SQL DDL .........................................................................28
7.5.3 Génération des triggers ...................................................................................29
7.6 Paramétrage du plugin ...........................................................................................30
APIs de table pour SQL Server Rapport pratique
Arnaud Senft
Page 3 sur 42
7.6.1 Plugin.properties .............................................................................................30
7.6.2 database.properties ........................................................................................32
7.7 Script de déploiement .............................................................................................33
7.8 Tests ......................................................................................................................34
7.8.1 Tests unitaires .................................................................................................34
7.8.2 Tests par l’utilisation ........................................................................................34
7.9 Gestion des erreurs ................................................................................................35
7.9.1 Implémentation de la gestion des messages et logs .......................................35
7.9.2 Affichage de messages à l’utilisateur ..............................................................35
7.9.3 Exceptions ......................................................................................................36
8 Ajout d’un nouveau SGBDR ..........................................................................................37
9 Amélioration ..................................................................................................................40
9.1 Récupérer une connexion de Visual Paradigm .......................................................40
9.2 Affichage de popup ................................................................................................41
9.3 Gérer les modifications incrémentales des APIs de table .......................................41
9.4 Revoir la séparation des fichiers de propriétés .......................................................41
10 Conclusion .................................................................................................................42
APIs de table pour SQL Server Rapport pratique
Arnaud Senft
Page 4 sur 42
1 Introduction
Ce document va présenter la démarche entreprise afin de parvenir à l’aboutissement du
travail.
Les chapitres sont ordonnés de façon à ce que le premier corresponde à la première
démarche entreprise et le dernier à la dernière démarche.
Le premier chapitre présente la planification mise en place afin de réaliser ce projet ainsi
qu’une analyse des risques et une présentation des différentes technologies utilisées. Le
deuxième chapitre présente les différentes conventions de nommage mises en place. Le
suivant expose et explique les différentes valeurs taguées utilisées. Le chapitre 5 présente le
fonctionnement du plugin dans son ensemble. Le sixième chapitre démontre l’utilité de celui-
ci. Le chapitre 7 présente quelques éléments concernant le développement propre du plugin.
Le chapitre 8 explique la procédure d’ajout d’un nouveau SGBDR au sein du plugin. Le
chapitre suivant présente les différentes améliorations possibles. Le dernier chapitre conclut
ce projet.
APIs de table pour SQL Server Rapport pratique
Arnaud Senft
Page 5 sur 42
2 Avant-Projet
2.1 Planification
Ci-dessous, une présentation de l’organisation des 12 semaines à dispositions afin de
réaliser ce dit travail. Le but originel de cette planification était d’organiser le travail plutôt que
de déterminer que la tâche A doit être terminée en semaine 2.
J’ai pris la décision de ne pas utiliser de méthode de gestion de projet, à la mode, tel Agile
car mon projet ne se prête que très peu à ce type d’organisation. Effectivement, il m’a été
demandé de réaliser chaque tâche de façon complète et non incrémentale comme la
méthode Agile le préconise. De plus, je suis seul sur ce projet. Je ne vois donc que très peu
l’intérêt d’utiliser une telle méthode.
Tout du moins, une organisation se basant sur des itérations a été utilisée. À la fin de
chacune de celle-ci, il a été décidé, conjointement avec mon directeur de travail, de livrer le
plugin.
2.2 Planifié
Tâche
12 avril
19 avril
26 avril
3 mai
8 mai
24 mai
7 juin
28 juin
5 juillet
Rédaction de la demande de ratification
Analyse du plugin
Itération 1
Itération 2
Itération 3
Itération 4
Rédaction des rapports
Test global
1 / 42 100%
La catégorie de ce document est-elle correcte?
Merci pour votre participation!

Faire une suggestion

Avez-vous trouvé des erreurs dans linterface ou les textes ? Ou savez-vous comment améliorer linterface utilisateur de StudyLib ? Nhésitez pas à envoyer vos suggestions. Cest très important pour nous !